Changeset deada67 in mainline for kernel/test/mm/slab2.c

Timestamp:

2006-12-19T17:54:50Z (19 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

File:

• kernel/test/mm/slab2.c (modified) (8 diffs)

kernel/test/mm/slab2.c

@@ -43 +43 @@
  *  now allocation should clean magazines and allow for full allocation.
  */
-static void totalmemtest(void)
+static void totalmemtest(bool quiet)
 {
         slab_cache_t *cache1;
@@ -50 +50 @@
 
         void *data1, *data2;
-        void *olddata1=NULL, *olddata2=NULL;
+        void *olddata1 = NULL, *olddata2 = NULL;
         
         cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0);
         cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
-
-        printf("Allocating...");
+        
+        if (!quiet)
+                printf("Allocating...");
+        
         /* Use atomic alloc, so that we find end of memory */
         do {
                 data1 = slab_alloc(cache1, FRAME_ATOMIC);
                 data2 = slab_alloc(cache2, FRAME_ATOMIC);
-                if (!data1 || !data2) {
+                if ((!data1) || (!data2)) {
                         if (data1)
-                                slab_free(cache1,data1);
+                                slab_free(cache1, data1);
                         if (data2)
-                                slab_free(cache2,data2);
+                                slab_free(cache2, data2);
                         break;
                 }
-                memsetb((uintptr_t)data1, ITEM_SIZE, 0);
-                memsetb((uintptr_t)data2, ITEM_SIZE, 0);
-                *((void **)data1) = olddata1;
-                *((void **)data2) = olddata2;
+                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
+                memsetb((uintptr_t) data2, ITEM_SIZE, 0);
+                *((void **) data1) = olddata1;
+                *((void **) data2) = olddata2;
                 olddata1 = data1;
                 olddata2 = data2;
-        } while(1);
-        printf("done.\n");
+        } while (1);
+        
+        if (!quiet) {
+                printf("done.\n");
+                printf("Deallocating cache2...");
+        }
+        
         /* We do not have memory - now deallocate cache2 */
-        printf("Deallocating cache2...");
         while (olddata2) {
-                data2 = *((void **)olddata2);
+                data2 = *((void **) olddata2);
                 slab_free(cache2, olddata2);
                 olddata2 = data2;
         }
-        printf("done.\n");
-
-        printf("Allocating to cache1...\n");
-        for (i=0; i<30; i++) {
+        
+        if (!quiet) {
+                printf("done.\n");
+                printf("Allocating to cache1...\n");
+        }
+        
+        for (i = 0; i < 30; i++) {
                 data1 = slab_alloc(cache1, FRAME_ATOMIC);
                 if (!data1) {
-                        printf("Incorrect memory size - use another test.");
+                        if (!quiet)
+                                printf("Incorrect memory size - use another test.");
                         return;
                 }
-                memsetb((uintptr_t)data1, ITEM_SIZE, 0);
-                *((void **)data1) = olddata1;
+                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
+                *((void **) data1) = olddata1;
                 olddata1 = data1;
         }
         while (1) {
                 data1 = slab_alloc(cache1, FRAME_ATOMIC);
-                if (!data1) {
-                        break;
-                }
-                memsetb((uintptr_t)data1, ITEM_SIZE, 0);
-                *((void **)data1) = olddata1;
-                olddata1 = data1;
-        }
-        printf("Deallocating cache1...");
+                if (!data1)
+                        break;
+                memsetb((uintptr_t) data1, ITEM_SIZE, 0);
+                *((void **) data1) = olddata1;
+                olddata1 = data1;
+        }
+        
+        if (!quiet)
+                printf("Deallocating cache1...");
+        
         while (olddata1) {
-                data1 = *((void **)olddata1);
+                data1 = *((void **) olddata1);
                 slab_free(cache1, olddata1);
                 olddata1 = data1;
         }
-        printf("done.\n");
-        slab_print_list();
+        
+        if (!quiet) {
+                printf("done.\n");
+                slab_print_list();
+        }
+        
         slab_cache_destroy(cache1);
         slab_cache_destroy(cache2);
@@ -120 +136 @@
 static condvar_t thread_starter;
 static mutex_t starter_mutex;
+static bool sh_quiet;
 
 #define THREADS 8
@@ -126 +143 @@
 {
         void *data = NULL, *new;
-
+        
         thread_detach(THREAD);
-
+        
         mutex_lock(&starter_mutex);
         condvar_wait(&thread_starter,&starter_mutex);
         mutex_unlock(&starter_mutex);
-                
-        printf("Starting thread #%d...\n",THREAD->tid);
+        
+        if (!sh_quiet)
+                printf("Starting thread #%d...\n",THREAD->tid);
 
         /* Alloc all */
-        printf("Thread #%d allocating...\n", THREAD->tid);
+        if (!sh_quiet)
+                printf("Thread #%d allocating...\n", THREAD->tid);
+        
         while (1) {
                 /* Call with atomic to detect end of memory */
@@ -142 +162 @@
                 if (!new)
                         break;
-                *((void **)new) = data;
-                data = new;
-        }
-        printf("Thread #%d releasing...\n", THREAD->tid);
+                *((void **) new) = data;
+                data = new;
+        }
+        
+        if (!sh_quiet)
+                printf("Thread #%d releasing...\n", THREAD->tid);
+        
         while (data) {
                 new = *((void **)data);
-                *((void **)data) = NULL;
+                *((void **) data) = NULL;
                 slab_free(thr_cache, data);
                 data = new;
         }
-        printf("Thread #%d allocating...\n", THREAD->tid);
+        
+        if (!sh_quiet)
+                printf("Thread #%d allocating...\n", THREAD->tid);
+        
         while (1) {
                 /* Call with atomic to detect end of memory */
@@ -158 +184 @@
                 if (!new)
                         break;
-                *((void **)new) = data;
-                data = new;
-        }
-        printf("Thread #%d releasing...\n", THREAD->tid);
+                *((void **) new) = data;
+                data = new;
+        }
+        
+        if (!sh_quiet)
+                printf("Thread #%d releasing...\n", THREAD->tid);
+        
         while (data) {
                 new = *((void **)data);
-                *((void **)data) = NULL;
+                *((void **) data) = NULL;
                 slab_free(thr_cache, data);
                 data = new;
         }
