Changeset c5613b7 in mainline

Timestamp:

2006-02-04T01:59:42Z (19 years ago)

Author:

Ondrej Palkovsky <ondrap@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

10e16a7

Parents:

81e52f2a

Message:

Added slab stress test.
Fixed race condition in slab allocator.
Moved initialization of slab to the point where we know correct config.cpu_count
Correctly passes tests on amd64, ia32 in both bochs & qemu.

Files:

• generic/src/main/main.c (modified) (2 diffs)
• generic/src/mm/slab.c (modified) (4 diffs)
• test/mm/slab2/test.c (modified) (5 diffs)

generic/src/main/main.c

@@ -164 +164 @@
         page_init();
         tlb_init();
-        slab_cache_init();
         arch_post_mm_init();
 
@@ -174 +173 @@
         arch_pre_smp_init();
         smp_init();
+        /* Slab must be initialized AFTER we know the number of processors */
+        slab_cache_init();
+
         printf("config.memory_size=%dM\n", config.memory_size/(1024*1024));
         printf("config.cpu_count=%d\n", config.cpu_count);

generic/src/mm/slab.c

@@ -387 +387 @@
  * no empty magazine is available and cannot be allocated
  *
+ * Assume mag_cache[CPU->id].lock is held
+ *
  * We have 2 magazines bound to processor. 
  * First try the current. 
@@ -421 +423 @@
 
         /* Flush last to magazine list */
-        if (lastmag)
+        if (lastmag) {
+                spinlock_lock(&cache->lock);
                 list_prepend(&lastmag->link, &cache->magazines);
+                spinlock_unlock(&cache->lock);
+        }
         /* Move current as last, save new as current */
         cache->mag_cache[CPU->id].last = cmag;  
@@ -514 +519 @@
         spinlock_initialize(&cache->lock, "cachelock");
         if (! (cache->flags & SLAB_CACHE_NOMAGAZINE)) {
-                for (i=0; i< config.cpu_count; i++) {
+                for (i=0; i < config.cpu_count; i++) {
                         memsetb((__address)&cache->mag_cache[i],
                                 sizeof(cache->mag_cache[i]), 0);
@@ -650 +655 @@
         ipl_t ipl;
         void *result = NULL;
-
+        
         /* Disable interrupts to avoid deadlocks with interrupt handlers */
         ipl = interrupts_disable();

test/mm/slab2/test.c

@@ -74 +74 @@
         }while(1);
         printf("done.\n");
-        slab_print_list();
         /* We do not have memory - now deallocate cache2 */
         printf("Deallocating cache2...");
@@ -84 +83 @@
         printf("done.\n");
 
-        slab_print_list();
         printf("Allocating to cache1...\n");
         for (i=0; i<30; i++) {
@@ -95 +93 @@
                 olddata1 = data1;
         }
-        slab_print_list();
         while (1) {
                 data1 = slab_alloc(cache1, FRAME_ATOMIC);
@@ -105 +102 @@
                 olddata1 = data1;
         }
-        slab_print_list();
         printf("Deallocating cache1...");
         while (olddata1) {
@@ -118 +114 @@
 }
 
+slab_cache_t *thr_cache;
+semaphore_t thr_sem;
+
+#define THREADS 8
+
+static void thread(void *priv)
+{
+        void *data=NULL, *new;
+
+        printf("Starting thread #%d...\n",THREAD->tid);
+
+        /* Alloc all */
+        printf("Thread #%d allocating...\n", THREAD->tid);
+        while (1) {
+                /* Call with atomic to detect end of memory */
+                new = slab_alloc(thr_cache, FRAME_ATOMIC);
+                if (!new)
+                        break;
+                *((void **)new) = data;
+                data = new;
+        }
+        printf("Thread #%d releasing...\n", THREAD->tid);
+        while (data) {
+                new = *((void **)data);
+                slab_free(thr_cache, data);
+                data = new;
+        }
+        printf("Thread #%d allocating...\n", THREAD->tid);
+        while (1) {
+                /* Call with atomic to detect end of memory */
+                new = slab_alloc(thr_cache, FRAME_ATOMIC);
+                if (!new)
+                        break;
+                *((void **)new) = data;
+                data = new;
+        }
+        printf("Thread #%d releasing...\n", THREAD->tid);
+        while (data) {
+                new = *((void **)data);
+                slab_free(thr_cache, data);
+                data = new;
+        }
+
+
+        printf("Thread #%d finished\n", THREAD->tid);
+        slab_print_list();
+        semaphore_up(&thr_sem);
+}
+
+
+static void multitest(int size)
+{
+        /* Start 8 threads that just allocate as much as possible,
+         * then release everything, then again allocate, then release
+         */
+        thread_t *t;
+        int i;
+
+        printf("Running stress test with size %d\n", size);
+        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(thread, NULL, TASK, 0)))
+                        panic("could not create thread\n");
+                thread_ready(t);
+        }
+
+        for (i=0; i<THREADS; i++)
+                semaphore_down(&thr_sem);
+        
+        slab_cache_destroy(thr_cache);
+        printf("Stress test complete.\n");
+}
+
 void test(void)
 {
-        printf("Running reclaim test .. pass1\n");
+        printf("Running reclaim single-thread test .. pass1\n");
         totalmemtest();
-        printf("Running reclaim test .. pass2\n");
+        printf("Running reclaim single-thread test .. pass2\n");
         totalmemtest();
         printf("Reclaim test OK.\n");
-}
+
+        multitest(128);
+        multitest(2048);
+        printf("All done.\n");
+}