Subversion Repositories HelenOS-historic

Rev

Rev 91 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 91 Rev 92
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 <arch/interrupt.h>
 30 
#include <arch/interrupt.h>
31 
#include <print.h>
 31 
#include <print.h>
32 
#include <debug.h>
 32 
#include <debug.h>
33 
#include <panic.h>
 33 
#include <panic.h>
34 
#include <arch/i8259.h>
 34 
#include <arch/i8259.h>
35 
#include <func.h>
 35 
#include <func.h>
36 
#include <cpu.h>
 36 
#include <cpu.h>
37 
#include <arch/asm.h>
 37 
#include <arch/asm.h>
38 
#include <mm/tlb.h>
 38 
#include <mm/tlb.h>
39 
 
 39 
 
40 
#include <test.h>
 40 
#include <test.h>
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; }
51 
 
 52 
 
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 
{
104 
    thread_t *t;
 113 
    thread_t *t;
105 
    int i;
 114 
    int i;
106 
 
 115 
 
107 
    waitq_initialize(&can_start);
 116 
    waitq_initialize(&can_start);
108 
 
 117 
 
109 
    printf("FPU test #1\n");
 118 
    printf("FPU test #1\n");
110 
    printf("Creating %d threads... ", THREADS);
 119 
    printf("Creating %d threads... ", THREADS);
111 
 
 120 
 
112 
    for (i=0; i<THREADS/2; i++) {  
 121 
    for (i=0; i<THREADS/2; i++) {  
113 
        if (!(t = thread_create(e, NULL, TASK, 0)))
 122 
        if (!(t = thread_create(e, NULL, TASK, 0)))
114 
            panic("could not create thread\n");
 123 
            panic("could not create thread\n");
115 
        thread_ready(t);
 124 
        thread_ready(t);
116 
        if (!(t = thread_create(pi, NULL, TASK, 0)))
 125 
        if (!(t = thread_create(pi, NULL, TASK, 0)))
117 
            panic("could not create thread\n");
 126 
            panic("could not create thread\n");
118 
        thread_ready(t);
 127 
        thread_ready(t);
119 
    }
 128 
    }
120 
    printf("ok\n");
 129 
    printf("ok\n");
121 
   
 130 
   
122 
    thread_sleep(1);
 131 
    thread_sleep(1);
123 
    waitq_wakeup(&can_start, WAKEUP_ALL);
 132 
    waitq_wakeup(&can_start, WAKEUP_ALL);
124 
 
 133 
 
125 
    while (threads_ok != THREADS)
 134 
    while (threads_ok != THREADS)
126 
        ;
 135 
        ;
127 
       
 136 
       
128 
    printf("Test passed.\n");
 137 
    printf("Test passed.\n");
129 
}
 138 
}
130 
 
 139