WebSVN – HelenOS-historic – Diff – /kernel/trunk/test/fpu/fpu1/test.c


/*
 * Copyright (C) 2005 Jakub Vana
 * Copyright (C) 2005 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <print.h>
#include <debug.h>
#include <panic.h>
 
#include <test.h>
#include <arch/atomic.h>
#include <proc/thread.h>
 
#include <arch.h>
#include <arch/arch.h>
 
#define THREADS     150*2
#define ATTEMPTS    100
 
#define E_10e8  271828182
#define PI_10e8 314159265
 
 
#ifdef __ia32_ARCH_H__
static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
#endif
 
#ifdef __amd64_ARCH_H__
static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
#endif
 
#ifdef __ia64_ARCH_H__
static inline long double sqrt(long double a)
{  
    long double x = 1;
    long double lx = 0;
 
    if(a<0.00000000000000001) return 0;
       
    while(x!=lx)
    {
        lx=x;
        x=(x+(a/x))/2;
    }
    return x;
}
#endif
 
 
 
static atomic_t threads_ok;
static waitq_t can_start;
 
static void e(void *data)
{
    int i;
    double e,d,le,f;
 
    waitq_sleep(&can_start);
 
    for (i = 0; i<ATTEMPTS; i++) {
        le=-1;
        e=0;
        f=1;
 
        for(d=1;e!=le;d*=f,f+=1) {
            le=e;
            e=e+1/d;
        }
 
        if((int)(100000000*e)!=E_10e8)
            panic("tid%d: e*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*e),(__native) E_10e8);
    }
 
    printf("tid%d: e*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*e),(__native) E_10e8);
    atomic_inc(&threads_ok);
}
 
static void pi(void *data)
{
 
#ifdef __ia64_ARCH_H__
#undef PI_10e8  
#define PI_10e8 3141592
#endif
 
    int i;
    double lpi, pi;
    double n, ab, ad;
 
    waitq_sleep(&can_start);
 
 
    for (i = 0; i<ATTEMPTS; i++) {
        lpi = -1;
        pi = 0;
 
        for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
            double sc, cd;
 
            sc = sqrt(1 - (ab*ab/4));
            cd = 1 - sc;
            ad = sqrt(ab*ab/4 + cd*cd);
            lpi = pi;
            pi = 2 * n * ad;
        }
 
#ifdef __ia64_ARCH_H__
        if((int)(1000000*pi)!=PI_10e8)
            panic("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (1000000*pi),(__native) (PI_10e8/100));
#else
        if((int)(100000000*pi)!=PI_10e8)
            panic("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
#endif
 
    }
 
    printf("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
    atomic_inc(&threads_ok);
}
 
 
void test(void)
{
    thread_t *t;
    int i;
 
    waitq_initialize(&can_start);
 
    printf("FPU test #1\n");
    printf("Creating %d threads... ", THREADS);
 
    for (i=0; i<THREADS/2; i++) {  
        if (!(t = thread_create(e, NULL, TASK, 0)))
            panic("could not create thread\n");
        thread_ready(t);
        if (!(t = thread_create(pi, NULL, TASK, 0)))
            panic("could not create thread\n");
        thread_ready(t);
    }
    printf("ok\n");
   
    thread_sleep(1);
    waitq_wakeup(&can_start, WAKEUP_ALL);
 
    while (atomic_get(&threads_ok) != THREADS)
        ;
       
    printf("Test passed.\n");
}
 
/*
static void pi(void *data)
{
#undef PI_10e8 
#define PI_10e8 3141592
 
 
    int i;
    double lpi, pi;
    double n, ab, ad;
 
 
    printf("pi test\n");
 
    waitq_sleep(&can_start);
 
 
    for (i = 0; i<ATTEMPTS; i++) {
        lpi = -1;
        pi = 0;
 
        for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
            double sc, cd;
 
            sc = sqrt(1 - (ab*ab/4));
            cd = 1 - sc;
            ad = sqrt(ab*ab/4 + cd*cd);
            lpi = pi;
            pi = 2 * n * ad;
        }
 
        atomic_inc(&threads_ok);
        if((int)(1000000*pi)!=PI_10e8)
            panic("tid%d: pi*10e6=%d\n", THREAD->tid, (int) 1000000*pi);
    }
 
    printf("tid%d: pi*10e6=%d\n", THREAD->tid, (int) 1000000*pi);
}
*/
 

