| 42,7 → 42,7 |
|---|
| * free one of the caches. We should have everything in magazines, |
| * now allocation should clean magazines and allow for full allocation. |
| */ |
| static void totalmemtest(bool quiet) |
| static void totalmemtest(void) |
| { |
| slab_cache_t *cache1; |
| slab_cache_t *cache2; |
| 54,8 → 54,7 |
|---|
| cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0); |
| cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0); |
| |
| if (!quiet) |
| printf("Allocating..."); |
| TPRINTF("Allocating..."); |
| |
| /* Use atomic alloc, so that we find end of memory */ |
| do { |
| 74,13 → 73,12 |
|---|
| *((void **) data2) = olddata2; |
| olddata1 = data1; |
| olddata2 = data2; |
| } while (1); |
| } while (true); |
| |
| if (!quiet) { |
| printf("done.\n"); |
| printf("Deallocating cache2..."); |
| } |
| TPRINTF("done.\n"); |
| |
| TPRINTF("Deallocating cache2..."); |
| |
| /* We do not have memory - now deallocate cache2 */ |
| while (olddata2) { |
| data2 = *((void **) olddata2); |
| 88,16 → 86,14 |
|---|
| olddata2 = data2; |
| } |
| |
| if (!quiet) { |
| printf("done.\n"); |
| printf("Allocating to cache1...\n"); |
| } |
| TPRINTF("done.\n"); |
| |
| TPRINTF("Allocating to cache1...\n"); |
| |
| for (i = 0; i < 30; i++) { |
| data1 = slab_alloc(cache1, FRAME_ATOMIC); |
| if (!data1) { |
| if (!quiet) |
| printf("Incorrect memory size - use another test."); |
| TPRINTF("Incorrect memory size - use another test."); |
| return; |
| } |
| memsetb(data1, ITEM_SIZE, 0); |
| 104,7 → 100,7 |
|---|
| *((void **) data1) = olddata1; |
| olddata1 = data1; |
| } |
| while (1) { |
| while (true) { |
| data1 = slab_alloc(cache1, FRAME_ATOMIC); |
| if (!data1) |
| break; |
| 113,8 → 109,7 |
|---|
| olddata1 = data1; |
| } |
| |
| if (!quiet) |
| printf("Deallocating cache1..."); |
| TPRINTF("Deallocating cache1..."); |
| |
| while (olddata1) { |
| data1 = *((void **) olddata1); |
| 122,10 → 117,10 |
|---|
| olddata1 = data1; |
| } |
| |
| if (!quiet) { |
| printf("done.\n"); |
| TPRINTF("done.\n"); |
| |
| if (!test_quiet) |
| slab_print_list(); |
| } |
| |
| slab_cache_destroy(cache1); |
| slab_cache_destroy(cache2); |
| 135,7 → 130,6 |
|---|
| static semaphore_t thr_sem; |
| static condvar_t thread_starter; |
| static mutex_t starter_mutex; |
| static bool sh_quiet; |
| |
| #define THREADS 8 |
| |
| 149,14 → 143,12 |
|---|
| condvar_wait(&thread_starter,&starter_mutex); |
| mutex_unlock(&starter_mutex); |
| |
| if (!sh_quiet) |
| printf("Starting thread #%" PRIu64 "...\n", THREAD->tid); |
| TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid); |
| |
| /* Alloc all */ |
| if (!sh_quiet) |
| printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| |
| while (1) { |
| while (true) { |
| /* Call with atomic to detect end of memory */ |
| new = slab_alloc(thr_cache, FRAME_ATOMIC); |
| if (!new) |
| 165,8 → 157,7 |
|---|
| data = new; |
| } |
| |
| if (!sh_quiet) |
| printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| |
| while (data) { |
| new = *((void **)data); |
| 175,10 → 166,9 |
|---|
| data = new; |
| } |
| |
| if (!sh_quiet) |
| printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| |
| while (1) { |
| while (true) { |
| /* Call with atomic to detect end of memory */ |
| new = slab_alloc(thr_cache, FRAME_ATOMIC); |
| if (!new) |
| 187,8 → 177,7 |
|---|
| data = new; |
| } |
| |
| if (!sh_quiet) |
| printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| |
| while (data) { |
| new = *((void **)data); |
| 197,14 → 186,15 |
|---|
| data = new; |
| } |
| |
| if (!sh_quiet) |
| printf("Thread #%" PRIu64 " finished\n", THREAD->tid); |
| TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid); |
| |
| if (!test_quiet) |
| slab_print_list(); |
| |
| semaphore_up(&thr_sem); |
| } |
| |
| static void multitest(int size, bool quiet) |
| static void multitest(int size) |
| { |
| /* Start 8 threads that just allocate as much as possible, |
| * then release everything, then again allocate, then release |
| 212,8 → 202,7 |
|---|
| thread_t *t; |
| int i; |
| |
| if (!quiet) |
| printf("Running stress test with size %d\n", size); |
| TPRINTF("Running stress test with size %d\n", size); |
| |
| condvar_initialize(&thread_starter); |
| mutex_initialize(&starter_mutex, MUTEX_PASSIVE); |
| 222,8 → 211,7 |
|---|
| semaphore_initialize(&thr_sem,0); |
| for (i = 0; i < THREADS; i++) { |
| if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) { |
| if (!quiet) |
| printf("Could not create thread %d\n", i); |
| TPRINTF("Could not create thread %d\n", i); |
| } else |
| thread_ready(t); |
| } |
| 234,26 → 222,22 |
|---|
| semaphore_down(&thr_sem); |
| |
| slab_cache_destroy(thr_cache); |
| if (!quiet) |
| printf("Stress test complete.\n"); |
| TPRINTF("Stress test complete.\n"); |
| } |
| |
| char * test_slab2(bool quiet) |
| char *test_slab2(void) |
| { |
| sh_quiet = quiet; |
| TPRINTF("Running reclaim single-thread test .. pass 1\n"); |
| totalmemtest(); |
| |
| 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"); |
| TPRINTF("Running reclaim single-thread test .. pass 2\n"); |
| totalmemtest(); |
| |
| multitest(128, quiet); |
| multitest(2048, quiet); |
| multitest(8192, quiet); |
| TPRINTF("Reclaim test OK.\n"); |
| |
| multitest(128); |
| multitest(2048); |
| multitest(8192); |
| |
| return NULL; |
| } |