Changeset deada67 in mainline


Ignore:
Timestamp:
2006-12-19T17:54:50Z (18 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
730376d
Parents:
6536a4a9
Message:

quiet variants of tests

Location:
kernel/test
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • kernel/test/fpu/mips2.c

    r6536a4a9 rdeada67  
    4646static atomic_t threads_fault;
    4747static waitq_t can_start;
     48static bool sh_quiet;
    4849
    4950static void testit1(void *data)
    … …  
    7172               
    7273                if (arg != after_arg) {
    73                         printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     74                        if (!sh_quiet)
     75                                printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    7476                        atomic_inc(&threads_fault);
    7577                        break;
    … …  
    102104               
    103105                if (arg != after_arg) {
    104                         printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     106                        if (!sh_quiet)
     107                                printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    105108                        atomic_inc(&threads_fault);
    106109                        break;
    … …  
    114117{
    115118        unsigned int i, total = 0;
     119        sh_quiet = quiet;
    116120       
    117121        waitq_initialize(&can_start);
    118122        atomic_set(&threads_ok, 0);
    119123        atomic_set(&threads_fault, 0);
    120         printf("Creating %d threads... ", 2 * THREADS);
     124       
     125        if (!quiet)
     126                printf("Creating %d threads... ", 2 * THREADS);
    121127
    122128        for (i = 0; i < THREADS; i++) {
    … …  
    124130               
    125131                if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) {
    126                         printf("could not create thread %d\n", 2 * i);
     132                        if (!quiet)
     133                                printf("could not create thread %d\n", 2 * i);
    127134                        break;
    128135                }
    … …  
    131138               
    132139                if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) {
    133                         printf("could not create thread %d\n", 2 * i + 1);
     140                        if (!quiet)
     141                                printf("could not create thread %d\n", 2 * i + 1);
    134142                        break;
    135143                }
    … …  
    137145                total++;
    138146        }
    139         printf("ok\n");
     147       
     148        if (!quiet)
     149                printf("ok\n");
    140150               
    141151        thread_sleep(1);
    … …  
    143153       
    144154        while (atomic_get(&threads_ok) != total) {
    145                 printf("Threads left: %d\n", total - atomic_get(&threads_ok));
     155                if (!quiet)
     156                        printf("Threads left: %d\n", total - atomic_get(&threads_ok));
    146157                thread_sleep(1);
    147158        }

  • kernel/test/mm/falloc1.c

    r6536a4a9 rdeada67  
    5656        for (run = 0; run < TEST_RUNS; run++) {
    5757                for (order = 0; order <= MAX_ORDER; order++) {
    58                         printf("Allocating %d frames blocks ... ", 1 << order);
     58                        if (!quiet)
     59                                printf("Allocating %d frames blocks ... ", 1 << order);
     60                       
    5961                        allocated = 0;
    6062                        for (i = 0; i < MAX_FRAMES >> order; i++) {
    … …  
    6264                               
    6365                                if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) != frames[allocated]) {
    64                                         printf("Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10);
     66                                        if (!quiet)
     67                                                printf("Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10);
    6568                                        return "Test failed";
    6669                                }
    … …  
    6972                                        allocated++;
    7073                                else {
    71                                         printf("done. ");
     74                                        if (!quiet)
     75                                                printf("done. ");
    7276                                        break;
    7377                                }
    7478                        }
    7579                       
    76                         printf("%d blocks allocated.\n", allocated);
     80                        if (!quiet)
     81                                printf("%d blocks allocated.\n", allocated);
    7782               
    7883                        if (run) {
    … …  
    8287                                results[order] = allocated;
    8388                       
    84                         printf("Deallocating ... ");
     89                        if (!quiet)
     90                                printf("Deallocating ... ");
     91                       
    8592                        for (i = 0; i < allocated; i++)
    8693                                frame_free(KA2PA(frames[i]));
    87                         printf("done.\n");
     94                       
     95                        if (!quiet)
     96                                printf("done.\n");
    8897                }
    8998        }

  • kernel/test/mm/falloc2.c

    r6536a4a9 rdeada67  
    4848static atomic_t thread_count;
    4949static atomic_t thread_fail;
     50static bool sh_quiet;
    5051
    5152static void falloc(void * arg)
    … …  
    5758        uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
    5859        if (frames == NULL) {
    59                 printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
     60                if (!sh_quiet)
     61                        printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
    6062                atomic_inc(&thread_fail);
    6163                atomic_dec(&thread_count);
    … …  
    6769        for (run = 0; run < THREAD_RUNS; run++) {
    6870                for (order = 0; order <= MAX_ORDER; order++) {
    69                         printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
     71                        if (!sh_quiet)
     72                                printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
     73                       
    7074                        allocated = 0;
    7175                        for (i = 0; i < (MAX_FRAMES >> order); i++) {
    … …  
    7781                                        break;
    7882                        }
    79                         printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
    80 
    81                         printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
     83                       
     84                        if (!sh_quiet)
     85                                printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
     86                       
     87                        if (!sh_quiet)
     88                                printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
     89                       
    8290                        for (i = 0; i < allocated; i++) {
    8391                                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
    8492                                        if (((uint8_t *) frames[i])[k] != val) {
    85                                                 printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
     93                                                if (!sh_quiet)
     94                                                        printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
    8695                                                atomic_inc(&thread_fail);
    8796                                                goto cleanup;
    … …  
    9099                                frame_free(KA2PA(frames[i]));
    91100                        }
    92                         printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
     101                       
     102                        if (!sh_quiet)
     103                                printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
    93104                }
    94105        }
    … …  
    96107cleanup:       
    97108        free(frames);
    98         printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
     109       
     110        if (!sh_quiet)
     111                printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
    99112        atomic_dec(&thread_count);
    100113}
    … …  
    103116{
    104117        unsigned int i;
     118        sh_quiet = quiet;
    105119
    106120        atomic_set(&thread_count, THREADS);
    … …  
    110124                thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
    111125                if (!thrd) {
    112                         printf("Could not create thread %d\n", i);
     126                        if (!quiet)
     127                                printf("Could not create thread %d\n", i);
    113128                        break;
    114129                }
    … …  
    117132       
    118133        while (atomic_get(&thread_count) > 0) {
    119                 printf("Threads left: %d\n", atomic_get(&thread_count));
     134                if (!quiet)
     135                        printf("Threads left: %d\n", atomic_get(&thread_count));
    120136                thread_sleep(1);
    121137        }

  • kernel/test/mm/mapping1.c

    r6536a4a9 rdeada67  
    4949        frame0 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA);
    5050        frame1 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA);
    51 
    52         printf("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0));
     51       
     52        if (!quiet)
     53                printf("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0));
    5354        *((uint32_t *) frame0) = VALUE0;
    54         printf("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1));
     55        if (!quiet)
     56                printf("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1));
    5557        *((uint32_t *) frame1) = VALUE1;
    5658       
    57         printf("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0));
     59        if (!quiet)
     60                printf("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0));
    5861        page_mapping_insert(AS_KERNEL, PAGE0, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE);
    59         printf("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1));   
     62        if (!quiet)
     63                printf("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1));   
    6064        page_mapping_insert(AS_KERNEL, PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE);
    6165       
    62         printf("Value at virtual address %p is %#x.\n", PAGE0, v0 = *((uint32_t *) PAGE0));
    63         printf("Value at virtual address %p is %#x.\n", PAGE1, v1 = *((uint32_t *) PAGE1));
     66        v0 = *((uint32_t *) PAGE0);
     67        v1 = *((uint32_t *) PAGE1);
     68        if (!quiet) {
     69                printf("Value at virtual address %p is %#x.\n", PAGE0, v0);
     70                printf("Value at virtual address %p is %#x.\n", PAGE1, v1);
     71        }
    6472       
    6573        if (v0 != VALUE0)
    … …  
    6775        if (v1 != VALUE1)
    6876                return "Value at v1 not equal to VALUE1";
    69 
    70         printf("Writing %#x to virtual address %p.\n", 0, PAGE0);
     77       
     78        if (!quiet)
     79                printf("Writing %#x to virtual address %p.\n", 0, PAGE0);
    7180        *((uint32_t *) PAGE0) = 0;
    72         printf("Writing %#x to virtual address %p.\n", 0, PAGE1);
     81        if (!quiet)
     82                printf("Writing %#x to virtual address %p.\n", 0, PAGE1);
    7383        *((uint32_t *) PAGE1) = 0;     
    7484
    … …  
    7686        v1 = *((uint32_t *) PAGE1);
    7787       
    78         printf("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0)); 
    79         printf("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1));
     88        if (!quiet) {
     89                printf("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0)); 
     90                printf("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1));
     91        }
    8092
    8193        if (v0 != 0)

  • kernel/test/mm/slab1.c

    r6536a4a9 rdeada67  
    3838static void * data[VAL_COUNT];
    3939
    40 static void testit(int size, int count)
     40static void testit(int size, int count, bool quiet)
    4141{
    4242        slab_cache_t *cache;
    4343        int i;
    4444       
    45         printf("Creating cache, object size: %d.\n", size);
    46         cache = slab_cache_create("test_cache", size, 0, NULL, NULL,
    47                                   SLAB_CACHE_NOMAGAZINE);       
    48         printf("Allocating %d items...", count);
     45        if (!quiet)
     46                printf("Creating cache, object size: %d.\n", size);
     47       
     48        cache = slab_cache_create("test_cache", size, 0, NULL, NULL,
     49                                SLAB_CACHE_NOMAGAZINE);
     50       
     51        if (!quiet)
     52                printf("Allocating %d items...", count);
     53       
    4954        for (i = 0; i < count; i++) {
    5055                data[i] = slab_alloc(cache, 0);
    5156                memsetb((uintptr_t) data[i], size, 0);
    5257        }
    53         printf("done.\n");
    54         printf("Freeing %d items...", count);
    55         for (i = 0; i < count; i++) {
     58       
     59        if (!quiet) {
     60                printf("done.\n");
     61                printf("Freeing %d items...", count);
     62        }
     63       
     64        for (i = 0; i < count; i++)
    5665                slab_free(cache, data[i]);
     66       
     67        if (!quiet) {
     68                printf("done.\n");
     69                printf("Allocating %d items...", count);
    5770        }
    58         printf("done.\n");
    59 
    60         printf("Allocating %d items...", count);
     71       
    6172        for (i = 0; i < count; i++) {
    6273                data[i] = slab_alloc(cache, 0);
    6374                memsetb((uintptr_t) data[i], size, 0);
    6475        }
    65         printf("done.\n");
    66 
    67         printf("Freeing %d items...", count / 2);
    68         for (i = count - 1; i >= count / 2; i--) {
     76       
     77        if (!quiet) {
     78                printf("done.\n");
     79                printf("Freeing %d items...", count / 2);
     80        }
     81       
     82        for (i = count - 1; i >= count / 2; i--)
    6983                slab_free(cache, data[i]);
     84       
     85        if (!quiet) {
     86                printf("done.\n");     
     87                printf("Allocating %d items...", count / 2);
    7088        }
    71         printf("done.\n");     
    72 
    73         printf("Allocating %d items...", count / 2);
     89       
    7490        for (i = count / 2; i < count; i++) {
    7591                data[i] = slab_alloc(cache, 0);
    7692                memsetb((uintptr_t) data[i], size, 0);
    7793        }
    78         printf("done.\n");
    79         printf("Freeing %d items...", count);
    80         for (i = 0; i < count; i++) {
     94       
     95        if (!quiet) {
     96                printf("done.\n");
     97                printf("Freeing %d items...", count);
     98        }
     99       
     100        for (i = 0; i < count; i++)
    81101                slab_free(cache, data[i]);
    82         }
    83         printf("done.\n");     
     102       
     103        if (!quiet)
     104                printf("done.\n");     
    84105        slab_cache_destroy(cache);
    85 
    86         printf("Test complete.\n");
     106       
     107        if (!quiet)
     108                printf("Test complete.\n");
    87109}
    88110
    89 static void testsimple(void)
     111static void testsimple(bool quiet)
    90112{
    91         testit(100, VAL_COUNT);
    92         testit(200, VAL_COUNT);
    93         testit(1024, VAL_COUNT);
    94         testit(2048, 512);
    95         testit(4000, 128);
    96         testit(8192, 128);
    97         testit(16384, 128);
    98         testit(16385, 128);
     113        testit(100, VAL_COUNT, quiet);
     114        testit(200, VAL_COUNT, quiet);
     115        testit(1024, VAL_COUNT, quiet);
     116        testit(2048, 512, quiet);
     117        testit(4000, 128, quiet);
     118        testit(8192, 128, quiet);
     119        testit(16384, 128, quiet);
     120        testit(16385, 128, quiet);
    99121}
    100122
    … …  
    106128static slab_cache_t *thr_cache;
    107129static semaphore_t thr_sem;
     130static bool sh_quiet;
    108131
    109132static void slabtest(void *data)
    … …  
    114137        thread_detach(THREAD);
    115138       
    116         printf("Starting thread #%d...\n",THREAD->tid);
     139        if (!sh_quiet)
     140                printf("Starting thread #%d...\n", THREAD->tid);
     141       
    117142        for (j = 0; j < 10; j++) {
    118143                for (i = 0; i < THR_MEM_COUNT; i++)
    … …  
    125150                        slab_free(thr_cache, thr_data[offs][i]);
    126151        }
    127         printf("Thread #%d finished\n", THREAD->tid);
     152       
     153        if (!sh_quiet)
     154                printf("Thread #%d finished\n", THREAD->tid);
     155       
    128156        semaphore_up(&thr_sem);
    129157}
    130158
    131 static void testthreads(void)
     159static void testthreads(bool quiet)
    132160{
    133161        thread_t *t;
    134162        int i;
    135163
    136         thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0,
    137                                       NULL, NULL,
    138                                       SLAB_CACHE_NOMAGAZINE);
     164        thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0, NULL, NULL,
     165                                        SLAB_CACHE_NOMAGAZINE);
    139166        semaphore_initialize(&thr_sem, 0);
    140167        for (i = 0; i < THREADS; i++) { 
    141                 if (!(t = thread_create(slabtest, (void *) (unative_t) i, TASK, 0, "slabtest", false)))
    142                         printf("Could not create thread %d\n", i);
    143                 else
     168                if (!(t = thread_create(slabtest, (void *) (unative_t) i, TASK, 0, "slabtest", false))) {
     169                        if (!quiet)
     170                                printf("Could not create thread %d\n", i);
     171                } else
    144172                        thread_ready(t);
    145173        }
    … …  
    149177       
    150178        slab_cache_destroy(thr_cache);
    151         printf("Test complete.\n");
    152179       
     180        if (!quiet)
     181                printf("Test complete.\n");
    153182}
    154183
    155184char * test_slab1(bool quiet)
    156185{
    157         testsimple();
    158         testthreads();
     186        sh_quiet = quiet;
     187       
     188        testsimple(quiet);
     189        testthreads(quiet);
    159190       
    160191        return NULL;

  • kernel/test/mm/slab2.c

    r6536a4a9 rdeada67  
    4343 *  now allocation should clean magazines and allow for full allocation.
    4444 */
    45 static void totalmemtest(void)
     45static void totalmemtest(bool quiet)
    4646{
    4747        slab_cache_t *cache1;
    … …  
    5050
    5151        void *data1, *data2;
    52         void *olddata1=NULL, *olddata2=NULL;
     52        void *olddata1 = NULL, *olddata2 = NULL;
    5353       
    5454        cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0);
    5555        cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
    56 
    57         printf("Allocating...");
     56       
     57        if (!quiet)
     58                printf("Allocating...");
     59       
    5860        /* Use atomic alloc, so that we find end of memory */
    5961        do {
    6062                data1 = slab_alloc(cache1, FRAME_ATOMIC);
    6163                data2 = slab_alloc(cache2, FRAME_ATOMIC);
    62                 if (!data1 || !data2) {
     64                if ((!data1) || (!data2)) {
    6365                        if (data1)
    64                                 slab_free(cache1,data1);
     66                                slab_free(cache1, data1);
    6567                        if (data2)
    66                                 slab_free(cache2,data2);
     68                                slab_free(cache2, data2);
    6769                        break;
    6870                }
    69                 memsetb((uintptr_t)data1, ITEM_SIZE, 0);
    70                 memsetb((uintptr_t)data2, ITEM_SIZE, 0);
    71                 *((void **)data1) = olddata1;
    72                 *((void **)data2) = olddata2;
     71                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
     72                memsetb((uintptr_t) data2, ITEM_SIZE, 0);
     73                *((void **) data1) = olddata1;
     74                *((void **) data2) = olddata2;
    7375                olddata1 = data1;
    7476                olddata2 = data2;
    75         } while(1);
    76         printf("done.\n");
     77        } while (1);
     78       
     79        if (!quiet) {
     80                printf("done.\n");
     81                printf("Deallocating cache2...");
     82        }
     83       
    7784        /* We do not have memory - now deallocate cache2 */
    78         printf("Deallocating cache2...");
    7985        while (olddata2) {
    80                 data2 = *((void **)olddata2);
     86                data2 = *((void **) olddata2);
    8187                slab_free(cache2, olddata2);
    8288                olddata2 = data2;
    8389        }
    84         printf("done.\n");
    85 
    86         printf("Allocating to cache1...\n");
    87         for (i=0; i<30; i++) {
     90       
     91        if (!quiet) {
     92                printf("done.\n");
     93                printf("Allocating to cache1...\n");
     94        }
     95       
     96        for (i = 0; i < 30; i++) {
    8897                data1 = slab_alloc(cache1, FRAME_ATOMIC);
    8998                if (!data1) {
    90                         printf("Incorrect memory size - use another test.");
     99                        if (!quiet)
     100                                printf("Incorrect memory size - use another test.");
    91101                        return;
    92102                }
    93                 memsetb((uintptr_t)data1, ITEM_SIZE, 0);
    94                 *((void **)data1) = olddata1;
     103                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
     104                *((void **) data1) = olddata1;
    95105                olddata1 = data1;
    96106        }
    97107        while (1) {
    98108                data1 = slab_alloc(cache1, FRAME_ATOMIC);
    99                 if (!data1) {
    100                         break;
    101                 }
    102                 memsetb((uintptr_t)data1, ITEM_SIZE, 0);
    103                 *((void **)data1) = olddata1;
    104                 olddata1 = data1;
    105         }
    106         printf("Deallocating cache1...");
     109                if (!data1)
     110                        break;
     111                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
     112                *((void **) data1) = olddata1;
     113                olddata1 = data1;
     114        }
     115       
     116        if (!quiet)
     117                printf("Deallocating cache1...");
     118       
    107119        while (olddata1) {
    108                 data1 = *((void **)olddata1);
     120                data1 = *((void **) olddata1);
    109121                slab_free(cache1, olddata1);
    110122                olddata1 = data1;
    111123        }
    112         printf("done.\n");
    113         slab_print_list();
     124       
     125        if (!quiet) {
     126                printf("done.\n");
     127                slab_print_list();
     128        }
     129       
    114130        slab_cache_destroy(cache1);
    115131        slab_cache_destroy(cache2);
    … …  
    120136static condvar_t thread_starter;
    121137static mutex_t starter_mutex;
     138static bool sh_quiet;
    122139
    123140#define THREADS 8
    … …  
    126143{
    127144        void *data = NULL, *new;
    128 
     145       
    129146        thread_detach(THREAD);
    130 
     147       
    131148        mutex_lock(&starter_mutex);
    132149        condvar_wait(&thread_starter,&starter_mutex);
    133150        mutex_unlock(&starter_mutex);
    134                
    135         printf("Starting thread #%d...\n",THREAD->tid);
     151       
     152        if (!sh_quiet)
     153                printf("Starting thread #%d...\n",THREAD->tid);
    136154
    137155        /* Alloc all */
    138         printf("Thread #%d allocating...\n", THREAD->tid);
     156        if (!sh_quiet)
     157                printf("Thread #%d allocating...\n", THREAD->tid);
     158       
    139159        while (1) {
    140160                /* Call with atomic to detect end of memory */
    … …  
    142162                if (!new)
    143163                        break;
    144                 *((void **)new) = data;
    145                 data = new;
    146         }
    147         printf("Thread #%d releasing...\n", THREAD->tid);
     164                *((void **) new) = data;
     165                data = new;
     166        }
     167       
     168        if (!sh_quiet)
     169                printf("Thread #%d releasing...\n", THREAD->tid);
     170       
    148171        while (data) {
    149172                new = *((void **)data);
    150                 *((void **)data) = NULL;
     173                *((void **) data) = NULL;
    151174                slab_free(thr_cache, data);
    152175                data = new;
    153176        }
    154         printf("Thread #%d allocating...\n", THREAD->tid);
     177       
     178        if (!sh_quiet)
     179                printf("Thread #%d allocating...\n", THREAD->tid);
     180       
    155181        while (1) {
    156182                /* Call with atomic to detect end of memory */
    … …  
    158184                if (!new)
    159185                        break;
    160                 *((void **)new) = data;
    161                 data = new;
    162         }
    163         printf("Thread #%d releasing...\n", THREAD->tid);
     186                *((void **) new) = data;
     187                data = new;
     188        }
     189       
     190        if (!sh_quiet)
     191                printf("Thread #%d releasing...\n", THREAD->tid);
     192       
    164193        while (data) {
    165194                new = *((void **)data);
    166                 *((void **)data) = NULL;
     195                *((void **) data) = NULL;
    167196                slab_free(thr_cache, data);
    168197                data = new;
    169198        }
    170 
    171         printf("Thread #%d finished\n", THREAD->tid);
     199       
     200        if (!sh_quiet)
     201                printf("Thread #%d finished\n", THREAD->tid);
     202       
    172203        slab_print_list();
    173204        semaphore_up(&thr_sem);
    174205}
    175206
    176 static void multitest(int size)
     207static void multitest(int size, bool quiet)
    177208{
    178209        /* Start 8 threads that just allocate as much as possible,
    … …  
    181212        thread_t *t;
    182213        int i;
    183 
    184         printf("Running stress test with size %d\n", size);
     214       
     215        if (!quiet)
     216                printf("Running stress test with size %d\n", size);
     217       
    185218        condvar_initialize(&thread_starter);
    186219        mutex_initialize(&starter_mutex);
    187220
    188         thr_cache = slab_cache_create("thread_cache", size, 0,
    189                                       NULL, NULL,
    190                                       0);
     221        thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
    191222        semaphore_initialize(&thr_sem,0);
    192223        for (i = 0; i < THREADS; i++) { 
    193                 if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false)))
    194                         printf("Could not create thread %d\n", i);
    195                 else
     224                if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
     225                        if (!quiet)
     226                                printf("Could not create thread %d\n", i);
     227                } else
    196228                        thread_ready(t);
    197229        }
    … …  
    203235       
    204236        slab_cache_destroy(thr_cache);
    205         printf("Stress test complete.\n");
     237        if (!quiet)
     238                printf("Stress test complete.\n");
    206239}
    207240
    208241char * test_slab2(bool quiet)
    209242{
    210         printf("Running reclaim single-thread test .. pass 1\n");
    211         totalmemtest();
    212         printf("Running reclaim single-thread test .. pass 2\n");
    213         totalmemtest();
    214         printf("Reclaim test OK.\n");
    215 
    216         multitest(128);
    217         multitest(2048);
    218         multitest(8192);
    219         printf("All done.\n");
     243        sh_quiet = quiet;
     244       
     245        if (!quiet)
     246                printf("Running reclaim single-thread test .. pass 1\n");
     247        totalmemtest(quiet);
     248        if (!quiet)
     249                printf("Running reclaim single-thread test .. pass 2\n");
     250        totalmemtest(quiet);
     251        if (!quiet)
     252                printf("Reclaim test OK.\n");
     253       
     254        multitest(128, quiet);
     255        multitest(2048, quiet);
     256        multitest(8192, quiet);
    220257       
    221258        return NULL;

  • kernel/test/print/print1.c

    r6536a4a9 rdeada67  
    3333char * test_print1(bool quiet)
    3434{
    35         int retval;
    36         unative_t nat = 0x12345678u;
    37        
    38         char buffer[BUFFER_SIZE];
    39        
    40         printf(" text 10.8s %*.*s \n", 5, 3, "text");
    41         printf(" very long text 10.8s %10.8s \n", "very long text");
    42         printf(" text 8.10s %8.10s \n", "text");
    43         printf(" very long text 8.10s %8.10s \n", "very long text");
    44 
    45         printf(" char: c '%c', 3.2c '%3.2c', -3.2c '%-3.2c', 2.3c '%2.3c', -2.3c '%-2.3c' \n",'a', 'b', 'c', 'd', 'e' );
    46         printf(" int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",1, 1, 1, 1, 1 );
    47         printf(" -int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",-1, -1, -1, -1, -1 );
    48         printf(" 0xint: x '%#x', 5.3x '%#5.3x', -5.3x '%#-5.3x', 3.5x '%#3.5x', -3.5x '%#-3.5x' \n",17, 17, 17, 17, 17 );
    49 
    50         printf("'%#llx' 64bit, '%#x' 32bit, '%#hhx' 8bit, '%#hx' 16bit, unative_t '%#zx'. '%#llx' 64bit and '%s' string.\n", 0x1234567887654321ll, 0x12345678, 0x12, 0x1234, nat, 0x1234567887654321ull, "Lovely string" );
    51        
    52         printf(" Print to NULL '%s'\n", NULL);
    53 
    54         retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
    55         printf("Result is: '%s', retval = %d\n", buffer, retval);
    56 
    57         retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
    58         printf("Result is: '%s', retval = %d\n", buffer, retval);
    59        
    60         printf("Print short text to %d char long buffer via snprintf.\n", BUFFER_SIZE);
    61         retval = snprintf(buffer, BUFFER_SIZE, "Short %s", "text");
    62         printf("Result is: '%s', retval = %d\n", buffer, retval);
    63        
    64         printf("Print long text to %d char long buffer via snprintf.\n", BUFFER_SIZE);
    65         retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text`s length is more than %d. We are interested in the result.", "text" , BUFFER_SIZE);
    66         printf("Result is: '%s', retval = %d\n", buffer, retval);
     35        if (!quiet) {
     36                int retval;
     37                unative_t nat = 0x12345678u;
     38               
     39                char buffer[BUFFER_SIZE];
     40               
     41                printf(" text 10.8s %*.*s \n", 5, 3, "text");
     42                printf(" very long text 10.8s %10.8s \n", "very long text");
     43                printf(" text 8.10s %8.10s \n", "text");
     44                printf(" very long text 8.10s %8.10s \n", "very long text");
     45               
     46                printf(" char: c '%c', 3.2c '%3.2c', -3.2c '%-3.2c', 2.3c '%2.3c', -2.3c '%-2.3c' \n",'a', 'b', 'c', 'd', 'e' );
     47                printf(" int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",1, 1, 1, 1, 1 );
     48                printf(" -int: d '%d', 3.2d '%3.2d', -3.2d '%-3.2d', 2.3d '%2.3d', -2.3d '%-2.3d' \n",-1, -1, -1, -1, -1 );
     49                printf(" 0xint: x '%#x', 5.3x '%#5.3x', -5.3x '%#-5.3x', 3.5x '%#3.5x', -3.5x '%#-3.5x' \n",17, 17, 17, 17, 17 );
     50               
     51                printf("'%#llx' 64bit, '%#x' 32bit, '%#hhx' 8bit, '%#hx' 16bit, unative_t '%#zx'. '%#llx' 64bit and '%s' string.\n", 0x1234567887654321ll, 0x12345678, 0x12, 0x1234, nat, 0x1234567887654321ull, "Lovely string" );
     52               
     53                printf(" Print to NULL '%s'\n", NULL);
     54               
     55                retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
     56                printf("Result is: '%s', retval = %d\n", buffer, retval);
     57               
     58                retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
     59                printf("Result is: '%s', retval = %d\n", buffer, retval);
     60               
     61                printf("Print short text to %d char long buffer via snprintf.\n", BUFFER_SIZE);
     62                retval = snprintf(buffer, BUFFER_SIZE, "Short %s", "text");
     63                printf("Result is: '%s', retval = %d\n", buffer, retval);
     64               
     65                printf("Print long text to %d char long buffer via snprintf.\n", BUFFER_SIZE);
     66                retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text`s length is more than %d. We are interested in the result.", "text" , BUFFER_SIZE);
     67                printf("Result is: '%s', retval = %d\n", buffer, retval);
     68        }
    6769       
    6870        return NULL;

  • kernel/test/synch/rwlock1.c

    r6536a4a9 rdeada67  
    6060        rwlock_read_unlock(&rwlock);
    6161       
    62        
    6362        rwlock_write_lock(&rwlock);
    6463        rwlock_write_unlock(&rwlock);   

  • kernel/test/synch/rwlock2.c

    r6536a4a9 rdeada67  
    3939
    4040static rwlock_t rwlock;
     41static bool sh_quiet;
    4142
    4243static void writer(void *arg)
    4344{
    44 
    45         thread_detach(THREAD);
    46 
    47         printf("Trying to lock rwlock for writing....\n");   
    48 
     45        if (!sh_quiet)
     46                printf("Trying to lock rwlock for writing....\n");
     47       
    4948        rwlock_write_lock(&rwlock);
    5049        rwlock_write_unlock(&rwlock);
    5150       
    52         printf("Trying to lock rwlock for reading....\n");     
     51        if (!sh_quiet)
     52                printf("Trying to lock rwlock for reading....\n");
     53       
    5354        rwlock_read_lock(&rwlock);
    5455        rwlock_read_unlock(&rwlock);   
    55         printf("Test passed.\n");
    5656}
    5757
    … …  
    5959{
    6060        thread_t *thrd;
     61        sh_quiet = quiet;
    6162       
    6263        rwlock_initialize(&rwlock);
    … …  
    8081        rwlock_read_unlock(&rwlock);
    8182       
     83        thread_join(thrd);
     84        thread_detach(thrd);
     85       
    8286        return NULL;
    8387}

  • kernel/test/synch/rwlock3.c

    r6536a4a9 rdeada67  
    3535#include <synch/rwlock.h>
    3636
    37 #define READERS         50
    38 #define WRITERS         50
     37#define THREADS 4
    3938
     39static atomic_t thread_count;
    4040static rwlock_t rwlock;
     41static bool sh_quiet;
    4142
    4243static void reader(void *arg)
    4344{
    4445        thread_detach(THREAD);
    45 
    46         printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);         
     46       
     47        if (!sh_quiet)
     48                printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
     49       
    4750        rwlock_read_lock(&rwlock);
    48         rwlock_read_unlock(&rwlock);   
    49         printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);               
    50 
    51         printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);         
     51        rwlock_read_unlock(&rwlock);
     52       
     53        if (!sh_quiet) {
     54                printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);               
     55                printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);         
     56        }
    5257
    5358        rwlock_write_lock(&rwlock);
    5459        rwlock_write_unlock(&rwlock);
    55         printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);                       
     60       
     61        if (!sh_quiet)
     62                printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
     63       
     64        atomic_dec(&thread_count);
    5665}
    5766
    … …  
    6069        int i;
    6170        thread_t *thrd;
     71        sh_quiet = quiet;
     72       
     73        atomic_set(&thread_count, THREADS);
    6274       
    6375        rwlock_initialize(&rwlock);
    6476        rwlock_write_lock(&rwlock);
    6577       
    66         for (i = 0; i < 4; i++) {
     78        for (i = 0; i < THREADS; i++) {
    6779                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
    6880                if (thrd)
    6981                        thread_ready(thrd);
    70                 else
     82                else if (!quiet)
    7183                        printf("Could not create reader %d\n", i);
    7284        }
    7385
    7486        thread_sleep(1);
     87        rwlock_write_unlock(&rwlock);
    7588       
    76         rwlock_write_unlock(&rwlock);
     89        while (atomic_get(&thread_count) > 0) {
     90                if (!quiet)
     91                        printf("Threads left: %d\n", atomic_get(&thread_count));
     92                thread_sleep(1);
     93        }
    7794       
    7895        return NULL;

  • kernel/test/synch/rwlock4.c

    r6536a4a9 rdeada67  
    4444#define WRITERS         50
    4545
     46static atomic_t thread_count;
    4647static rwlock_t rwlock;
    4748static atomic_t threads_fault;
     49static bool sh_quiet;
    4850
    4951SPINLOCK_INITIALIZE(rw_lock);
    … …  
    7173
    7274        to = random(40000);
    73         printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
     75       
     76        if (!sh_quiet)
     77                printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
     78       
    7479        rc = rwlock_write_lock_timeout(&rwlock, to);
    7580        if (SYNCH_FAILED(rc)) {
    76                 printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
     81                if (!sh_quiet)
     82                        printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
     83                atomic_dec(&thread_count);
    7784                return;
    7885        }
    79         printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
     86       
     87        if (!sh_quiet)
     88                printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
    8089
    8190        if (rwlock.readers_in) {
    82                 printf("Oops.");
     91                if (!sh_quiet)
     92                        printf("Oops.");
    8393                atomic_inc(&threads_fault);
     94                atomic_dec(&thread_count);
    8495                return;
    8596        }
    8697        thread_usleep(random(1000000));
    8798        if (rwlock.readers_in) {
    88                 printf("Oops.");       
     99                if (!sh_quiet)
     100                        printf("Oops.");       
    89101                atomic_inc(&threads_fault);
     102                atomic_dec(&thread_count);
    90103                return;
    91104        }
    92105
    93106        rwlock_write_unlock(&rwlock);
    94         printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);     
     107       
     108        if (!sh_quiet)
     109                printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);
     110        atomic_dec(&thread_count);
    95111}
    96112
    … …  
    102118       
    103119        to = random(2000);
    104         printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
     120       
     121        if (!sh_quiet)
     122                printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
     123       
    105124        rc = rwlock_read_lock_timeout(&rwlock, to);
    106125        if (SYNCH_FAILED(rc)) {
    107                 printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
     126                if (!sh_quiet)
     127                        printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
     128                atomic_dec(&thread_count);
    108129                return;
    109130        }
    110         printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
     131       
     132        if (!sh_quiet)
     133                printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
     134       
    111135        thread_usleep(30000);
    112136        rwlock_read_unlock(&rwlock);
    113         printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);             
     137       
     138        if (!sh_quiet)
     139                printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);
     140        atomic_dec(&thread_count);
    114141}
    115142
    … …  
    117144{
    118145        context_t ctx;
    119         uint32_t i, k;
     146        uint32_t i;
     147        sh_quiet = quiet;
    120148       
    121149        waitq_initialize(&can_start);
    … …  
    123151        atomic_set(&threads_fault, 0);
    124152       
     153        uint32_t rd = random(7) + 1;
     154        uint32_t wr = random(5) + 1;
     155       
     156        atomic_set(&thread_count, rd + wr);
     157       
    125158        thread_t *thrd;
    126159       
    127160        context_save(&ctx);
    128         printf("sp=%#x, readers_in=%d\n", ctx.sp, rwlock.readers_in);
     161        if (!quiet) {
     162                printf("sp=%#x, readers_in=%d\n", ctx.sp, rwlock.readers_in);
     163                printf("Creating %d readers\n", rd);
     164        }
    129165       
    130         k = random(7) + 1;
    131         printf("Creating %d readers\n", k);
    132         for (i = 0; i < k; i++) {
     166        for (i = 0; i < rd; i++) {
    133167                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
    134168                if (thrd)
    135169                        thread_ready(thrd);
    136                 else
     170                else if (!quiet)
    137171                        printf("Could not create reader %d\n", i);
    138172        }
    139173
    140         k = random(5) + 1;
    141         printf("Creating %d writers\n", k);
    142         for (i = 0; i < k; i++) {
     174        if (!quiet)
     175                printf("Creating %d writers\n", wr);
     176       
     177        for (i = 0; i < wr; i++) {
    143178                thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
    144179                if (thrd)
    145180                        thread_ready(thrd);
    146                 else
     181                else if (!quiet)
    147182                        printf("Could not create writer %d\n", i);
    148183        }
    … …  
    151186        waitq_wakeup(&can_start, WAKEUP_ALL);
    152187       
     188        while (atomic_get(&thread_count) > 0) {
     189                if (!quiet)
     190                        printf("Threads left: %d\n", atomic_get(&thread_count));
     191                thread_sleep(1);
     192        }
     193       
    153194        if (atomic_get(&threads_fault) == 0)
    154195                return NULL;

  • kernel/test/sysinfo/sysinfo1.c

    r6536a4a9 rdeada67  
    3535char * test_sysinfo1(bool quiet)
    3636{
    37         sysinfo_dump(NULL, 0);
     37        if (!quiet)
     38                sysinfo_dump(NULL, 0);
    3839        return NULL;
    3940}

  • kernel/test/thread/thread1.c

    r6536a4a9 rdeada67  
    4141static atomic_t finish;
    4242static atomic_t threads_finished;
     43static bool sh_quiet;
    4344
    4445static void threadtest(void *data)
    … …  
    4748
    4849        while (atomic_get(&finish)) {
    49                 printf("%d\n", (int) (THREAD->tid));
     50                if (!sh_quiet)
     51                        printf("%d\n", (int) (THREAD->tid));
    5052                thread_usleep(100);
    5153        }
    … …  
    5658{
    5759        unsigned int i, total = 0;
     60        sh_quiet = quiet;
    5861       
    5962        atomic_set(&finish, 1);
    … …  
    6366                thread_t *t;
    6467                if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) {
    65                         printf("Could not create thread %d\n", i);
     68                        if (!quiet)
     69                                printf("Could not create thread %d\n", i);
    6670                        break;
    6771                }
    … …  
    7074        }
    7175       
    72         printf("Running threads for 10 seconds...\n");
     76        if (!quiet)
     77                printf("Running threads for 10 seconds...\n");
    7378        thread_sleep(10);
    7479       
    7580        atomic_set(&finish, 0);
    7681        while (atomic_get(&threads_finished) < total) {
    77                 printf("Threads left: %d\n", total - atomic_get(&threads_finished));
     82                if (!quiet)
     83                        printf("Threads left: %d\n", total - atomic_get(&threads_finished));
    7884                thread_sleep(1);
    7985        }
Note: See TracChangeset for help on using the changeset viewer.