-
-        printf("Thread #%d finished\n", THREAD->tid);
+        
+        if (!sh_quiet)
+                printf("Thread #%d finished\n", THREAD->tid);
+        
         slab_print_list();
         semaphore_up(&thr_sem);
 }
 
-static void multitest(int size)
+static void multitest(int size, bool quiet)
 {
         /* Start 8 threads that just allocate as much as possible,
@@ -181 +212 @@
         thread_t *t;
         int i;
-
-        printf("Running stress test with size %d\n", size);
+        
+        if (!quiet)
+                printf("Running stress test with size %d\n", size);
+        
         condvar_initialize(&thread_starter);
         mutex_initialize(&starter_mutex);
 
-        thr_cache = slab_cache_create("thread_cache", size, 0, 
-                                      NULL, NULL, 
-                                      0);
+        thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
         semaphore_initialize(&thr_sem,0);
         for (i = 0; i < THREADS; i++) {  
-                if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false)))
-                        printf("Could not create thread %d\n", i);
-                else
+                if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
+                        if (!quiet)
+                                printf("Could not create thread %d\n", i);
+                } else
                         thread_ready(t);
         }
@@ -203 +235 @@
         
         slab_cache_destroy(thr_cache);
-        printf("Stress test complete.\n");
+        if (!quiet)
+                printf("Stress test complete.\n");
 }
 
 char * test_slab2(bool quiet)
 {
-        printf("Running reclaim single-thread test .. pass 1\n");
-        totalmemtest();
-        printf("Running reclaim single-thread test .. pass 2\n");
-        totalmemtest();
-        printf("Reclaim test OK.\n");
-
-        multitest(128);
-        multitest(2048);
-        multitest(8192);
-        printf("All done.\n");
+        sh_quiet = quiet;
+        
+        if (!quiet)
+                printf("Running reclaim single-thread test .. pass 1\n");
+        totalmemtest(quiet);
+        if (!quiet)
+                printf("Running reclaim single-thread test .. pass 2\n");
+        totalmemtest(quiet);
+        if (!quiet)
+                printf("Reclaim test OK.\n");
+        
+        multitest(128, quiet);
+        multitest(2048, quiet);
+        multitest(8192, quiet);
         
         return NULL;