Changeset 34db7fa in mainline


Ignore:
Timestamp:
2006-12-12T12:32:02Z (18 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
96348adc
Parents:
df496c5
Message:

cleanup kernel tests infrastructure

Location:
kernel
Files:
23 added
10 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/console/cmd.c

    rdf496c5 r34db7fa  
    6868#ifdef CONFIG_TEST
    6969#include <test.h>
     70#endif
     71
     72#ifdef CONFIG_BENCH
     73#include <arch/cycle.h>
    7074#endif
    7175
    … …  
    859863}
    860864
     865static bool run_test(const test_t * test)
     866{
     867        printf("%s\t\t%s\n", test->name, test->desc);
     868#ifdef CONFIG_BENCH
     869        uint64_t t0 = get_cycle();
     870#endif
     871        char * ret = test->entry();
     872#ifdef CONFIG_BENCH
     873        uint64_t dt = get_cycle() - t0;
     874        printf("Time: %llu cycles\n", dt);
     875#endif
     876       
     877        if (ret == NULL) {
     878                printf("Test passed\n");
     879                return true;
     880        }
     881
     882        printf("%s\n", ret);
     883        return false;
     884}
     885
    861886/** Command for returning kernel tests
    862887 *
    … …  
    872897                for (test = tests; test->name != NULL; test++) {
    873898                        if (test->safe) {
    874                                 printf("\n%s\t\t%s\n\n", test->name, test->desc);
    875                                 test->entry();
     899                                printf("\n");
     900                                if (!run_test(test))
     901                                        break;
    876902                        }
    877903                }
    … …  
    882908                        if (strcmp(test->name, argv->buffer) == 0) {
    883909                                fnd = true;
    884                                 test->entry();
     910                                run_test(test);
    885911                                break;
    886912                        }
    … …  
    888914               
    889915                if (!fnd)
    890                         printf("Unknown test.\n");
     916                        printf("Unknown test\n");
    891917        }
    892918       

  • kernel/test/atomic/atomic1.c

    rdf496c5 r34db7fa  
    3232#include <debug.h>
    3333
    34 #ifdef CONFIG_BENCH
    35 #include <arch/cycle.h>
    36 #endif
    37 
    38 void test_atomic1(void)
     34char * test_atomic1(void)
    3935{
    40 #ifdef CONFIG_BENCH
    41         uint64_t t0 = get_cycle();
    42 #endif
    4336        atomic_t a;
    44 
     37       
    4538        atomic_set(&a, 10);
    46         printf("Testing atomic_set() and atomic_get().\n");
    47         ASSERT(atomic_get(&a) == 10);
    48         printf("Testing atomic_postinc()\n");
    49         ASSERT(atomic_postinc(&a) == 10);
    50         ASSERT(atomic_get(&a) == 11);
    51         printf("Testing atomic_postdec()\n");
    52         ASSERT(atomic_postdec(&a) == 11);
    53         ASSERT(atomic_get(&a) == 10);
    54         printf("Testing atomic_preinc()\n");
    55         ASSERT(atomic_preinc(&a) == 11);
    56         ASSERT(atomic_get(&a) == 11);
    57         printf("Testing atomic_predec()\n");
    58         ASSERT(atomic_postdec(&a) == 11);
    59         ASSERT(atomic_get(&a) == 10);
    60 
    61         printf("Test passed.\n");
    62 #ifdef CONFIG_BENCH
    63         uint64_t dt = get_cycle() - t0;
    64         printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
    65 #endif
     39        if (atomic_get(&a) != 10)
     40                return "Failed atomic_set()/atomic_get()";
     41       
     42        if (atomic_postinc(&a) != 10)
     43                return "Failed atomic_postinc()";
     44        if (atomic_get(&a) != 11)
     45                return "Failed atomic_get() after atomic_postinc()";
     46       
     47        if (atomic_postdec(&a) != 11)
     48                return "Failed atomic_postdec()";
     49        if (atomic_get(&a) != 10)
     50                return "Failed atomic_get() after atomic_postdec()";
     51       
     52        if (atomic_preinc(&a) != 11)
     53                return "Failed atomic_preinc()";
     54        if (atomic_get(&a) != 11)
     55                return "Failed atomic_get() after atomic_preinc()";
     56       
     57        if (atomic_predec(&a) != 10)
     58                return "Failed atomic_predec()";
     59        if (atomic_get(&a) != 10)
     60                return "Failed atomic_get() after atomic_predec()";
     61       
     62        return NULL;
    6663}

  • kernel/test/btree/btree1.c

    rdf496c5 r34db7fa  
    3232#include <debug.h>
    3333
    34 #ifdef CONFIG_BENCH
    35 #include <arch/cycle.h>
    36 #endif
    37 
    3834static void *data = (void *) 0xdeadbeef;
    3935
    40 void test_btree1(void)
     36char * test_btree1(void)
    4137{
    42 #ifdef CONFIG_BENCH
    43         uint64_t t0 = get_cycle();
    44 #endif
    4538        btree_t t;
    4639        int i;
    … …  
    164157
    165158        btree_print(&t);
    166 #ifdef CONFIG_BENCH
    167         uint64_t dt = get_cycle() - t0;
    168         printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
    169 #endif
     159       
     160        return NULL;
    170161}

  • kernel/test/debug/mips1.c

    rdf496c5 r34db7fa  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28 
     29#ifdef mips32
    2830
    2931#include <print.h>
    … …  
    3840#include <arch.h>
    3941
     42char * test_mips1(void)
     43{
     44        printf("You should enter kconsole debug mode now.\n");
     45       
     46        asm volatile (
     47                "break\n"
     48        );
     49       
     50        return "Back from debug mode";
     51}
    4052
    41 void test_mips1(void)
    42 {
    43 #ifdef mips32
    44         printf("MIPS debug test #1\n");
    45 
    46         printf("You should enter kconsole debug mode now.\n");
    47 
    48         asm __volatile__ ("break");
    49 
    50         printf("Test passed.\n");
    51 #else
    52         printf("This test is availaible only on MIPS32 platform.\n");
    5353#endif
    54 }

  • kernel/test/fault/fault1.c

    rdf496c5 r34db7fa  
    3939
    4040
    41 void test_fault1(void)
     41char * test_fault1(void)
    4242{
    43 
    44         ((int *)(0))[1]=0; 
    45 
     43        ((int *)(0))[1] = 0;
     44       
     45        return "Written to NULL";
    4646}

  • kernel/test/fpu/fpu1.c

    rdf496c5 r34db7fa  
    2828 */
    2929
     30#if (defined(ia32) || defined(amd64) || defined(ia64) || defined(ia32xen))
     31
    3032#include <print.h>
    3133#include <debug.h>
    … …  
    3941#include <arch/arch.h>
    4042
    41 #ifdef CONFIG_BENCH
    42 #include <arch/cycle.h>
    43 #endif
    44 
    45 #if (defined(ia32) || defined(amd64) || defined(ia64) || defined(ia32xen))
    46 
    47 #define THREADS         150*2
     43
     44#define THREADS         150
    4845#define ATTEMPTS        100
    4946
    … …  
    5350
    5451#ifdef KERN_ia32_ARCH_H_
    55 static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
     52static inline double sqrt(double x)
     53{
     54        double v;
     55       
     56        asm (
     57                "fsqrt\n"
     58                : "=t" (v)
     59                : "0" (x)
     60        );
     61       
     62        return v;
     63}
    5664#endif
    5765
    5866#ifdef KERN_amd64_ARCH_H_
    59 static inline double sqrt(double x) { double v; __asm__ ("fsqrt\n" : "=t" (v) : "0" (x)); return v; }
     67static inline double sqrt(double x)
     68{
     69        double v;
     70       
     71        asm (
     72                "fsqrt\n"
     73                : "=t" (v)
     74                : "0" (x)
     75        );
     76       
     77        return v;
     78}
    6079#endif
    6180
    6281#ifdef KERN_ia64_ARCH_H_
     82
     83#undef PI_10e8 
     84#define PI_10e8 3141592
     85
    6386static inline long double sqrt(long double a)
    6487{   
    … …  
    6689        long double lx = 0;
    6790
    68         if(a<0.00000000000000001) return 0;
     91        if (a < 0.00000000000000001)
     92                return 0;
    6993               
    70         while(x!=lx)
    71         {
    72                 lx=x;
    73                 x=(x+(a/x))/2;
    74         }
     94        while(x != lx) {
     95                lx = x;
     96                x = (x + (a / x)) / 2;
     97        }
     98       
    7599        return x;
    76100}
    … …  
    78102
    79103
    80 
    81104static atomic_t threads_ok;
     105static atomic_t threads_fault;
    82106static waitq_t can_start;
    83107
    … …  
    92116
    93117        for (i = 0; i<ATTEMPTS; i++) {
    94                 le=-1;
    95                 e=0;
    96                 f=1;
    97 
    98                 for(d=1;e!=le;d*=f,f+=1) {
    99                         le=e;
    100                         e=e+1/d;
    101                 }
    102 
    103                 if((int)(100000000*e)!=E_10e8)
    104                         panic("tid%d: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000*e),(unative_t) E_10e8);
    105         }
    106 
    107         printf("tid%d: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000*e),(unative_t) E_10e8);
     118                le = -1;
     119                e = 0;
     120                f = 1;
     121
     122                for (d = 1; e != le; d *= f, f += 1) {
     123                        le = e;
     124                        e = e + 1 / d;
     125                }
     126
     127                if ((int) (100000000 * e) != E_10e8) {
     128                        printf("tid%d: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
     129                        atomic_inc(&threads_fault);
     130                        break;
     131                }
     132        }
    108133        atomic_inc(&threads_ok);
    109134}
    … …  
    111136static void pi(void *data)
    112137{
    113 
    114 #ifdef KERN_ia64_ARCH_H_
    115 #undef PI_10e8 
    116 #define PI_10e8 3141592
    117 #endif
    118 
    119 
    120138        int i;
    121139        double lpi, pi;
    … …  
    126144        waitq_sleep(&can_start);
    127145
    128 
    129         for (i = 0; i<ATTEMPTS; i++) {
     146        for (i = 0; i < ATTEMPTS; i++) {
    130147                lpi = -1;
    131148                pi = 0;
    132149
    133                 for (n=2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
     150                for (n = 2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
    134151                        double sc, cd;
    135152
    136                         sc = sqrt(1 - (ab*ab/4));
     153                        sc = sqrt(1 - (ab * ab / 4));
    137154                        cd = 1 - sc;
    138                         ad = sqrt(ab*ab/4 + cd*cd);
     155                        ad = sqrt(ab * ab / 4 + cd * cd);
    139156                        lpi = pi;
    140157                        pi = 2 * n * ad;
    … …  
    142159
    143160#ifdef KERN_ia64_ARCH_H_
    144                 if((int)(1000000*pi)!=PI_10e8)
    145                         panic("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000*pi),(unative_t) (PI_10e8/100));
     161                if ((int) (1000000 * pi) != PI_10e8) {
     162                        printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
     163                        atomic_inc(&threads_fault);
     164                        break;
     165                }
    146166#else
    147                 if((int)(100000000*pi)!=PI_10e8)
    148                         panic("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000*pi),(unative_t) PI_10e8);
    149 #endif
    150 
    151         }
    152 
    153         printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000*pi),(unative_t) PI_10e8);
     167                if ((int) (100000000 * pi) != PI_10e8) {
     168                        printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
     169                        atomic_inc(&threads_fault);
     170                        break;
     171                }
     172#endif
     173        }
    154174        atomic_inc(&threads_ok);
    155175}
    156176
    157 void test_fpu1(void)
    158 {
    159 #ifdef CONFIG_BENCH
    160         uint64_t t0 = get_cycle();
    161 #endif
    162         thread_t *t;
    163         int i;
     177char * test_fpu1(void)
     178{
     179        unsigned int i, total = 0;
    164180
    165181        waitq_initialize(&can_start);
    166 
    167         printf("FPU test #1\n");
    168         printf("Creating %d threads... ", THREADS);
    169 
    170         for (i=0; i<THREADS/2; i++) { 
    171                 if (!(t = thread_create(e, NULL, TASK, 0, "e")))
    172                         panic("could not create thread\n");
     182        atomic_set(&threads_ok, 0);
     183        atomic_set(&threads_fault, 0);
     184        printf("Creating %d threads... ", 2 * THREADS);
     185
     186        for (i = 0; i < THREADS; i++) { 
     187                thread_t *t;
     188               
     189                if (!(t = thread_create(e, NULL, TASK, 0, "e"))) {
     190                        printf("could not create thread %d\n", 2 * i);
     191                        break;
     192                }
    173193                thread_ready(t);
    174                 if (!(t = thread_create(pi, NULL, TASK, 0, "pi")))
    175                         panic("could not create thread\n");
     194                total++;
     195               
     196                if (!(t = thread_create(pi, NULL, TASK, 0, "pi"))) {
     197                        printf("could not create thread %d\n", 2 * i + 1);
     198                        break;
     199                }
    176200                thread_ready(t);
     201                total++;
    177202        }
    178203        printf("ok\n");
    … …  
    180205        thread_sleep(1);
    181206        waitq_wakeup(&can_start, WAKEUP_ALL);
    182 
    183         while (atomic_get(&threads_ok) != THREADS)
    184                 ;
    185                
    186         printf("Test passed.\n");
    187 #ifdef CONFIG_BENCH
    188         uint64_t dt = get_cycle() - t0;
    189         printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
    190 #endif
    191 }
    192 
    193 #else
    194 
    195 void test_fpu1(void)
    196 {
    197         printf("This test is available only on Intel/AMD platforms.");
    198 }
    199 
    200 #endif
     207       
     208        while (atomic_get(&threads_ok) != total) {
     209                printf("Threads left: %d\n", total - atomic_get(&threads_ok));
     210                thread_sleep(1);
     211        }
     212       
     213        if (atomic_get(&threads_fault) == 0)
     214                return NULL;
     215       
     216        return "Test failed";
     217}
     218
     219#endif

  • kernel/test/fpu/mips2.c

    rdf496c5 r34db7fa  
    2727 */
    2828
     29#ifdef mips32
     30
    2931#include <print.h>
    3032#include <debug.h>
    … …  
    3840#include <arch.h>
    3941
    40 #ifdef mips32
    41 
    4242#define THREADS         50
    4343#define DELAY           10000L
    … …  
    4545
    4646static atomic_t threads_ok;
     47static atomic_t threads_fault;
    4748static waitq_t can_start;
    4849
    … …  
    5051{
    5152        int i;
    52         int arg __attribute__((aligned(16))) = (int)((unative_t) data);
     53        int arg __attribute__((aligned(16))) = (int) ((unative_t) data);
    5354        int after_arg __attribute__((aligned(16)));
    54 
     55       
    5556        thread_detach(THREAD);
    5657       
    5758        waitq_sleep(&can_start);
    5859
    59         for (i = 0; i<ATTEMPTS; i++) {
    60                 __asm__ volatile (
     60        for (i = 0; i < ATTEMPTS; i++) {
     61                asm volatile (
    6162                        "mtc1 %0,$1"
    62                         :"=r"(arg)
    63                         );
    64 
     63                        : "=r" (arg)
     64                );
     65               
    6566                delay(DELAY);
    66                 __asm__ volatile (
     67               
     68                asm volatile (
    6769                        "mfc1 %0, $1"
    68                         :"=r"(after_arg)
    69                         );
     70                        : "=r" (after_arg)
     71                );
    7072               
    71                 if(arg != after_arg)
    72                         panic("General reg tid%d: arg(%d) != %d\n",
    73                               THREAD->tid, arg, after_arg);
     73                if (arg != after_arg) {
     74                        printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     75                        atomic_inc(&threads_fault);
     76                        break;
     77                }
    7478        }
    75 
    7679        atomic_inc(&threads_ok);
    7780}
    … …  
    8083{
    8184        int i;
    82         int arg __attribute__((aligned(16))) = (int)((unative_t) data);
     85        int arg __attribute__((aligned(16))) = (int) ((unative_t) data);
    8386        int after_arg __attribute__((aligned(16)));
    84 
     87       
    8588        thread_detach(THREAD);
    86 
     89       
    8790        waitq_sleep(&can_start);
    8891
    89         for (i = 0; i<ATTEMPTS; i++) {
    90                 __asm__ volatile (
     92        for (i = 0; i < ATTEMPTS; i++) {
     93                asm volatile (
    9194                        "mtc1 %0,$1"
    92                         :"=r"(arg)
    93                         );
     95                        : "=r" (arg)
     96                );
    9497
    9598                scheduler();
    96                 __asm__ volatile (
     99                asm volatile (
    97100                        "mfc1 %0,$1"
    98                         :"=r"(after_arg)
    99                         );
     101                        : "=r" (after_arg)
     102                );
    100103               
    101                 if(arg != after_arg)
    102                         panic("General reg tid%d: arg(%d) != %d\n",
    103                               THREAD->tid, arg, after_arg);
     104                if (arg != after_arg) {
     105                        panic("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     106                        atomic_inc(&threads_fault);
     107                        break;
     108                }
    104109        }
    105 
    106110        atomic_inc(&threads_ok);
    107111}
    108112
    109113
    110 void test_mips2(void)
     114char * test_mips2(void)
    111115{
    112         thread_t *t;
    113         int i;
     116        unsigned int i, total = 0;
     117       
     118        waitq_initialize(&can_start);
     119        atomic_set(&threads_ok, 0);
     120        atomic_set(&threads_fault, 0);
     121        printf("Creating %d threads... ", 2 * THREADS);
    114122
    115         waitq_initialize(&can_start);
    116 
    117         printf("MIPS test #1\n");
    118         printf("Creating %d threads... ", THREADS);
    119 
    120         for (i=0; i<THREADS/2; i++) { 
    121                 if (!(t = thread_create(testit1, (void *)((unative_t)i*2), TASK, 0, "testit1")))
    122                         panic("could not create thread\n");
     123        for (i = 0; i < THREADS; i++) {
     124                thread_t *t;
     125               
     126                if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1"))) {
     127                        printf("could not create thread %d\n", 2 * i);
     128                        break;
     129                }
    123130                thread_ready(t);
    124                 if (!(t = thread_create(testit2, (void *)((unative_t)i*2+1), TASK, 0, "testit2")))
    125                         panic("could not create thread\n");
     131                total++;
     132               
     133                if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2"))) {
     134                        printf("could not create thread %d\n", 2 * i + 1);
     135                        break;
     136                }
    126137                thread_ready(t);
     138                total++;
    127139        }
    128 
    129140        printf("ok\n");
    130        
     141               
    131142        thread_sleep(1);
    132143        waitq_wakeup(&can_start, WAKEUP_ALL);
    133 
    134         while (atomic_get(&threads_ok) != THREADS)
    135                 ;
    136                
    137         printf("Test passed.\n");
    138 }
    139 
    140 #else
    141 
    142 void test_mips2(void)
    143 {
    144         printf("This test is availaible only on MIPS32 platform.\n");
     144       
     145        while (atomic_get(&threads_ok) != total) {
     146                printf("Threads left: %d\n", total - atomic_get(&threads_ok));
     147                thread_sleep(1);
     148        }
     149       
     150        if (atomic_get(&threads_fault) == 0)
     151                return NULL;
     152       
     153        return "Test failed";
    145154}
    146155

  • kernel/test/fpu/sse1.c

    rdf496c5 r34db7fa  
    2727 */
    2828
     29#if (defined(ia32) || defined(amd64) || defined(ia32xen))
     30
    2931#include <print.h>
    3032#include <debug.h>
    … …  
    3840#include <arch.h>
    3941
    40 #ifdef CONFIG_BENCH
    41 #include <arch/cycle.h>
    42 #endif
    43 
    44 #if (defined(ia32) || defined(amd64) || defined(ia32xen))
    45 
    46 #define THREADS         50
     42#define THREADS         25
    4743#define DELAY           10000L
    4844#define ATTEMPTS        5
    4945
    5046static atomic_t threads_ok;
     47static atomic_t threads_fault;
    5148static waitq_t can_start;
    5249
    … …  
    5451{
    5552        int i;
    56         int arg __attribute__((aligned(16))) = (int)((unative_t) data);
     53        int arg __attribute__((aligned(16))) = (int) ((unative_t) data);
    5754        int after_arg __attribute__((aligned(16)));
    5855
    … …  
    6158        waitq_sleep(&can_start);
    6259
    63         for (i = 0; i<ATTEMPTS; i++) {
    64                 __asm__ volatile (
    65                         "movlpd %0, %%xmm2"
    66                         :"=m"(arg)
    67                         );
     60        for (i = 0; i < ATTEMPTS; i++) {
     61                asm volatile (
     62                        "movlpd %0, %%xmm2\n"
     63                        : "=m" (arg)
     64                );
    6865
    6966                delay(DELAY);
    70                 __asm__ volatile (
    71                         "movlpd %%xmm2, %0"
    72                         :"=m"(after_arg)
    73                         );
     67                asm volatile (
     68                        "movlpd %%xmm2, %0\n"
     69                        : "=m" (after_arg)
     70                );
    7471               
    75                 if(arg != after_arg)
    76                         panic("tid%d: arg(%d) != %d\n",
    77                               THREAD->tid, arg, after_arg);
     72                if (arg != after_arg) {
     73                        printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     74                        atomic_inc(&threads_fault);
     75                        break;
     76                }
    7877        }
    79 
    8078        atomic_inc(&threads_ok);
    8179}
    … …  
    8482{
    8583        int i;
    86         int arg __attribute__((aligned(16))) = (int)((unative_t) data);
     84        int arg __attribute__((aligned(16))) = (int) ((unative_t) data);
    8785        int after_arg __attribute__((aligned(16)));
    88 
     86       
    8987        thread_detach(THREAD);
    9088       
    9189        waitq_sleep(&can_start);
    9290
    93         for (i = 0; i<ATTEMPTS; i++) {
    94                 __asm__ volatile (
    95                         "movlpd %0, %%xmm2"
    96                         :"=m"(arg)
    97                         );
     91        for (i = 0; i < ATTEMPTS; i++) {
     92                asm volatile (
     93                        "movlpd %0, %%xmm2\n"
     94                        : "=m" (arg)
     95                );
    9896
    9997                scheduler();
    100                 __asm__ volatile (
    101                         "movlpd %%xmm2, %0"
    102                         :"=m"(after_arg)
    103                         );
     98                asm volatile (
     99                        "movlpd %%xmm2, %0\n"
     100                        : "=m" (after_arg)
     101                );
    104102               
    105                 if(arg != after_arg)
    106                         panic("tid%d: arg(%d) != %d\n",
    107                               THREAD->tid, arg, after_arg);
     103                if (arg != after_arg) {
     104                        printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     105                        atomic_inc(&threads_fault);
     106                        break;
     107                }
    108108        }
    109 
    110109        atomic_inc(&threads_ok);
    111110}
    112111
    113112
    114 void test_sse1(void)
     113char * test_sse1(void)
    115114{
    116 #ifdef CONFIG_BENCH
    117         uint64_t t0 = get_cycle();
    118 #endif
    119         thread_t *t;
    120         int i;
     115        unsigned int i, total = 0;
    121116
    122117        waitq_initialize(&can_start);
     118        atomic_set(&threads_ok, 0);
     119        atomic_set(&threads_fault, 0);
     120        printf("Creating %d threads... ", 2 * THREADS);
    123121
    124         printf("SSE test #1\n");
    125         printf("Creating %d threads... ", THREADS);
    126 
    127         for (i=0; i<THREADS/2; i++) { 
    128                 if (!(t = thread_create(testit1, (void *)((unative_t)i*2), TASK, 0, "testit1")))
    129                         panic("could not create thread\n");
     122        for (i = 0; i < THREADS; i++) {
     123                thread_t *t;
     124               
     125                if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1"))) {
     126                        printf("could not create thread %d\n", 2 * i);
     127                        break;
     128                }
    130129                thread_ready(t);
    131                 if (!(t = thread_create(testit2, (void *)((unative_t)i*2+1), TASK, 0, "testit2")))
    132                         panic("could not create thread\n");
     130                total++;
     131               
     132                if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2"))) {
     133                        printf("could not create thread %d\n", 2 * i + 1);
     134                        break;
     135                }
    133136                thread_ready(t);
     137                total++;
    134138        }
    135 
    136139        printf("ok\n");
    137        
     140               
    138141        thread_sleep(1);
    139142        waitq_wakeup(&can_start, WAKEUP_ALL);
    140 
    141         while (atomic_get(&threads_ok) != THREADS)
    142                 ;
    143                
    144         printf("Test passed.\n");
    145 #ifdef CONFIG_BENCH
    146         uint64_t dt = get_cycle() - t0;
    147         printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
    148 #endif
    149 }
    150 
    151 #else
    152 
    153 void test_sse1(void)
    154 {
    155         printf("This test is available only on SSE enabled platforms.");
     143       
     144        while (atomic_get(&threads_ok) != total) {
     145                printf("Threads left: %d\n", total - atomic_get(&threads_ok));
     146                thread_sleep(1);
     147        }
     148       
     149        if (atomic_get(&threads_fault) == 0)
     150                return NULL;
     151       
     152        return "Test failed";
    156153}
    157154

  • kernel/test/test.c

    rdf496c5 r34db7fa  
    3636
    3737test_t tests[] = {
    38         {
    39                 "atomic1",
    40                 "Test atomic operations",
    41                 &test_atomic1,
    42                 true
    43         },
    44         {
    45                 "btree1",
    46                 "Test B-tree operations",
    47                 &test_btree1,
    48                 true
    49         },
    50         {
    51                 "mips1",
    52                 "MIPS debug test",
    53                 &test_mips1,
    54                 true
    55         },
    56         {
    57                 "fault1",
    58                 "Write to NULL (maybe page fault)",
    59                 &test_fault1,
    60                 false
    61         },
    62         {
    63                 "fpu1",
    64                 "Intel FPU test",
    65                 &test_fpu1,
    66                 true
    67         },
    68         {
    69                 "sse1",
    70                 "Intel SEE test",
    71                 &test_sse1,
    72                 true
    73         },
    74         {
    75                 "mips2",
    76                 "MIPS FPU test",
    77                 &test_mips2,
    78                 true
    79         },
     38#include <atomic/atomic1.def>
     39#include <btree/btree1.def>
     40#include <debug/mips1.def>
     41#include <fault/fault1.def>
     42#include <fpu/fpu1.def>
     43#include <fpu/sse1.def>
     44#include <fpu/mips2.def>
     45        /*
    8046        {
    8147                "falloc1",
    … …  
    173139                &test_sysinfo1,
    174140                true
    175         },
     141        },*/
    176142        {NULL, NULL, NULL}
    177143};

  • kernel/test/test.h

    rdf496c5 r34db7fa  
    3939#include <typedefs.h>
    4040
     41typedef char * (* test_entry_t)();
     42
    4143typedef struct {
    4244        char * name;
    4345        char * desc;
    44         function entry;
     46        test_entry_t entry;
    4547        bool safe;
    4648} test_t;
    4749
    48 extern void test_atomic1(void);
    49 extern void test_btree1(void);
    50 extern void test_mips1(void);
    51 extern void test_fault1(void);
    52 extern void test_fpu1(void);
    53 extern void test_sse1(void);
    54 extern void test_mips2(void);
     50extern char * test_atomic1(void);
     51extern char * test_btree1(void);
     52extern char * test_mips1(void);
     53extern char * test_fault1(void);
     54extern char * test_fpu1(void);
     55extern char * test_sse1(void);
     56extern char * test_mips2(void);
    5557extern void test_falloc1(void);
    5658extern void test_falloc2(void);
Note: See TracChangeset for help on using the changeset viewer.