| /trunk/kernel/test/test.c |
|---|
| 65,6 → 65,54 |
| &test_fpu1, |
| true |
| }, |
| { |
| "sse1", |
| "Intel SEE test", |
| &test_sse1, |
| true |
| }, |
| { |
| "mips2", |
| "MIPS FPU test", |
| &test_mips2, |
| true |
| }, |
| { |
| "falloc1", |
| "Frame allocator test 1", |
| &test_falloc1, |
| true |
| }, |
| { |
| "falloc2", |
| "Frame allocator test 2", |
| &test_falloc2, |
| true |
| }, |
| { |
| "mapping1", |
| "Mapping test", |
| &test_mapping1, |
| true |
| }, |
| { |
| "slab1", |
| "SLAB test 1", |
| &test_slab1, |
| true |
| }, |
| { |
| "slab2", |
| "SLAB test 2", |
| &test_slab2, |
| true |
| }, |
| { |
| "purge1", |
| "Itanium TLB purge test", |
| &test_purge1, |
| true |
| }, |
| {NULL, NULL, NULL} |
| }; |
| /trunk/kernel/test/test.h |
|---|
| 50,6 → 50,14 |
| extern void test_mips1(void); |
| extern void test_fault1(void); |
| extern void test_fpu1(void); |
| extern void test_sse1(void); |
| extern void test_mips2(void); |
| extern void test_falloc1(void); |
| extern void test_falloc2(void); |
| extern void test_mapping1(void); |
| extern void test_purge1(void); |
| extern void test_slab1(void); |
| extern void test_slab2(void); |
| extern test_t tests[]; |
| /trunk/kernel/test/mm/falloc2/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/mapping1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/slab1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/slab2/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/falloc1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/purge1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/mm/falloc1.c |
|---|
| 0,0 → 1,103 |
| /* |
| * Copyright (C) 2006 Sergey Bondari |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <test.h> |
| #include <mm/page.h> |
| #include <mm/frame.h> |
| #include <mm/slab.h> |
| #include <arch/mm/page.h> |
| #include <arch/types.h> |
| #include <debug.h> |
| #include <align.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #define MAX_FRAMES 1024 |
| #define MAX_ORDER 8 |
| #define TEST_RUNS 2 |
| void test_falloc1(void) { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| uintptr_t * frames = (uintptr_t *) malloc(MAX_FRAMES*sizeof(uintptr_t), 0); |
| int results[MAX_ORDER+1]; |
| int i, order, run; |
| int allocated; |
| ASSERT(TEST_RUNS > 1); |
| ASSERT(frames != NULL) |
| for (run = 0; run < TEST_RUNS; run++) { |
| for (order = 0; order <= MAX_ORDER; order++) { |
| printf("Allocating %d frames blocks ... ", 1 << order); |
| allocated = 0; |
| for (i = 0; i < MAX_FRAMES >> order; i++) { |
| frames[allocated] = (uintptr_t) frame_alloc(order, FRAME_ATOMIC | FRAME_KA); |
| if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) != frames[allocated]) { |
| panic("Test failed. Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10); |
| } |
| if (frames[allocated]) { |
| allocated++; |
| } else { |
| printf("done. "); |
| break; |
| } |
| } |
| printf("%d blocks allocated.\n", allocated); |
| if (run) { |
| if (results[order] != allocated) { |
| panic("Test failed. Frame leak possible.\n"); |
| } |
| } else |
| results[order] = allocated; |
| printf("Deallocating ... "); |
| for (i = 0; i < allocated; i++) { |
| frame_free(KA2PA(frames[i])); |
| } |
| printf("done.\n"); |
| } |
| } |
| free(frames); |
| printf("Test passed.\n"); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| /trunk/kernel/test/mm/falloc2.c |
|---|
| 0,0 → 1,134 |
| /* |
| * Copyright (C) 2006 Sergey Bondari |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <test.h> |
| #include <mm/page.h> |
| #include <mm/frame.h> |
| #include <mm/slab.h> |
| #include <arch/mm/page.h> |
| #include <arch/types.h> |
| #include <atomic.h> |
| #include <debug.h> |
| #include <proc/thread.h> |
| #include <memstr.h> |
| #include <arch.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #define MAX_FRAMES 256 |
| #define MAX_ORDER 8 |
| #define THREAD_RUNS 1 |
| #define THREADS 8 |
| static void falloc(void * arg); |
| static void failed(void); |
| static atomic_t thread_count; |
| void falloc(void * arg) |
| { |
| int order, run, allocated, i; |
| uint8_t val = THREAD->tid % THREADS; |
| index_t k; |
| uintptr_t * frames = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC); |
| ASSERT(frames != NULL); |
| thread_detach(THREAD); |
| for (run = 0; run < THREAD_RUNS; run++) { |
| for (order = 0; order <= MAX_ORDER; order++) { |
| printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order); |
| allocated = 0; |
| for (i = 0; i < (MAX_FRAMES >> order); i++) { |
| frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA); |
| if (frames[allocated]) { |
| memsetb(frames[allocated], FRAME_SIZE << order, val); |
| allocated++; |
| } else { |
| break; |
| } |
| } |
| printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated); |
| printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id); |
| for (i = 0; i < allocated; i++) { |
| for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) { |
| if (((uint8_t *) frames[i])[k] != val) { |
| 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); |
| failed(); |
| } |
| } |
| frame_free(KA2PA(frames[i])); |
| } |
| printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id); |
| } |
| } |
| free(frames); |
| printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id); |
| atomic_dec(&thread_count); |
| } |
| void failed(void) |
| { |
| panic("Test failed.\n"); |
| } |
| void test_falloc2(void) |
| { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| int i; |
| atomic_set(&thread_count, THREADS); |
| for (i = 0; i < THREADS; i++) { |
| thread_t * thrd; |
| thrd = thread_create(falloc, NULL, TASK, 0, "falloc"); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| failed(); |
| } |
| while (thread_count.count) |
| ; |
| printf("Test passed.\n"); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| /trunk/kernel/test/mm/slab1.c |
|---|
| 0,0 → 1,171 |
| /* |
| * Copyright (C) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <test.h> |
| #include <mm/slab.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #include <panic.h> |
| #include <memstr.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #define VAL_COUNT 1024 |
| void * data[VAL_COUNT]; |
| static void testit(int size, int count) |
| { |
| slab_cache_t *cache; |
| int i; |
| printf("Creating cache, object size: %d.\n", size); |
| cache = slab_cache_create("test_cache", size, 0, NULL, NULL, |
| SLAB_CACHE_NOMAGAZINE); |
| printf("Allocating %d items...", count); |
| for (i=0; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb((uintptr_t)data[i], size, 0); |
| } |
| printf("done.\n"); |
| printf("Freeing %d items...", count); |
| for (i=0; i < count; i++) { |
| slab_free(cache, data[i]); |
| } |
| printf("done.\n"); |
| printf("Allocating %d items...", count); |
| for (i=0; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb((uintptr_t)data[i], size, 0); |
| } |
| printf("done.\n"); |
| printf("Freeing %d items...", count/2); |
| for (i=count-1; i >= count/2; i--) { |
| slab_free(cache, data[i]); |
| } |
| printf("done.\n"); |
| printf("Allocating %d items...", count/2); |
| for (i=count/2; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb((uintptr_t)data[i], size, 0); |
| } |
| printf("done.\n"); |
| printf("Freeing %d items...", count); |
| for (i=0; i < count; i++) { |
| slab_free(cache, data[i]); |
| } |
| printf("done.\n"); |
| slab_cache_destroy(cache); |
| printf("Test complete.\n"); |
| } |
| static void testsimple(void) |
| { |
| testit(100, VAL_COUNT); |
| testit(200, VAL_COUNT); |
| testit(1024, VAL_COUNT); |
| testit(2048, 512); |
| testit(4000, 128); |
| testit(8192, 128); |
| testit(16384, 128); |
| testit(16385, 128); |
| } |
| #define THREADS 6 |
| #define THR_MEM_COUNT 1024 |
| #define THR_MEM_SIZE 128 |
| void * thr_data[THREADS][THR_MEM_COUNT]; |
| slab_cache_t *thr_cache; |
| semaphore_t thr_sem; |
| static void slabtest(void *data) |
| { |
| int offs = (int)(unative_t) data; |
| int i,j; |
| thread_detach(THREAD); |
| printf("Starting thread #%d...\n",THREAD->tid); |
| for (j=0; j<10; j++) { |
| for (i=0; i<THR_MEM_COUNT; i++) |
| thr_data[offs][i] = slab_alloc(thr_cache,0); |
| for (i=0; i<THR_MEM_COUNT/2; i++) |
| slab_free(thr_cache, thr_data[offs][i]); |
| for (i=0; i< THR_MEM_COUNT/2; i++) |
| thr_data[offs][i] = slab_alloc(thr_cache, 0); |
| for (i=0; i<THR_MEM_COUNT;i++) |
| slab_free(thr_cache, thr_data[offs][i]); |
| } |
| printf("Thread #%d finished\n", THREAD->tid); |
| semaphore_up(&thr_sem); |
| } |
| static void testthreads(void) |
| { |
| thread_t *t; |
| int i; |
| thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0, |
| NULL, NULL, |
| SLAB_CACHE_NOMAGAZINE); |
| semaphore_initialize(&thr_sem,0); |
| for (i=0; i<THREADS; i++) { |
| if (!(t = thread_create(slabtest, (void *)(unative_t)i, TASK, 0, "slabtest"))) |
| 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("Test complete.\n"); |
| } |
| void test_slab1(void) |
| { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| testsimple(); |
| testthreads(); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| /trunk/kernel/test/mm/purge1.c |
|---|
| 0,0 → 1,92 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <test.h> |
| #include <mm/page.h> |
| #include <mm/frame.h> |
| #include <mm/as.h> |
| #include <arch/mm/page.h> |
| #include <arch/mm/tlb.h> |
| #include <arch/types.h> |
| #include <debug.h> |
| #ifdef ia64 |
| extern void tlb_invalidate_all(void); |
| extern void tlb_invalidate_pages(asid_t asid, uintptr_t va, count_t cnt); |
| void test(void) |
| { |
| tlb_entry_t entryi; |
| tlb_entry_t entryd; |
| int i; |
| entryd.word[0] = 0; |
| entryd.word[1] = 0; |
| entryd.p = true; /* present */ |
| entryd.ma = MA_WRITEBACK; |
| entryd.a = true; /* already accessed */ |
| entryd.d = true; /* already dirty */ |
| entryd.pl = PL_KERNEL; |
| entryd.ar = AR_READ | AR_WRITE; |
| entryd.ppn = 0; |
| entryd.ps = PAGE_WIDTH; |
| entryi.word[0] = 0; |
| entryi.word[1] = 0; |
| entryi.p = true; /* present */ |
| entryi.ma = MA_WRITEBACK; |
| entryi.a = true; /* already accessed */ |
| entryi.d = true; /* already dirty */ |
| entryi.pl = PL_KERNEL; |
| entryi.ar = AR_READ | AR_EXECUTE; |
| entryi.ppn = 0; |
| entryi.ps = PAGE_WIDTH; |
| for (i = 0; i < 100; i++) { |
| itc_mapping_insert(0 + i * (1 << PAGE_WIDTH), 8, entryi); |
| dtc_mapping_insert(0 + i * (1 << PAGE_WIDTH), 9, entryd); |
| } |
| tlb_invalidate_pages(8,0x0c000,14); |
| /*tlb_invalidate_all();*/ |
| } |
| #else |
| void test_purge1(void) |
| { |
| printf("This test is availaible only on IA64 platform.\n"); |
| } |
| #endif |
| /trunk/kernel/test/mm/slab2.c |
|---|
| 0,0 → 1,234 |
| /* |
| * Copyright (C) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <test.h> |
| #include <mm/slab.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #include <panic.h> |
| #include <mm/frame.h> |
| #include <memstr.h> |
| #include <synch/condvar.h> |
| #include <synch/mutex.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #define ITEM_SIZE 256 |
| /** Fill memory with 2 caches, when allocation fails, |
| * free one of the caches. We should have everything in magazines, |
| * now allocation should clean magazines and allow for full allocation. |
| */ |
| static void totalmemtest(void) |
| { |
| slab_cache_t *cache1; |
| slab_cache_t *cache2; |
| int i; |
| void *data1, *data2; |
| 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..."); |
| /* 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) |
| slab_free(cache1,data1); |
| if (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; |
| olddata1 = data1; |
| olddata2 = data2; |
| }while(1); |
| printf("done.\n"); |
| /* We do not have memory - now deallocate cache2 */ |
| printf("Deallocating cache2..."); |
| while (olddata2) { |
| data2 = *((void **)olddata2); |
| slab_free(cache2, olddata2); |
| olddata2 = data2; |
| } |
| printf("done.\n"); |
| printf("Allocating to cache1...\n"); |
| for (i=0; i<30; i++) { |
| data1 = slab_alloc(cache1, FRAME_ATOMIC); |
| if (!data1) { |
| panic("Incorrect memory size - use another test."); |
| } |
| 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..."); |
| while (olddata1) { |
| data1 = *((void **)olddata1); |
| slab_free(cache1, olddata1); |
| olddata1 = data1; |
| } |
| printf("done.\n"); |
| slab_print_list(); |
| slab_cache_destroy(cache1); |
| slab_cache_destroy(cache2); |
| } |
| slab_cache_t *thr_cache; |
| semaphore_t thr_sem; |
| condvar_t thread_starter; |
| mutex_t starter_mutex; |
| #define THREADS 8 |
| static void slabtest(void *priv) |
| { |
| 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); |
| /* 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); |
| *((void **)data) = NULL; |
| 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); |
| *((void **)data) = NULL; |
| 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); |
| condvar_initialize(&thread_starter); |
| mutex_initialize(&starter_mutex); |
| 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"))) |
| panic("could not create thread\n"); |
| thread_ready(t); |
| } |
| thread_sleep(1); |
| condvar_broadcast(&thread_starter); |
| for (i=0; i<THREADS; i++) |
| semaphore_down(&thr_sem); |
| slab_cache_destroy(thr_cache); |
| printf("Stress test complete.\n"); |
| } |
| void test_slab2(void) |
| { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| printf("Running reclaim single-thread test .. pass1\n"); |
| totalmemtest(); |
| printf("Running reclaim single-thread test .. pass2\n"); |
| totalmemtest(); |
| printf("Reclaim test OK.\n"); |
| multitest(128); |
| multitest(2048); |
| multitest(8192); |
| printf("All done.\n"); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| /trunk/kernel/test/mm/mapping1.c |
|---|
| 0,0 → 1,95 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <test.h> |
| #include <mm/page.h> |
| #include <mm/frame.h> |
| #include <mm/as.h> |
| #include <arch/mm/page.h> |
| #include <arch/types.h> |
| #include <debug.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #define PAGE0 0x10000000 |
| #define PAGE1 (PAGE0+PAGE_SIZE) |
| #define VALUE0 0x01234567 |
| #define VALUE1 0x89abcdef |
| void test_mapping1(void) |
| { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| uintptr_t frame0, frame1; |
| uint32_t v0, v1; |
| printf("Memory management test mapping #1\n"); |
| frame0 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA); |
| frame1 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA); |
| printf("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0)); |
| *((uint32_t *) frame0) = VALUE0; |
| printf("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1)); |
| *((uint32_t *) frame1) = VALUE1; |
| printf("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0)); |
| page_mapping_insert(AS_KERNEL, PAGE0, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE); |
| printf("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1)); |
| page_mapping_insert(AS_KERNEL, PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE); |
| printf("Value at virtual address %p is %#x.\n", PAGE0, v0 = *((uint32_t *) PAGE0)); |
| printf("Value at virtual address %p is %#x.\n", PAGE1, v1 = *((uint32_t *) PAGE1)); |
| ASSERT(v0 == VALUE0); |
| ASSERT(v1 == VALUE1); |
| printf("Writing %#x to virtual address %p.\n", 0, PAGE0); |
| *((uint32_t *) PAGE0) = 0; |
| printf("Writing %#x to virtual address %p.\n", 0, PAGE1); |
| *((uint32_t *) PAGE1) = 0; |
| v0 = *((uint32_t *) PAGE0); |
| v1 = *((uint32_t *) PAGE1); |
| printf("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0)); |
| printf("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1)); |
| ASSERT(v0 == 0); |
| ASSERT(v1 == 0); |
| printf("Test passed.\n"); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| /trunk/kernel/test/fpu/sse1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/fpu/mips1/test.c |
|---|
| File deleted |
| /trunk/kernel/test/fpu/mips2.c |
|---|
| 0,0 → 1,147 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <debug.h> |
| #include <panic.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <time/delay.h> |
| #include <arch.h> |
| #ifdef mips32 |
| #define THREADS 50 |
| #define DELAY 10000L |
| #define ATTEMPTS 5 |
| static atomic_t threads_ok; |
| static waitq_t can_start; |
| static void testit1(void *data) |
| { |
| int i; |
| int arg __attribute__((aligned(16))) = (int)((unative_t) data); |
| int after_arg __attribute__((aligned(16))); |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| __asm__ volatile ( |
| "mtc1 %0,$1" |
| :"=r"(arg) |
| ); |
| delay(DELAY); |
| __asm__ volatile ( |
| "mfc1 %0, $1" |
| :"=r"(after_arg) |
| ); |
| if(arg != after_arg) |
| panic("General reg tid%d: arg(%d) != %d\n", |
| THREAD->tid, arg, after_arg); |
| } |
| atomic_inc(&threads_ok); |
| } |
| static void testit2(void *data) |
| { |
| int i; |
| int arg __attribute__((aligned(16))) = (int)((unative_t) data); |
| int after_arg __attribute__((aligned(16))); |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| __asm__ volatile ( |
| "mtc1 %0,$1" |
| :"=r"(arg) |
| ); |
| scheduler(); |
| __asm__ volatile ( |
| "mfc1 %0,$1" |
| :"=r"(after_arg) |
| ); |
| if(arg != after_arg) |
| panic("General reg tid%d: arg(%d) != %d\n", |
| THREAD->tid, arg, after_arg); |
| } |
| atomic_inc(&threads_ok); |
| } |
| void test_mips2(void) |
| { |
| thread_t *t; |
| int i; |
| waitq_initialize(&can_start); |
| printf("MIPS test #1\n"); |
| printf("Creating %d threads... ", THREADS); |
| for (i=0; i<THREADS/2; i++) { |
| if (!(t = thread_create(testit1, (void *)((unative_t)i*2), TASK, 0, "testit1"))) |
| panic("could not create thread\n"); |
| thread_ready(t); |
| if (!(t = thread_create(testit2, (void *)((unative_t)i*2+1), TASK, 0, "testit2"))) |
| panic("could not create thread\n"); |
| thread_ready(t); |
| } |
| printf("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != THREADS) |
| ; |
| printf("Test passed.\n"); |
| } |
| #else |
| void test_mips2(void) |
| { |
| printf("This test is availaible only on MIPS32 platform.\n"); |
| } |
| #endif |
| /trunk/kernel/test/fpu/sse1.c |
|---|
| 0,0 → 1,158 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <print.h> |
| #include <debug.h> |
| #include <panic.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <time/delay.h> |
| #include <arch.h> |
| #ifdef CONFIG_BENCH |
| #include <arch/cycle.h> |
| #endif |
| #if (defined(ia32) || defined(amd64) || defined(ia32xen)) |
| #define THREADS 50 |
| #define DELAY 10000L |
| #define ATTEMPTS 5 |
| static atomic_t threads_ok; |
| static waitq_t can_start; |
| static void testit1(void *data) |
| { |
| int i; |
| int arg __attribute__((aligned(16))) = (int)((unative_t) data); |
| int after_arg __attribute__((aligned(16))); |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| __asm__ volatile ( |
| "movlpd %0, %%xmm2" |
| :"=m"(arg) |
| ); |
| delay(DELAY); |
| __asm__ volatile ( |
| "movlpd %%xmm2, %0" |
| :"=m"(after_arg) |
| ); |
| if(arg != after_arg) |
| panic("tid%d: arg(%d) != %d\n", |
| THREAD->tid, arg, after_arg); |
| } |
| atomic_inc(&threads_ok); |
| } |
| static void testit2(void *data) |
| { |
| int i; |
| int arg __attribute__((aligned(16))) = (int)((unative_t) data); |
| int after_arg __attribute__((aligned(16))); |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| __asm__ volatile ( |
| "movlpd %0, %%xmm2" |
| :"=m"(arg) |
| ); |
| scheduler(); |
| __asm__ volatile ( |
| "movlpd %%xmm2, %0" |
| :"=m"(after_arg) |
| ); |
| if(arg != after_arg) |
| panic("tid%d: arg(%d) != %d\n", |
| THREAD->tid, arg, after_arg); |
| } |
| atomic_inc(&threads_ok); |
| } |
| void test_sse1(void) |
| { |
| #ifdef CONFIG_BENCH |
| uint64_t t0 = get_cycle(); |
| #endif |
| thread_t *t; |
| int i; |
| waitq_initialize(&can_start); |
| printf("SSE test #1\n"); |
| printf("Creating %d threads... ", THREADS); |
| for (i=0; i<THREADS/2; i++) { |
| if (!(t = thread_create(testit1, (void *)((unative_t)i*2), TASK, 0, "testit1"))) |
| panic("could not create thread\n"); |
| thread_ready(t); |
| if (!(t = thread_create(testit2, (void *)((unative_t)i*2+1), TASK, 0, "testit2"))) |
| panic("could not create thread\n"); |
| thread_ready(t); |
| } |
| printf("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != THREADS) |
| ; |
| printf("Test passed.\n"); |
| #ifdef CONFIG_BENCH |
| uint64_t dt = get_cycle() - t0; |
| printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt); |
| #endif |
| } |
| #else |
| void test_sse1(void) |
| { |
| printf("This test is available only on SSE enabled platforms."); |
| } |
| #endif |