Subversion Repositories HelenOS-historic

Rev

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

Rev 91 Rev 92
Line 41... Line 41...
41 
#include <arch.h>
 41 
#include <arch.h>
42 
#include <arch/smp/atomic.h>
 42 
#include <arch/smp/atomic.h>
43 
#include <proc/thread.h>
 43 
#include <proc/thread.h>
44 
 
 44 
 
45 
#define THREADS     150*2
 45 
#define THREADS     150*2
- 
 
 46 
#define ATTEMPTS    10
46 
 
 47 
 
47 
#define E_10e8  271828182
 48 
#define E_10e8  271828182
48 
#define PI_10e8 314159265
 49 
#define PI_10e8 314159265
49 
 
 50 
 
50 
static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
 51 
static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
Line 52... Line 53...
52 
static volatile int threads_ok;
 53 
static volatile int threads_ok;
53 
static waitq_t can_start;
 54 
static waitq_t can_start;
54 
 
 55 
 
55 
static void e(void *data)
 56 
static void e(void *data)
56 
{
 57 
{
- 
 
 58 
    int i;
57 
    double e,d,le,f;
 59 
    double e,d,le,f;
58 
    le=-1;
 - 
 
59 
    e=0;
 - 
 
60 
    f=1;
 - 
 
61 
 
 60 
 
62 
    waitq_sleep(&can_start);
 61 
    waitq_sleep(&can_start);
63 
 
 62 
 
- 
 
 63 
    for (i = 0; i<ATTEMPTS; i++) {
- 
 
 64 
        le=-1;
- 
 
 65 
        e=0;
- 
 
 66 
        f=1;
- 
 
 67 
 
64 
    for(d=1;e!=le;d*=f,f+=1) {
 68 
        for(d=1;e!=le;d*=f,f+=1) {
65 
        le=e;
 69 
            le=e;
66 
        e=e+1/d;
 70 
            e=e+1/d;
67 
    }
 71 
        }
68 
 
 72 
 
69 
    if((int)(100000000*e)==E_10e8) {
 73 
        if((int)(100000000*e)!=E_10e8)
70 
        atomic_inc((int *) &threads_ok);
 74 
            panic("tid%d: e*10e8=%d\n", THREAD->tid, (int) 100000000*e);
71 
    }
 75 
    }
72 
    else
 76 
 
73 
        printf("tid%d: e*10e8=%d)\n", THREAD->tid, (int) 100000000*e);
 77 
    atomic_inc((int *) &threads_ok);
74 
}
 78 
}
75 
 
 79 
 
76 
static void pi(void *data)
 80 
static void pi(void *data)
77 
{
 81 
{
- 
 
 82 
    int i;
78 
        double lpi = -1, pi = 0;
 83 
        double lpi, pi;
79 
        double ab, ad;
 84 
        double n, ab, ad;
80 
        int n;
 - 
 
81 
 
 85 
 
82 
    waitq_sleep(&can_start);
 86 
    waitq_sleep(&can_start);
83 
 
 87 
 
84 
        for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
 - 
 
85 
                double sc, cd;
 - 
 
86 
 
 88 
 
- 
 
 89 
    for (i = 0; i<ATTEMPTS; i++) {
- 
 
 90 
        lpi = -1;
- 
 
 91 
        pi = 0;
- 
 
 92 
 
- 
 
 93 
            for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
- 
 
 94 
                    double sc, cd;
- 
 
 95 
 
87 
                sc = sqrt(1 - (ab*ab/4));
 96 
                    sc = sqrt(1 - (ab*ab/4));
88 
                cd = 1 - sc;
 97 
                    cd = 1 - sc;
89 
                ad = sqrt(ab*ab/4 + cd*cd);
 98 
                    ad = sqrt(ab*ab/4 + cd*cd);
90 
                lpi = pi;
 99 
                    lpi = pi;
91 
                pi = 2 * n * ad;
 100 
                    pi = 2 * n * ad;
92 
        }
 101 
            }
93 
 
 102 
 
94 
    if((int)(100000000*pi)==PI_10e8) {
 103 
        if((int)(100000000*pi)!=PI_10e8)
95 
        atomic_inc((int *) &threads_ok);
 104 
            panic("tid%d: pi*10e8=%d\n", THREAD->tid, (int) 100000000*pi);
96 
    }
 105 
    }
97 
    else
 106 
 
98 
        printf("tid%d: pi*10e8=%d)\n", THREAD->tid, (int) 100000000*pi);
 107 
    atomic_inc((int *) &threads_ok);
99 
}
 108 
}
100 
 
 109 
 
101 
 
 110 
 
102 
void test(void)
 111 
void test(void)
103 
{
 112 
{