Rev 1023	Rev 1053
1	/*	1	/*
2	* Copyright (C) 2005 Jakub Vana	2	* Copyright (C) 2005 Jakub Vana
3	* Copyright (C) 2005 Jakub Jermar	3	* Copyright (C) 2005 Jakub Jermar
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	#include <print.h>	30	#include <print.h>
31	#include <debug.h>	31	#include <debug.h>
32	#include <panic.h>	32	#include <panic.h>
33		33
34	#include <test.h>	34	#include <test.h>
35	#include <arch/atomic.h>	35	#include <arch/atomic.h>
36	#include <proc/thread.h>	36	#include <proc/thread.h>
37		37
38	#include <arch.h>	38	#include <arch.h>
39	#include <arch/arch.h>	39	#include <arch/arch.h>
40		40
41	#define THREADS 15*2	41	#define THREADS 150*2
42	#define ATTEMPTS 10	42	#define ATTEMPTS 100
43		43
44	#define E_10e8 271828182	44	#define E_10e8 271828182
45	#define PI_10e8 314159265	45	#define PI_10e8 314159265
46		46
47		47
48	#ifdef __ia32_ARCH_H__	48	#ifdef __ia32_ARCH_H__
49	static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }	49	static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
50	#endif	50	#endif
51		51
52	#ifdef __amd64_ARCH_H__	52	#ifdef __amd64_ARCH_H__
53	static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }	53	static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
54	#endif	54	#endif
55		55
56	#ifdef __ia64_ARCH_H__	56	#ifdef __ia64_ARCH_H__
57	static inline long double sqrt(long double a)	57	static inline long double sqrt(long double a)
58	{	58	{
59	long double x = 1;	59	long double x = 1;
60	long double lx = 0;	60	long double lx = 0;
61		61
62	if(a<0.00000000000000001) return 0;	62	if(a<0.00000000000000001) return 0;
63		63
64	while(x!=lx)	64	while(x!=lx)
65	{	65	{
66	lx=x;	66	lx=x;
67	x=(x+(a/x))/2;	67	x=(x+(a/x))/2;
68	}	68	}
69	return x;	69	return x;
70	}	70	}
71	#endif	71	#endif
72		72
73		73
74		74
75	static atomic_t threads_ok;	75	static atomic_t threads_ok;
76	static waitq_t can_start;	76	static waitq_t can_start;
77		77
78	static void e(void *data)	78	static void e(void *data)
79	{	79	{
80	int i;	80	int i;
81	double e,d,le,f;	81	double e,d,le,f;
82		82
83	waitq_sleep(&can_start);	83	waitq_sleep(&can_start);
84		84
85	for (i = 0; i<ATTEMPTS; i++) {	85	for (i = 0; i<ATTEMPTS; i++) {
86	le=-1;	86	le=-1;
87	e=0;	87	e=0;
88	f=1;	88	f=1;
89		89
90	for(d=1;e!=le;d*=f,f+=1) {	90	for(d=1;e!=le;d*=f,f+=1) {
91	le=e;	91	le=e;
92	e=e+1/d;	92	e=e+1/d;
93	}	93	}
94		94
95	if((int)(100000000*e)!=E_10e8)	95	if((int)(100000000*e)!=E_10e8)
96	panic("tid%d: e10e8=%d should be %d\n", THREAD->tid, (__native) (100000000e),(__native) E_10e8);	96	panic("tid%d: e10e8=%d should be %d\n", THREAD->tid, (__native) (100000000e),(__native) E_10e8);
97	}	97	}
98		98
99	printf("tid%d: e10e8=%d should be %d\n", THREAD->tid, (__native) (100000000e),(__native) E_10e8);	99	printf("tid%d: e10e8=%d should be %d\n", THREAD->tid, (__native) (100000000e),(__native) E_10e8);
100	atomic_inc(&threads_ok);	100	atomic_inc(&threads_ok);
101	}	101	}
102		102
103	static void pi(void *data)	103	static void pi(void *data)
104	{	104	{
105		105
106	#ifdef __ia64_ARCH_H__	106	#ifdef __ia64_ARCH_H__
107	#undef PI_10e8	107	#undef PI_10e8
108	#define PI_10e8 3141592	108	#define PI_10e8 3141592
109	#endif	109	#endif
110		110
111	int i;	111	int i;
112	double lpi, pi;	112	double lpi, pi;
113	double n, ab, ad;	113	double n, ab, ad;
114		114
115	waitq_sleep(&can_start);	115	waitq_sleep(&can_start);
116		116
117		117
118	for (i = 0; i<ATTEMPTS; i++) {	118	for (i = 0; i<ATTEMPTS; i++) {
119	lpi = -1;	119	lpi = -1;
120	pi = 0;	120	pi = 0;
121		121
122	for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {	122	for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
123	double sc, cd;	123	double sc, cd;
124		124
125	sc = sqrt(1 - (ab*ab/4));	125	sc = sqrt(1 - (ab*ab/4));
126	cd = 1 - sc;	126	cd = 1 - sc;
127	ad = sqrt(abab/4 + cdcd);	127	ad = sqrt(abab/4 + cdcd);
128	lpi = pi;	128	lpi = pi;
129	pi = 2 * n * ad;	129	pi = 2 * n * ad;
130	}	130	}
131		131
132	#ifdef __ia64_ARCH_H__	132	#ifdef __ia64_ARCH_H__
133	if((int)(1000000*pi)!=PI_10e8)	133	if((int)(1000000*pi)!=PI_10e8)
134	panic("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (1000000pi),(__native) (PI_10e8/100));	134	panic("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (1000000pi),(__native) (PI_10e8/100));
135	#else	135	#else
136	if((int)(100000000*pi)!=PI_10e8)	136	if((int)(100000000*pi)!=PI_10e8)
137	panic("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (100000000pi),(__native) PI_10e8);	137	panic("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (100000000pi),(__native) PI_10e8);
138	#endif	138	#endif
139		139
140	}	140	}
141		141
142	printf("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (100000000pi),(__native) PI_10e8);	142	printf("tid%d: pi10e8=%d should be %d\n", THREAD->tid, (__native) (100000000pi),(__native) PI_10e8);
143	atomic_inc(&threads_ok);	143	atomic_inc(&threads_ok);
144	}	144	}
145		145
146		146
147	void test(void)	147	void test(void)
148	{	148	{
149	thread_t *t;	149	thread_t *t;
150	int i;	150	int i;
151		151
152	waitq_initialize(&can_start);	152	waitq_initialize(&can_start);
153		153
154	printf("FPU test #1\n");	154	printf("FPU test #1\n");
155	printf("Creating %d threads... ", THREADS);	155	printf("Creating %d threads... ", THREADS);
156		156
157	for (i=0; i<THREADS/2; i++) {	157	for (i=0; i<THREADS/2; i++) {
158	if (!(t = thread_create(e, NULL, TASK, 0)))	158	if (!(t = thread_create(e, NULL, TASK, 0)))
159	panic("could not create thread\n");	159	panic("could not create thread\n");
160	thread_ready(t);	160	thread_ready(t);
161	if (!(t = thread_create(pi, NULL, TASK, 0)))	161	if (!(t = thread_create(pi, NULL, TASK, 0)))
162	panic("could not create thread\n");	162	panic("could not create thread\n");
163	thread_ready(t);	163	thread_ready(t);
164	}	164	}
165	printf("ok\n");	165	printf("ok\n");
166		166
167	thread_sleep(1);	167	thread_sleep(1);
168	waitq_wakeup(&can_start, WAKEUP_ALL);	168	waitq_wakeup(&can_start, WAKEUP_ALL);
169		169
170	while (atomic_get(&threads_ok) != THREADS)	170	while (atomic_get(&threads_ok) != THREADS)
171	;	171	;
172		172
173	printf("Test passed.\n");	173	printf("Test passed.\n");
174	}	174	}
175		175
176	/*	176	/*
177	static void pi(void *data)	177	static void pi(void *data)
178	{	178	{
179	#undef PI_10e8	179	#undef PI_10e8
180	#define PI_10e8 3141592	180	#define PI_10e8 3141592
181		181
182		182
183	int i;	183	int i;
184	double lpi, pi;	184	double lpi, pi;
185	double n, ab, ad;	185	double n, ab, ad;
186		186
187		187
188	printf("pi test\n");	188	printf("pi test\n");
189		189
190	waitq_sleep(&can_start);	190	waitq_sleep(&can_start);
191		191
192		192
193	for (i = 0; i<ATTEMPTS; i++) {	193	for (i = 0; i<ATTEMPTS; i++) {
194	lpi = -1;	194	lpi = -1;
195	pi = 0;	195	pi = 0;
196		196
197	for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {	197	for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
198	double sc, cd;	198	double sc, cd;
199		199
200	sc = sqrt(1 - (ab*ab/4));	200	sc = sqrt(1 - (ab*ab/4));
201	cd = 1 - sc;	201	cd = 1 - sc;
202	ad = sqrt(abab/4 + cdcd);	202	ad = sqrt(abab/4 + cdcd);
203	lpi = pi;	203	lpi = pi;
204	pi = 2 * n * ad;	204	pi = 2 * n * ad;
205	}	205	}
206		206
207	atomic_inc(&threads_ok);	207	atomic_inc(&threads_ok);
208	if((int)(1000000*pi)!=PI_10e8)	208	if((int)(1000000*pi)!=PI_10e8)
209	panic("tid%d: pi10e6=%d\n", THREAD->tid, (int) 1000000pi);	209	panic("tid%d: pi10e6=%d\n", THREAD->tid, (int) 1000000pi);
210	}	210	}
211		211
212	printf("tid%d: pi10e6=%d\n", THREAD->tid, (int) 1000000pi);	212	printf("tid%d: pi10e6=%d\n", THREAD->tid, (int) 1000000pi);
213	}	213	}
214	*/	214	*/
215		215

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/test/fpu/fpu1/test.c – Rev 1023 → 1053