Subversion Repositories HelenOS-historic

Rev

Rev 1020 | Rev 1053 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1020 Rev 1023
Line 34... Line 34...
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 
 
 40 
 
40 
#define THREADS     150*2
 41 
#define THREADS     15*2
41 
#define ATTEMPTS    100
 42 
#define ATTEMPTS    10
42 
 
 43 
 
43 
#define E_10e8  271828182
 44 
#define E_10e8  271828182
44 
#define PI_10e8 314159265
 45 
#define PI_10e8 314159265
45 
 
 46 
 
- 
 
 47 
 
- 
 
 48 
#ifdef __ia32_ARCH_H__
- 
 
 49 
static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
- 
 
 50 
#endif
- 
 
 51 
 
- 
 
 52 
#ifdef __amd64_ARCH_H__
46 
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
- 
 
 55 
 
- 
 
 56 
#ifdef __ia64_ARCH_H__
- 
 
 57 
static inline long double sqrt(long double a)
- 
 
 58 
{  
- 
 
 59 
    long double x = 1;
- 
 
 60 
    long double lx = 0;
- 
 
 61 
 
- 
 
 62 
    if(a<0.00000000000000001) return 0;
- 
 
 63 
       
- 
 
 64 
    while(x!=lx)
- 
 
 65 
    {
- 
 
 66 
        lx=x;
- 
 
 67 
        x=(x+(a/x))/2;
- 
 
 68 
    }
- 
 
 69 
    return x;
- 
 
 70 
}
- 
 
 71 
#endif
- 
 
 72 
 
- 
 
 73 
 
47 
 
 74 
 
48 
static atomic_t threads_ok;
 75 
static atomic_t threads_ok;
49 
static waitq_t can_start;
 76 
static waitq_t can_start;
50 
 
 77 
 
51 
static void e(void *data)
 78 
static void e(void *data)
Line 73... Line 100...
73 
    atomic_inc(&threads_ok);
 100 
    atomic_inc(&threads_ok);
74 
}
 101 
}
75 
 
 102 
 
76 
static void pi(void *data)
 103 
static void pi(void *data)
77 
{
 104 
{
- 
 
 105 
 
- 
 
 106 
#ifdef __ia64_ARCH_H__
- 
 
 107 
#undef PI_10e8 
- 
 
 108 
#define PI_10e8 3141592
- 
 
 109 
#endif
- 
 
 110 
 
78 
    int i;
 111 
    int i;
79 
    double lpi, pi;
 112 
    double lpi, pi;
80 
    double n, ab, ad;
 113 
    double n, ab, ad;
81 
 
 114 
 
82 
    waitq_sleep(&can_start);
 115 
    waitq_sleep(&can_start);
Line 94... Line 127...
94 
            ad = sqrt(ab*ab/4 + cd*cd);
 127 
            ad = sqrt(ab*ab/4 + cd*cd);
95 
            lpi = pi;
 128 
            lpi = pi;
96 
            pi = 2 * n * ad;
 129 
            pi = 2 * n * ad;
97 
        }
 130 
        }
98 
 
 131 
 
- 
 
 132 
#ifdef __ia64_ARCH_H__
- 
 
 133 
        if((int)(1000000*pi)!=PI_10e8)
- 
 
 134 
            panic("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (1000000*pi),(__native) (PI_10e8/100));
- 
 
 135 
#else
99 
        if((int)(100000000*pi)!=PI_10e8)
 136 
        if((int)(100000000*pi)!=PI_10e8)
100 
            panic("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
 137 
            panic("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
- 
 
 138 
#endif
- 
 
 139 
 
101 
    }
 140 
    }
102 
 
 141 
 
103 
    printf("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
 142 
    printf("tid%d: pi*10e8=%d should be %d\n", THREAD->tid, (__native) (100000000*pi),(__native) PI_10e8);
104 
    atomic_inc(&threads_ok);
 143 
    atomic_inc(&threads_ok);
105 
}
 144 
}
Line 131... Line 170...
131 
    while (atomic_get(&threads_ok) != THREADS)
 170 
    while (atomic_get(&threads_ok) != THREADS)
132 
        ;
 171 
        ;
133 
       
 172 
       
134 
    printf("Test passed.\n");
 173 
    printf("Test passed.\n");
135 
}
 174 
}
- 
 
 175 
 
- 
 
 176 
/*
- 
 
 177 
static void pi(void *data)
- 
 
 178 
{
- 
 
 179 
#undef PI_10e8 
- 
 
 180 
#define PI_10e8 3141592
- 
 
 181 
 
- 
 
 182 
 
- 
 
 183 
    int i;
- 
 
 184 
    double lpi, pi;
- 
 
 185 
    double n, ab, ad;
- 
 
 186 
 
- 
 
 187 
 
- 
 
 188 
    printf("pi test\n");
- 
 
 189 
 
- 
 
 190 
    waitq_sleep(&can_start);
- 
 
 191 
 
- 
 
 192 
 
- 
 
 193 
    for (i = 0; i<ATTEMPTS; i++) {
- 
 
 194 
        lpi = -1;
- 
 
 195 
        pi = 0;
- 
 
 196 
 
- 
 
 197 
        for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
- 
 
 198 
            double sc, cd;
- 
 
 199 
 
- 
 
 200 
            sc = sqrt(1 - (ab*ab/4));
- 
 
 201 
            cd = 1 - sc;
- 
 
 202 
            ad = sqrt(ab*ab/4 + cd*cd);
- 
 
 203 
            lpi = pi;
- 
 
 204 
            pi = 2 * n * ad;
- 
 
 205 
        }
- 
 
 206 
 
- 
 
 207 
        atomic_inc(&threads_ok);
- 
 
 208 
        if((int)(1000000*pi)!=PI_10e8)
- 
 
 209 
            panic("tid%d: pi*10e6=%d\n", THREAD->tid, (int) 1000000*pi);
- 
 
 210 
    }
- 
 
 211 
 
- 
 
 212 
    printf("tid%d: pi*10e6=%d\n", THREAD->tid, (int) 1000000*pi);
- 
 
 213 
}
- 
 
 214 
*/