| /tags/0.4.1/kernel/test/avltree/avltree1.c |
|---|
| 0,0 → 1,282 |
| /* |
| * Copyright (c) 2007 Vojtech Mencl |
| * 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 <print.h> |
| #include <adt/avl.h> |
| #include <debug.h> |
| #include <arch/types.h> |
| #define NODE_COUNT 100 |
| static avltree_t avltree; |
| /* |
| * avl tree nodes in array for faster allocation |
| */ |
| static avltree_node_t avltree_nodes[NODE_COUNT]; |
| /* |
| * head of free nodes' list: |
| */ |
| static avltree_node_t *first_free_node = NULL; |
| static int test_tree_balance(avltree_node_t *node); |
| static avltree_node_t *test_tree_parents(avltree_node_t *node); |
| static void print_tree_structure_flat (avltree_node_t *node, int level) |
| __attribute__ ((used)); |
| static avltree_node_t *alloc_avltree_node(void); |
| static avltree_node_t *test_tree_parents(avltree_node_t *node) |
| { |
| avltree_node_t *tmp; |
| if (!node) |
| return NULL; |
| if (node->lft) { |
| tmp = test_tree_parents(node->lft); |
| if (tmp != node) { |
| TPRINTF("Bad parent pointer key: %" PRIu64 |
| ", address: %p\n", tmp->key, node->lft); |
| } |
| } |
| if (node->rgt) { |
| tmp = test_tree_parents(node->rgt); |
| if (tmp != node) { |
| TPRINTF("Bad parent pointer key: %" PRIu64 |
| ", address: %p\n", |
| tmp->key,node->rgt); |
| } |
| } |
| return node->par; |
| } |
| int test_tree_balance(avltree_node_t *node) |
| { |
| int h1, h2, diff; |
| if (!node) |
| return 0; |
| h1 = test_tree_balance(node->lft); |
| h2 = test_tree_balance(node->rgt); |
| diff = h2 - h1; |
| if ((diff != node->balance) || ((diff != -1) && (diff != 0) && (diff != 1))) |
| TPRINTF("Bad balance\n"); |
| return ((h1 > h2) ? (h1 + 1) : (h2 + 1)); |
| } |
| /** |
| * Prints the structure of the node, which is level levels from the top of the |
| * tree. |
| */ |
| static void print_tree_structure_flat(avltree_node_t *node, int level) |
| { |
| /* |
| * You can set the maximum level as high as you like. |
| * Most of the time, you'll want to debug code using small trees, |
| * so that a large level indicates a loop, which is a bug. |
| */ |
| if (level > 16) { |
| TPRINTF("[...]"); |
| return; |
| } |
| if (node == NULL) |
| return; |
| TPRINTF("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance); |
| if (node->lft != NULL || node->rgt != NULL) { |
| TPRINTF("("); |
| print_tree_structure_flat(node->lft, level + 1); |
| if (node->rgt != NULL) { |
| TPRINTF(","); |
| print_tree_structure_flat(node->rgt, level + 1); |
| } |
| TPRINTF(")"); |
| } |
| } |
| static void alloc_avltree_node_prepare(void) |
| { |
| int i; |
| for (i = 0; i < NODE_COUNT - 1; i++) |
| avltree_nodes[i].par = &avltree_nodes[i + 1]; |
| avltree_nodes[i].par = NULL; |
| /* |
| * Node keys which will be used for insertion. Up to NODE_COUNT size of |
| * array. |
| */ |
| /* First tree node and same key */ |
| avltree_nodes[0].key = 60; |
| avltree_nodes[1].key = 60; |
| avltree_nodes[2].key = 60; |
| /* LL rotation */ |
| avltree_nodes[3].key = 50; |
| avltree_nodes[4].key = 40; |
| avltree_nodes[5].key = 30; |
| /* LR rotation */ |
| avltree_nodes[6].key = 20; |
| avltree_nodes[7].key = 20; |
| avltree_nodes[8].key = 25; |
| avltree_nodes[9].key = 25; |
| /* LL rotation in lower floor */ |
| avltree_nodes[10].key = 35; |
| /* RR rotation */ |
| avltree_nodes[11].key = 70; |
| avltree_nodes[12].key = 80; |
| /* RL rotation */ |
| avltree_nodes[13].key = 90; |
| avltree_nodes[14].key = 85; |
| /* Insert 0 key */ |
| avltree_nodes[15].key = 0; |
| avltree_nodes[16].key = 0; |
| /* Insert reverse */ |
| avltree_nodes[17].key = 600; |
| avltree_nodes[18].key = 500; |
| avltree_nodes[19].key = 400; |
| avltree_nodes[20].key = 300; |
| for (i = 21; i < NODE_COUNT; i++) |
| avltree_nodes[i].key = i * 3; |
| first_free_node = &avltree_nodes[0]; |
| } |
| static avltree_node_t *alloc_avltree_node(void) |
| { |
| avltree_node_t *node; |
| node = first_free_node; |
| first_free_node = first_free_node->par; |
| return node; |
| } |
| static void test_tree_insert(avltree_t *tree, size_t node_count) |
| { |
| unsigned int i; |
| avltree_node_t *newnode; |
| avltree_create(tree); |
| TPRINTF("Inserting %" PRIs " nodes...", node_count); |
| for (i = 0; i < node_count; i++) { |
| newnode = alloc_avltree_node(); |
| avltree_insert(tree, newnode); |
| test_tree_parents(tree->root); |
| test_tree_balance(tree->root); |
| } |
| TPRINTF("done.\n"); |
| } |
| static void test_tree_delete(avltree_t *tree, size_t node_count, |
| int node_position) |
| { |
| avltree_node_t *delnode; |
| unsigned int i; |
| switch (node_position) { |
| case 0: |
| TPRINTF("Deleting root nodes..."); |
| while (tree->root != NULL) { |
| delnode = tree->root; |
| avltree_delete(tree, delnode); |
| test_tree_parents(tree->root); |
| test_tree_balance(tree->root); |
| } |
| break; |
| case 1: |
| TPRINTF("Deleting nodes according to creation time..."); |
| for (i = 0; i < node_count; i++) { |
| avltree_delete(tree, &avltree_nodes[i]); |
| test_tree_parents(tree->root); |
| test_tree_balance(tree->root); |
| } |
| break; |
| } |
| TPRINTF("done.\n"); |
| } |
| static void test_tree_delmin(avltree_t *tree, size_t node_count) |
| { |
| unsigned int i = 0; |
| TPRINTF("Deleting minimum nodes..."); |
| while (tree->root != NULL) { |
| i++; |
| avltree_delete_min(tree); |
| test_tree_parents(tree->root); |
| test_tree_balance(tree->root); |
| } |
| if (i != node_count) |
| TPRINTF("Bad node count. Some nodes have been lost!\n"); |
| TPRINTF("done.\n"); |
| } |
| char *test_avltree1(void) |
| { |
| alloc_avltree_node_prepare(); |
| test_tree_insert(&avltree, NODE_COUNT); |
| test_tree_delete(&avltree, NODE_COUNT, 0); |
| alloc_avltree_node_prepare(); |
| test_tree_insert(&avltree, NODE_COUNT); |
| test_tree_delete(&avltree, NODE_COUNT, 1); |
| alloc_avltree_node_prepare(); |
| test_tree_insert(&avltree, NODE_COUNT); |
| test_tree_delmin(&avltree, NODE_COUNT); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/avltree/avltree1.def |
|---|
| 0,0 → 1,6 |
| { |
| "avltree1", |
| "Test AVL tree operations", |
| &test_avltree1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/rwlock4.c |
|---|
| 0,0 → 1,184 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <arch/types.h> |
| #include <arch/context.h> |
| #include <context.h> |
| #include <synch/waitq.h> |
| #include <synch/rwlock.h> |
| #include <synch/synch.h> |
| #include <synch/spinlock.h> |
| #define READERS 50 |
| #define WRITERS 50 |
| static atomic_t thread_count; |
| static rwlock_t rwlock; |
| static atomic_t threads_fault; |
| SPINLOCK_INITIALIZE(rw_lock); |
| static waitq_t can_start; |
| static uint32_t seed = 0xdeadbeef; |
| static uint32_t random(uint32_t max) |
| { |
| uint32_t rc; |
| spinlock_lock(&rw_lock); |
| rc = seed % max; |
| seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc; |
| spinlock_unlock(&rw_lock); |
| return rc; |
| } |
| static void writer(void *arg) |
| { |
| int rc, to; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| to = random(40000); |
| TPRINTF("cpu%u, tid %" PRIu64 " w+ (%d)\n", CPU->id, THREAD->tid, to); |
| rc = rwlock_write_lock_timeout(&rwlock, to); |
| if (SYNCH_FAILED(rc)) { |
| TPRINTF("cpu%u, tid %" PRIu64 " w!\n", CPU->id, THREAD->tid); |
| atomic_dec(&thread_count); |
| return; |
| } |
| TPRINTF("cpu%u, tid %" PRIu64 " w=\n", CPU->id, THREAD->tid); |
| if (rwlock.readers_in) { |
| TPRINTF("Oops.\n"); |
| atomic_inc(&threads_fault); |
| atomic_dec(&thread_count); |
| return; |
| } |
| thread_usleep(random(1000000)); |
| if (rwlock.readers_in) { |
| TPRINTF("Oops.\n"); |
| atomic_inc(&threads_fault); |
| atomic_dec(&thread_count); |
| return; |
| } |
| rwlock_write_unlock(&rwlock); |
| TPRINTF("cpu%u, tid %" PRIu64 " w-\n", CPU->id, THREAD->tid); |
| atomic_dec(&thread_count); |
| } |
| static void reader(void *arg) |
| { |
| int rc, to; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| to = random(2000); |
| TPRINTF("cpu%u, tid %" PRIu64 " r+ (%d)\n", CPU->id, THREAD->tid, to); |
| rc = rwlock_read_lock_timeout(&rwlock, to); |
| if (SYNCH_FAILED(rc)) { |
| TPRINTF("cpu%u, tid %" PRIu64 " r!\n", CPU->id, THREAD->tid); |
| atomic_dec(&thread_count); |
| return; |
| } |
| TPRINTF("cpu%u, tid %" PRIu64 " r=\n", CPU->id, THREAD->tid); |
| thread_usleep(30000); |
| rwlock_read_unlock(&rwlock); |
| TPRINTF("cpu%u, tid %" PRIu64 " r-\n", CPU->id, THREAD->tid); |
| atomic_dec(&thread_count); |
| } |
| char *test_rwlock4(void) |
| { |
| context_t ctx; |
| uint32_t i; |
| waitq_initialize(&can_start); |
| rwlock_initialize(&rwlock); |
| atomic_set(&threads_fault, 0); |
| uint32_t rd = random(7) + 1; |
| uint32_t wr = random(5) + 1; |
| atomic_set(&thread_count, rd + wr); |
| thread_t *thrd; |
| context_save(&ctx); |
| TPRINTF("sp=%#x, readers_in=%" PRIs "\n", ctx.sp, rwlock.readers_in); |
| TPRINTF("Creating %" PRIu32 " readers\n", rd); |
| for (i = 0; i < rd; i++) { |
| thrd = thread_create(reader, NULL, TASK, 0, "reader", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Could not create reader %" PRIu32 "\n", i); |
| } |
| TPRINTF("Creating %" PRIu32 " writers\n", wr); |
| for (i = 0; i < wr; i++) { |
| thrd = thread_create(writer, NULL, TASK, 0, "writer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Could not create writer %" PRIu32 "\n", i); |
| } |
| thread_usleep(20000); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&thread_count) > 0) { |
| TPRINTF("Threads left: %ld\n", atomic_get(&thread_count)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&threads_fault) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/synch/rwlock1.c |
|---|
| 0,0 → 1,75 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <synch/waitq.h> |
| #include <synch/rwlock.h> |
| #define READERS 50 |
| #define WRITERS 50 |
| static rwlock_t rwlock; |
| char *test_rwlock1(void) |
| { |
| rwlock_initialize(&rwlock); |
| rwlock_write_lock(&rwlock); |
| rwlock_write_unlock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_write_lock(&rwlock); |
| rwlock_write_unlock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_write_lock(&rwlock); |
| rwlock_write_unlock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/rwlock2.c |
|---|
| 0,0 → 1,83 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <synch/rwlock.h> |
| #define READERS 50 |
| #define WRITERS 50 |
| static rwlock_t rwlock; |
| static void writer(void *arg) |
| { |
| TPRINTF("Trying to lock rwlock for writing....\n"); |
| rwlock_write_lock(&rwlock); |
| rwlock_write_unlock(&rwlock); |
| TPRINTF("Trying to lock rwlock for reading....\n"); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| } |
| char *test_rwlock2(void) |
| { |
| thread_t *thrd; |
| rwlock_initialize(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_lock(&rwlock); |
| thrd = thread_create(writer, NULL, TASK, 0, "writer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| return "Could not create thread"; |
| thread_sleep(1); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| thread_join(thrd); |
| thread_detach(thrd); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/rwlock3.c |
|---|
| 0,0 → 1,89 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <synch/rwlock.h> |
| #define THREADS 4 |
| static atomic_t thread_count; |
| static rwlock_t rwlock; |
| static void reader(void *arg) |
| { |
| thread_detach(THREAD); |
| TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for reading....\n", CPU->id, THREAD->tid); |
| rwlock_read_lock(&rwlock); |
| rwlock_read_unlock(&rwlock); |
| TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid); |
| TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for writing....\n", CPU->id, THREAD->tid); |
| rwlock_write_lock(&rwlock); |
| rwlock_write_unlock(&rwlock); |
| TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid); |
| atomic_dec(&thread_count); |
| } |
| char *test_rwlock3(void) |
| { |
| int i; |
| thread_t *thrd; |
| atomic_set(&thread_count, THREADS); |
| rwlock_initialize(&rwlock); |
| rwlock_write_lock(&rwlock); |
| for (i = 0; i < THREADS; i++) { |
| thrd = thread_create(reader, NULL, TASK, 0, "reader", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Could not create reader %d\n", i); |
| } |
| thread_sleep(1); |
| rwlock_write_unlock(&rwlock); |
| while (atomic_get(&thread_count) > 0) { |
| TPRINTF("Threads left: %ld\n", atomic_get(&thread_count)); |
| thread_sleep(1); |
| } |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/semaphore1.c |
|---|
| 0,0 → 1,120 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <synch/waitq.h> |
| #include <synch/semaphore.h> |
| #define AT_ONCE 3 |
| #define PRODUCERS 50 |
| #define CONSUMERS 50 |
| static semaphore_t sem; |
| static waitq_t can_start; |
| static atomic_t items_produced; |
| static atomic_t items_consumed; |
| static void producer(void *arg) |
| { |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| semaphore_down(&sem); |
| atomic_inc(&items_produced); |
| thread_usleep(250); |
| semaphore_up(&sem); |
| } |
| static void consumer(void *arg) |
| { |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| semaphore_down(&sem); |
| atomic_inc(&items_consumed); |
| thread_usleep(500); |
| semaphore_up(&sem); |
| } |
| char *test_semaphore1(void) |
| { |
| int i, j, k; |
| int consumers, producers; |
| waitq_initialize(&can_start); |
| semaphore_initialize(&sem, AT_ONCE); |
| for (i = 1; i <= 3; i++) { |
| thread_t *thrd; |
| atomic_set(&items_produced, 0); |
| atomic_set(&items_consumed, 0); |
| consumers = i * CONSUMERS; |
| producers = (4 - i) * PRODUCERS; |
| TPRINTF("Creating %d consumers and %d producers...", consumers, producers); |
| for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) { |
| for (k = 0; k < i; k++) { |
| thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("could not create consumer %d\n", i); |
| } |
| for (k = 0; k < (4 - i); k++) { |
| thrd = thread_create(producer, NULL, TASK, 0, "producer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("could not create producer %d\n", i); |
| } |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while ((items_consumed.count != consumers) || (items_produced.count != producers)) { |
| TPRINTF("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count); |
| thread_sleep(1); |
| } |
| } |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/semaphore2.c |
|---|
| 0,0 → 1,107 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <arch/types.h> |
| #include <arch/context.h> |
| #include <synch/waitq.h> |
| #include <synch/semaphore.h> |
| #include <synch/synch.h> |
| #include <synch/spinlock.h> |
| static semaphore_t sem; |
| SPINLOCK_INITIALIZE(sem_lock); |
| static waitq_t can_start; |
| static uint32_t seed = 0xdeadbeef; |
| static uint32_t random(uint32_t max) |
| { |
| uint32_t rc; |
| spinlock_lock(&sem_lock); |
| rc = seed % max; |
| seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc; |
| spinlock_unlock(&sem_lock); |
| return rc; |
| } |
| static void consumer(void *arg) |
| { |
| int rc, to; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| to = random(20000); |
| TPRINTF("cpu%u, tid %" PRIu64 " down+ (%d)\n", CPU->id, THREAD->tid, to); |
| rc = semaphore_down_timeout(&sem, to); |
| if (SYNCH_FAILED(rc)) { |
| TPRINTF("cpu%u, tid %" PRIu64 " down!\n", CPU->id, THREAD->tid); |
| return; |
| } |
| TPRINTF("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid); |
| thread_usleep(random(30000)); |
| semaphore_up(&sem); |
| TPRINTF("cpu%u, tid %" PRIu64 " up\n", CPU->id, THREAD->tid); |
| } |
| char *test_semaphore2(void) |
| { |
| uint32_t i, k; |
| waitq_initialize(&can_start); |
| semaphore_initialize(&sem, 5); |
| thread_t *thrd; |
| k = random(7) + 1; |
| TPRINTF("Creating %" PRIu32 " consumers\n", k); |
| for (i = 0; i < k; i++) { |
| thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Error creating thread\n"); |
| } |
| thread_usleep(20000); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/rwlock5.c |
|---|
| 0,0 → 1,117 |
| /* |
| * Copyright (c) 2001-2004 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 <test.h> |
| #include <arch.h> |
| #include <atomic.h> |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <synch/waitq.h> |
| #include <synch/rwlock.h> |
| #define READERS 50 |
| #define WRITERS 50 |
| static rwlock_t rwlock; |
| static waitq_t can_start; |
| static atomic_t items_read; |
| static atomic_t items_written; |
| static void writer(void *arg) |
| { |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| rwlock_write_lock(&rwlock); |
| atomic_inc(&items_written); |
| rwlock_write_unlock(&rwlock); |
| } |
| static void reader(void *arg) |
| { |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| rwlock_read_lock(&rwlock); |
| atomic_inc(&items_read); |
| rwlock_read_unlock(&rwlock); |
| } |
| char *test_rwlock5(void) |
| { |
| int i, j, k; |
| long readers, writers; |
| waitq_initialize(&can_start); |
| rwlock_initialize(&rwlock); |
| for (i = 1; i <= 3; i++) { |
| thread_t *thrd; |
| atomic_set(&items_read, 0); |
| atomic_set(&items_written, 0); |
| readers = i * READERS; |
| writers = (4 - i) * WRITERS; |
| TPRINTF("Creating %ld readers and %ld writers...", readers, writers); |
| for (j = 0; j < (READERS + WRITERS) / 2; j++) { |
| for (k = 0; k < i; k++) { |
| thrd = thread_create(reader, NULL, TASK, 0, "reader", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Could not create reader %d\n", k); |
| } |
| for (k = 0; k < (4 - i); k++) { |
| thrd = thread_create(writer, NULL, TASK, 0, "writer", false); |
| if (thrd) |
| thread_ready(thrd); |
| else |
| TPRINTF("Could not create writer %d\n", k); |
| } |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while ((items_read.count != readers) || (items_written.count != writers)) { |
| TPRINTF("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in); |
| thread_usleep(100000); |
| } |
| } |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/synch/rwlock1.def |
|---|
| 0,0 → 1,6 |
| { |
| "rwlock1", |
| "RW-lock test 1", |
| &test_rwlock1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/rwlock2.def |
|---|
| 0,0 → 1,6 |
| { |
| "rwlock2", |
| "RW-lock test 2", |
| &test_rwlock2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/rwlock3.def |
|---|
| 0,0 → 1,6 |
| { |
| "rwlock3", |
| "RW-lock test 3", |
| &test_rwlock3, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/semaphore1.def |
|---|
| 0,0 → 1,6 |
| { |
| "semaphore1", |
| "Semaphore test 1", |
| &test_semaphore1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/rwlock4.def |
|---|
| 0,0 → 1,6 |
| { |
| "rwlock4", |
| "RW-lock test 4", |
| &test_rwlock4, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/semaphore2.def |
|---|
| 0,0 → 1,6 |
| { |
| "semaphore2", |
| "Semaphore test 2", |
| &test_semaphore2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/synch/rwlock5.def |
|---|
| 0,0 → 1,6 |
| { |
| "rwlock5", |
| "RW-lock test 5", |
| &test_rwlock5, |
| true |
| }, |
| /tags/0.4.1/kernel/test/mm/falloc2.c |
|---|
| 0,0 → 1,131 |
| /* |
| * 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> |
| #define MAX_FRAMES 256 |
| #define MAX_ORDER 8 |
| #define THREAD_RUNS 1 |
| #define THREADS 8 |
| static atomic_t thread_count; |
| static atomic_t thread_fail; |
| static void falloc(void *arg) |
| { |
| int order, run, allocated, i; |
| uint8_t val = THREAD->tid % THREADS; |
| size_t k; |
| void **frames = (void **) malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC); |
| if (frames == NULL) { |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id); |
| atomic_inc(&thread_fail); |
| atomic_dec(&thread_count); |
| return; |
| } |
| thread_detach(THREAD); |
| for (run = 0; run < THREAD_RUNS; run++) { |
| for (order = 0; order <= MAX_ORDER; order++) { |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order); |
| allocated = 0; |
| for (i = 0; i < (MAX_FRAMES >> order); i++) { |
| frames[allocated] = frame_alloc(order, FRAME_ATOMIC | FRAME_KA); |
| if (frames[allocated]) { |
| memsetb(frames[allocated], FRAME_SIZE << order, val); |
| allocated++; |
| } else |
| break; |
| } |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated); |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Deallocating ... \n", THREAD->tid, CPU->id); |
| for (i = 0; i < allocated; i++) { |
| for (k = 0; k <= (((size_t) FRAME_SIZE << order) - 1); k++) { |
| if (((uint8_t *) frames[i])[k] != val) { |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Unexpected data (%c) in block %p offset %#" PRIs "\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k); |
| atomic_inc(&thread_fail); |
| goto cleanup; |
| } |
| } |
| frame_free(KA2PA(frames[i])); |
| } |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Finished run.\n", THREAD->tid, CPU->id); |
| } |
| } |
| cleanup: |
| free(frames); |
| TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n", THREAD->tid, CPU->id); |
| atomic_dec(&thread_count); |
| } |
| char *test_falloc2(void) |
| { |
| unsigned int i; |
| atomic_set(&thread_count, THREADS); |
| atomic_set(&thread_fail, 0); |
| for (i = 0; i < THREADS; i++) { |
| thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false); |
| if (!thrd) { |
| TPRINTF("Could not create thread %u\n", i); |
| break; |
| } |
| thread_ready(thrd); |
| } |
| while (atomic_get(&thread_count) > 0) { |
| TPRINTF("Threads left: %ld\n", atomic_get(&thread_count)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&thread_fail) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/mm/purge1.c |
|---|
| 0,0 → 1,83 |
| /* |
| * 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> |
| extern void tlb_invalidate_all(void); |
| extern void tlb_invalidate_pages(asid_t asid, uintptr_t va, size_t cnt); |
| char *test_purge1(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(); */ |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/slab2.c |
|---|
| 0,0 → 1,243 |
| /* |
| * 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 <mm/frame.h> |
| #include <memstr.h> |
| #include <synch/condvar.h> |
| #include <synch/mutex.h> |
| #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); |
| TPRINTF("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(data1, ITEM_SIZE, 0); |
| memsetb(data2, ITEM_SIZE, 0); |
| *((void **) data1) = olddata1; |
| *((void **) data2) = olddata2; |
| olddata1 = data1; |
| olddata2 = data2; |
| } while (true); |
| TPRINTF("done.\n"); |
| TPRINTF("Deallocating cache2..."); |
| /* We do not have memory - now deallocate cache2 */ |
| while (olddata2) { |
| data2 = *((void **) olddata2); |
| slab_free(cache2, olddata2); |
| olddata2 = data2; |
| } |
| TPRINTF("done.\n"); |
| TPRINTF("Allocating to cache1...\n"); |
| for (i = 0; i < 30; i++) { |
| data1 = slab_alloc(cache1, FRAME_ATOMIC); |
| if (!data1) { |
| TPRINTF("Incorrect memory size - use another test."); |
| return; |
| } |
| memsetb(data1, ITEM_SIZE, 0); |
| *((void **) data1) = olddata1; |
| olddata1 = data1; |
| } |
| while (true) { |
| data1 = slab_alloc(cache1, FRAME_ATOMIC); |
| if (!data1) |
| break; |
| memsetb(data1, ITEM_SIZE, 0); |
| *((void **) data1) = olddata1; |
| olddata1 = data1; |
| } |
| TPRINTF("Deallocating cache1..."); |
| while (olddata1) { |
| data1 = *((void **) olddata1); |
| slab_free(cache1, olddata1); |
| olddata1 = data1; |
| } |
| TPRINTF("done.\n"); |
| if (!test_quiet) |
| slab_print_list(); |
| slab_cache_destroy(cache1); |
| slab_cache_destroy(cache2); |
| } |
| static slab_cache_t *thr_cache; |
| static semaphore_t thr_sem; |
| static condvar_t thread_starter; |
| static 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); |
| TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid); |
| /* Alloc all */ |
| TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| while (true) { |
| /* Call with atomic to detect end of memory */ |
| new = slab_alloc(thr_cache, FRAME_ATOMIC); |
| if (!new) |
| break; |
| *((void **) new) = data; |
| data = new; |
| } |
| TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| while (data) { |
| new = *((void **)data); |
| *((void **) data) = NULL; |
| slab_free(thr_cache, data); |
| data = new; |
| } |
| TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid); |
| while (true) { |
| /* Call with atomic to detect end of memory */ |
| new = slab_alloc(thr_cache, FRAME_ATOMIC); |
| if (!new) |
| break; |
| *((void **) new) = data; |
| data = new; |
| } |
| TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid); |
| while (data) { |
| new = *((void **)data); |
| *((void **) data) = NULL; |
| slab_free(thr_cache, data); |
| data = new; |
| } |
| TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid); |
| if (!test_quiet) |
| 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; |
| TPRINTF("Running stress test with size %d\n", size); |
| condvar_initialize(&thread_starter); |
| mutex_initialize(&starter_mutex, MUTEX_PASSIVE); |
| 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))) { |
| TPRINTF("Could not create thread %d\n", i); |
| } else |
| 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); |
| TPRINTF("Stress test complete.\n"); |
| } |
| char *test_slab2(void) |
| { |
| TPRINTF("Running reclaim single-thread test .. pass 1\n"); |
| totalmemtest(); |
| TPRINTF("Running reclaim single-thread test .. pass 2\n"); |
| totalmemtest(); |
| TPRINTF("Reclaim test OK.\n"); |
| multitest(128); |
| multitest(2048); |
| multitest(8192); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/falloc1.c |
|---|
| 0,0 → 1,98 |
| /* |
| * 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> |
| #define MAX_FRAMES 1024 |
| #define MAX_ORDER 8 |
| #define TEST_RUNS 2 |
| char *test_falloc1(void) { |
| uintptr_t *frames |
| = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0); |
| int results[MAX_ORDER + 1]; |
| int i, order, run; |
| int allocated; |
| if (TEST_RUNS < 2) |
| return "Test is compiled with TEST_RUNS < 2"; |
| if (frames == NULL) |
| return "Unable to allocate frames"; |
| for (run = 0; run < TEST_RUNS; run++) { |
| for (order = 0; order <= MAX_ORDER; order++) { |
| TPRINTF("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]) { |
| TPRINTF("Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10); |
| return "Test failed"; |
| } |
| if (frames[allocated]) |
| allocated++; |
| else { |
| TPRINTF("done. "); |
| break; |
| } |
| } |
| TPRINTF("%d blocks allocated.\n", allocated); |
| if (run) { |
| if (results[order] != allocated) |
| return "Possible frame leak"; |
| } else |
| results[order] = allocated; |
| TPRINTF("Deallocating ... "); |
| for (i = 0; i < allocated; i++) |
| frame_free(KA2PA(frames[i])); |
| TPRINTF("done.\n"); |
| } |
| } |
| free(frames); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/slab1.c |
|---|
| 0,0 → 1,178 |
| /* |
| * 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 <memstr.h> |
| #define VAL_COUNT 1024 |
| static void *data[VAL_COUNT]; |
| static void testit(int size, int count) |
| { |
| slab_cache_t *cache; |
| int i; |
| TPRINTF("Creating cache, object size: %d.\n", size); |
| cache = slab_cache_create("test_cache", size, 0, NULL, NULL, |
| SLAB_CACHE_NOMAGAZINE); |
| TPRINTF("Allocating %d items...", count); |
| for (i = 0; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb(data[i], size, 0); |
| } |
| TPRINTF("done.\n"); |
| TPRINTF("Freeing %d items...", count); |
| for (i = 0; i < count; i++) |
| slab_free(cache, data[i]); |
| TPRINTF("done.\n"); |
| TPRINTF("Allocating %d items...", count); |
| for (i = 0; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb(data[i], size, 0); |
| } |
| TPRINTF("done.\n"); |
| TPRINTF("Freeing %d items...", count / 2); |
| for (i = count - 1; i >= count / 2; i--) |
| slab_free(cache, data[i]); |
| TPRINTF("done.\n"); |
| TPRINTF("Allocating %d items...", count / 2); |
| for (i = count / 2; i < count; i++) { |
| data[i] = slab_alloc(cache, 0); |
| memsetb(data[i], size, 0); |
| } |
| TPRINTF("done.\n"); |
| TPRINTF("Freeing %d items...", count); |
| for (i = 0; i < count; i++) |
| slab_free(cache, data[i]); |
| TPRINTF("done.\n"); |
| slab_cache_destroy(cache); |
| TPRINTF("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 |
| static void *thr_data[THREADS][THR_MEM_COUNT]; |
| static slab_cache_t *thr_cache; |
| static semaphore_t thr_sem; |
| static void slabtest(void *data) |
| { |
| int offs = (int) (unative_t) data; |
| int i, j; |
| thread_detach(THREAD); |
| TPRINTF("Starting thread #%" PRIu64 "...\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]); |
| } |
| TPRINTF("Thread #%" PRIu64 " 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", false))) { |
| TPRINTF("Could not create thread %d\n", i); |
| } else |
| thread_ready(t); |
| } |
| for (i = 0; i < THREADS; i++) |
| semaphore_down(&thr_sem); |
| slab_cache_destroy(thr_cache); |
| TPRINTF("Test complete.\n"); |
| } |
| char *test_slab1(void) |
| { |
| testsimple(); |
| testthreads(); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/purge1_skip.c |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_purge1(void) |
| { |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/mapping1.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/types.h> |
| #include <debug.h> |
| #define PAGE0 0x10000000 |
| #define PAGE1 (PAGE0 + PAGE_SIZE) |
| #define VALUE0 0x01234567 |
| #define VALUE1 0x89abcdef |
| char *test_mapping1(void) |
| { |
| uintptr_t frame0, frame1; |
| uint32_t v0, v1; |
| frame0 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA); |
| frame1 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA); |
| TPRINTF("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0)); |
| *((uint32_t *) frame0) = VALUE0; |
| TPRINTF("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1)); |
| *((uint32_t *) frame1) = VALUE1; |
| TPRINTF("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0)); |
| page_mapping_insert(AS_KERNEL, PAGE0, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE); |
| TPRINTF("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1)); |
| page_mapping_insert(AS_KERNEL, PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE); |
| v0 = *((uint32_t *) PAGE0); |
| v1 = *((uint32_t *) PAGE1); |
| TPRINTF("Value at virtual address %p is %#x.\n", PAGE0, v0); |
| TPRINTF("Value at virtual address %p is %#x.\n", PAGE1, v1); |
| if (v0 != VALUE0) |
| return "Value at v0 not equal to VALUE0"; |
| if (v1 != VALUE1) |
| return "Value at v1 not equal to VALUE1"; |
| TPRINTF("Writing %#x to virtual address %p.\n", 0, PAGE0); |
| *((uint32_t *) PAGE0) = 0; |
| TPRINTF("Writing %#x to virtual address %p.\n", 0, PAGE1); |
| *((uint32_t *) PAGE1) = 0; |
| v0 = *((uint32_t *) PAGE0); |
| v1 = *((uint32_t *) PAGE1); |
| TPRINTF("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0)); |
| TPRINTF("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1)); |
| if (v0 != 0) |
| return "Value at v0 not equal to 0"; |
| if (v1 != 0) |
| return "Value at v1 not equal to 0"; |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/mm/purge1.def |
|---|
| 0,0 → 1,6 |
| { |
| "purge1", |
| "Itanium TLB purge test", |
| &test_purge1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/mm/falloc2.def |
|---|
| 0,0 → 1,6 |
| { |
| "falloc2", |
| "Frame allocator test 2", |
| &test_falloc2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/mm/slab1.def |
|---|
| 0,0 → 1,6 |
| { |
| "slab1", |
| "SLAB test 1", |
| &test_slab1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/mm/slab2.def |
|---|
| 0,0 → 1,6 |
| { |
| "slab2", |
| "SLAB test 2", |
| &test_slab2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/mm/mapping1.def |
|---|
| 0,0 → 1,6 |
| { |
| "mapping1", |
| "Mapping test", |
| &test_mapping1, |
| false |
| }, |
| /tags/0.4.1/kernel/test/mm/falloc1.def |
|---|
| 0,0 → 1,6 |
| { |
| "falloc1", |
| "Frame allocator test 1", |
| &test_falloc1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/test.c |
|---|
| 0,0 → 1,74 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * 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. |
| */ |
| /** @addtogroup test |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <test.h> |
| bool test_quiet; |
| test_t tests[] = { |
| #include <atomic/atomic1.def> |
| #include <avltree/avltree1.def> |
| #include <btree/btree1.def> |
| #include <debug/mips1.def> |
| #include <fault/fault1.def> |
| #include <fpu/fpu1.def> |
| #include <fpu/sse1.def> |
| #include <fpu/mips2.def> |
| #include <mm/falloc1.def> |
| #include <mm/falloc2.def> |
| #include <mm/mapping1.def> |
| #include <mm/slab1.def> |
| #include <mm/slab2.def> |
| #include <synch/rwlock1.def> |
| #include <synch/rwlock2.def> |
| #include <synch/rwlock3.def> |
| #include <synch/rwlock4.def> |
| #include <synch/rwlock5.def> |
| #include <synch/semaphore1.def> |
| #include <synch/semaphore2.def> |
| #include <print/print1.def> |
| #include <print/print2.def> |
| #include <print/print3.def> |
| #include <print/print4.def> |
| #include <thread/thread1.def> |
| #include <sysinfo/sysinfo1.def> |
| { |
| .name = NULL, |
| .desc = NULL, |
| .entry = NULL |
| } |
| }; |
| /** @} |
| */ |
| /tags/0.4.1/kernel/test/btree/btree1.c |
|---|
| 0,0 → 1,163 |
| /* |
| * Copyright (c) 2006 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 <test.h> |
| #include <print.h> |
| #include <adt/btree.h> |
| #include <debug.h> |
| static void *data = (void *) 0xdeadbeef; |
| char *test_btree1(void) |
| { |
| btree_t t; |
| int i; |
| btree_create(&t); |
| TPRINTF("Inserting keys.\n"); |
| btree_insert(&t, 19, data, NULL); |
| btree_insert(&t, 20, data, NULL); |
| btree_insert(&t, 21, data, NULL); |
| btree_insert(&t, 0, data, NULL); |
| btree_insert(&t, 25, data, NULL); |
| btree_insert(&t, 22, data, NULL); |
| btree_insert(&t, 26, data, NULL); |
| btree_insert(&t, 23, data, NULL); |
| btree_insert(&t, 24, data, NULL); |
| btree_insert(&t, 5, data, NULL); |
| btree_insert(&t, 1, data, NULL); |
| btree_insert(&t, 4, data, NULL); |
| btree_insert(&t, 28, data, NULL); |
| btree_insert(&t, 29, data, NULL); |
| btree_insert(&t, 7, data, NULL); |
| btree_insert(&t, 8, data, NULL); |
| btree_insert(&t, 9, data, NULL); |
| btree_insert(&t, 17, data, NULL); |
| btree_insert(&t, 18, data, NULL); |
| btree_insert(&t, 2, data, NULL); |
| btree_insert(&t, 3, data, NULL); |
| btree_insert(&t, 6, data, NULL); |
| btree_insert(&t, 10, data, NULL); |
| btree_insert(&t, 11, data, NULL); |
| btree_insert(&t, 12, data, NULL); |
| btree_insert(&t, 13, data, NULL); |
| btree_insert(&t, 14, data, NULL); |
| btree_insert(&t, 15, data, NULL); |
| btree_insert(&t, 16, data, NULL); |
| btree_insert(&t, 27, data, NULL); |
| for (i = 30; i < 50; i++) |
| btree_insert(&t, i, data, NULL); |
| for (i = 100; i >= 50; i--) |
| btree_insert(&t, i, data, NULL); |
| if (!test_quiet) |
| btree_print(&t); |
| TPRINTF("Removing keys.\n"); |
| btree_remove(&t, 50, NULL); |
| btree_remove(&t, 49, NULL); |
| btree_remove(&t, 51, NULL); |
| btree_remove(&t, 46, NULL); |
| btree_remove(&t, 45, NULL); |
| btree_remove(&t, 48, NULL); |
| btree_remove(&t, 53, NULL); |
| btree_remove(&t, 47, NULL); |
| btree_remove(&t, 52, NULL); |
| btree_remove(&t, 54, NULL); |
| btree_remove(&t, 65, NULL); |
| btree_remove(&t, 60, NULL); |
| btree_remove(&t, 99, NULL); |
| btree_remove(&t, 97, NULL); |
| btree_remove(&t, 57, NULL); |
| btree_remove(&t, 58, NULL); |
| btree_remove(&t, 61, NULL); |
| btree_remove(&t, 64, NULL); |
| btree_remove(&t, 56, NULL); |
| btree_remove(&t, 41, NULL); |
| for (i = 5; i < 20; i++) |
| btree_remove(&t, i, NULL); |
| btree_remove(&t, 2, NULL); |
| btree_remove(&t, 43, NULL); |
| btree_remove(&t, 22, NULL); |
| btree_remove(&t, 100, NULL); |
| btree_remove(&t, 98, NULL); |
| btree_remove(&t, 96, NULL); |
| btree_remove(&t, 66, NULL); |
| btree_remove(&t, 1, NULL); |
| for (i = 70; i < 90; i++) |
| btree_remove(&t, i, NULL); |
| btree_remove(&t, 20, NULL); |
| btree_remove(&t, 0, NULL); |
| btree_remove(&t, 40, NULL); |
| btree_remove(&t, 3, NULL); |
| btree_remove(&t, 4, NULL); |
| btree_remove(&t, 21, NULL); |
| btree_remove(&t, 44, NULL); |
| btree_remove(&t, 55, NULL); |
| btree_remove(&t, 62, NULL); |
| btree_remove(&t, 26, NULL); |
| btree_remove(&t, 27, NULL); |
| btree_remove(&t, 28, NULL); |
| btree_remove(&t, 29, NULL); |
| btree_remove(&t, 30, NULL); |
| btree_remove(&t, 31, NULL); |
| btree_remove(&t, 32, NULL); |
| btree_remove(&t, 33, NULL); |
| btree_remove(&t, 93, NULL); |
| btree_remove(&t, 95, NULL); |
| btree_remove(&t, 94, NULL); |
| btree_remove(&t, 69, NULL); |
| btree_remove(&t, 68, NULL); |
| btree_remove(&t, 92, NULL); |
| btree_remove(&t, 91, NULL); |
| btree_remove(&t, 67, NULL); |
| btree_remove(&t, 63, NULL); |
| btree_remove(&t, 90, NULL); |
| btree_remove(&t, 59, NULL); |
| btree_remove(&t, 23, NULL); |
| btree_remove(&t, 24, NULL); |
| btree_remove(&t, 25, NULL); |
| btree_remove(&t, 37, NULL); |
| btree_remove(&t, 38, NULL); |
| btree_remove(&t, 42, NULL); |
| btree_remove(&t, 39, NULL); |
| btree_remove(&t, 34, NULL); |
| btree_remove(&t, 35, NULL); |
| btree_remove(&t, 36, NULL); |
| if (!test_quiet) |
| btree_print(&t); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/btree/btree1.def |
|---|
| 0,0 → 1,6 |
| { |
| "btree1", |
| "Test B-tree operations", |
| &test_btree1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/test.h |
|---|
| 0,0 → 1,92 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * 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. |
| */ |
| /** @addtogroup test |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_TEST_H_ |
| #define KERN_TEST_H_ |
| #include <arch/types.h> |
| #include <typedefs.h> |
| extern bool test_quiet; |
| #define TPRINTF(format, ...) \ |
| { \ |
| if (!test_quiet) { \ |
| printf(format, ##__VA_ARGS__); \ |
| } \ |
| } |
| typedef char *(*test_entry_t)(void); |
| typedef struct { |
| char *name; |
| char *desc; |
| test_entry_t entry; |
| bool safe; |
| } test_t; |
| extern char *test_atomic1(void); |
| extern char *test_avltree1(void); |
| extern char *test_btree1(void); |
| extern char *test_mips1(void); |
| extern char *test_fault1(void); |
| extern char *test_fpu1(void); |
| extern char *test_sse1(void); |
| extern char *test_mips2(void); |
| extern char *test_falloc1(void); |
| extern char *test_falloc2(void); |
| extern char *test_mapping1(void); |
| extern char *test_purge1(void); |
| extern char *test_slab1(void); |
| extern char *test_slab2(void); |
| extern char *test_rwlock1(void); |
| extern char *test_rwlock2(void); |
| extern char *test_rwlock3(void); |
| extern char *test_rwlock4(void); |
| extern char *test_rwlock5(void); |
| extern char *test_semaphore1(void); |
| extern char *test_semaphore2(void); |
| extern char *test_print1(void); |
| extern char *test_print2(void); |
| extern char *test_print3(void); |
| extern char *test_print4(void); |
| extern char *test_thread1(void); |
| extern char *test_sysinfo1(void); |
| extern test_t tests[]; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/kernel/test/debug/mips1_skip.c |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_mips1(void) |
| { |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/debug/mips1.c |
|---|
| 0,0 → 1,48 |
| /* |
| * 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 <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <time/delay.h> |
| #include <arch.h> |
| char *test_mips1(void) |
| { |
| TPRINTF("If kconsole is compiled in, you should enter debug mode now.\n"); |
| asm volatile ( |
| "break\n" |
| ); |
| return "Back from debug mode"; |
| } |
| /tags/0.4.1/kernel/test/debug/mips1.def |
|---|
| 0,0 → 1,6 |
| { |
| "mips1", |
| "MIPS debug test", |
| &test_mips1, |
| false |
| }, |
| /tags/0.4.1/kernel/test/thread/thread1.c |
|---|
| 0,0 → 1,82 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * 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 <debug.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #define THREADS 5 |
| static atomic_t finish; |
| static atomic_t threads_finished; |
| static void threadtest(void *data) |
| { |
| thread_detach(THREAD); |
| while (atomic_get(&finish)) { |
| TPRINTF("%" PRIu64 " ", THREAD->tid); |
| thread_usleep(100000); |
| } |
| atomic_inc(&threads_finished); |
| } |
| char *test_thread1(void) |
| { |
| unsigned int i, total = 0; |
| atomic_set(&finish, 1); |
| atomic_set(&threads_finished, 0); |
| for (i = 0; i < THREADS; i++) { |
| thread_t *t; |
| if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) { |
| TPRINTF("Could not create thread %d\n", i); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| } |
| TPRINTF("Running threads for 10 seconds...\n"); |
| thread_sleep(10); |
| atomic_set(&finish, 0); |
| while (atomic_get(&threads_finished) < ((long) total)) { |
| TPRINTF("Threads left: %d\n", total - atomic_get(&threads_finished)); |
| thread_sleep(1); |
| } |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/thread/thread1.def |
|---|
| 0,0 → 1,6 |
| { |
| "thread1", |
| "Thread test", |
| &test_thread1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/fpu/fpu1_ia64.c |
|---|
| 0,0 → 1,170 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * 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 <debug.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #include <arch/arch.h> |
| #define THREADS 150 |
| #define ATTEMPTS 100 |
| #define E_10e8 271828182 |
| #define PI_10e8 3141592 |
| static inline long double sqrt(long double a) |
| { |
| long double x = 1; |
| long double lx = 0; |
| if (a < 0.00000000000000001) |
| return 0; |
| while (x != lx) { |
| lx = x; |
| x = (x + (a / x)) / 2; |
| } |
| return x; |
| } |
| static atomic_t threads_ok; |
| static atomic_t threads_fault; |
| static waitq_t can_start; |
| static void e(void *data) |
| { |
| int i; |
| double e, d, le, f; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| le = -1; |
| e = 0; |
| f = 1; |
| for (d = 1; e != le; d *= f, f += 1) { |
| le = e; |
| e = e + 1 / d; |
| } |
| if ((int) (100000000 * e) != E_10e8) { |
| TPRINTF("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| static void pi(void *data) |
| { |
| int i; |
| double lpi, pi; |
| double n, ab, ad; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i < ATTEMPTS; i++) { |
| lpi = -1; |
| pi = 0; |
| for (n = 2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) { |
| double sc, cd; |
| sc = sqrt(1 - (ab * ab / 4)); |
| cd = 1 - sc; |
| ad = sqrt(ab * ab / 4 + cd * cd); |
| lpi = pi; |
| pi = 2 * n * ad; |
| } |
| if ((int) (1000000 * pi) != PI_10e8) { |
| TPRINTF("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100)); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| char *test_fpu1(void) |
| { |
| unsigned int i, total = 0; |
| waitq_initialize(&can_start); |
| atomic_set(&threads_ok, 0); |
| atomic_set(&threads_fault, 0); |
| TPRINTF("Creating %u threads... ", 2 * THREADS); |
| for (i = 0; i < THREADS; i++) { |
| thread_t *t; |
| if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i + 1); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != (long) total) { |
| TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&threads_fault) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/fpu/fpu1_x86.c |
|---|
| 0,0 → 1,167 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * 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 <debug.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #include <arch/arch.h> |
| #define THREADS 150 |
| #define ATTEMPTS 100 |
| #define E_10e8 271828182 |
| #define PI_10e8 314159265 |
| static inline double sqrt(double x) |
| { |
| double v; |
| asm ( |
| "fsqrt\n" |
| : "=t" (v) |
| : "0" (x) |
| ); |
| return v; |
| } |
| static atomic_t threads_ok; |
| static atomic_t threads_fault; |
| static waitq_t can_start; |
| static void e(void *data) |
| { |
| int i; |
| double e, d, le, f; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i<ATTEMPTS; i++) { |
| le = -1; |
| e = 0; |
| f = 1; |
| for (d = 1; e != le; d *= f, f += 1) { |
| le = e; |
| e = e + 1 / d; |
| } |
| if ((int) (100000000 * e) != E_10e8) { |
| TPRINTF("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| static void pi(void *data) |
| { |
| int i; |
| double lpi, pi; |
| double n, ab, ad; |
| thread_detach(THREAD); |
| waitq_sleep(&can_start); |
| for (i = 0; i < ATTEMPTS; i++) { |
| lpi = -1; |
| pi = 0; |
| for (n = 2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) { |
| double sc, cd; |
| sc = sqrt(1 - (ab * ab / 4)); |
| cd = 1 - sc; |
| ad = sqrt(ab * ab / 4 + cd * cd); |
| lpi = pi; |
| pi = 2 * n * ad; |
| } |
| if ((int) (100000000 * pi) != PI_10e8) { |
| TPRINTF("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| char *test_fpu1(void) |
| { |
| unsigned int i, total = 0; |
| waitq_initialize(&can_start); |
| atomic_set(&threads_ok, 0); |
| atomic_set(&threads_fault, 0); |
| TPRINTF("Creating %u threads... ", 2 * THREADS); |
| for (i = 0; i < THREADS; i++) { |
| thread_t *t; |
| if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i + 1); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != (long) total) { |
| TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&threads_fault) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/fpu/mips2_skip.c |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_mips2(void) |
| { |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/fpu/fpu1_skip.c |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_fpu1(void) |
| { |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/fpu/sse1_skip.c |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_sse1(void) |
| { |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/fpu/mips2.c |
|---|
| 0,0 → 1,153 |
| /* |
| * 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 <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <time/delay.h> |
| #include <arch.h> |
| #define THREADS 50 |
| #define DELAY 10000L |
| #define ATTEMPTS 5 |
| static atomic_t threads_ok; |
| static atomic_t threads_fault; |
| 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) { |
| TPRINTF("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| 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) { |
| TPRINTF("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| char *test_mips2(void) |
| { |
| unsigned int i, total = 0; |
| waitq_initialize(&can_start); |
| atomic_set(&threads_ok, 0); |
| atomic_set(&threads_fault, 0); |
| TPRINTF("Creating %u threads... ", 2 * THREADS); |
| for (i = 0; i < THREADS; i++) { |
| thread_t *t; |
| if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i + 1); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != (long) total) { |
| TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&threads_fault) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/fpu/sse1.c |
|---|
| 0,0 → 1,151 |
| /* |
| * 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 <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <time/delay.h> |
| #include <arch.h> |
| #define THREADS 25 |
| #define DELAY 10000L |
| #define ATTEMPTS 5 |
| static atomic_t threads_ok; |
| static atomic_t threads_fault; |
| 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 %[arg], %%xmm2\n" |
| : [arg] "=m" (arg) |
| ); |
| delay(DELAY); |
| asm volatile ( |
| "movlpd %%xmm2, %[after_arg]\n" |
| : [after_arg] "=m" (after_arg) |
| ); |
| if (arg != after_arg) { |
| TPRINTF("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| 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 %[arg], %%xmm2\n" |
| : [arg] "=m" (arg) |
| ); |
| scheduler(); |
| asm volatile ( |
| "movlpd %%xmm2, %[after_arg]\n" |
| : [after_arg] "=m" (after_arg) |
| ); |
| if (arg != after_arg) { |
| TPRINTF("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg); |
| atomic_inc(&threads_fault); |
| break; |
| } |
| } |
| atomic_inc(&threads_ok); |
| } |
| char *test_sse1(void) |
| { |
| unsigned int i, total = 0; |
| waitq_initialize(&can_start); |
| atomic_set(&threads_ok, 0); |
| atomic_set(&threads_fault, 0); |
| TPRINTF("Creating %u threads... ", 2 * THREADS); |
| for (i = 0; i < THREADS; i++) { |
| thread_t *t; |
| if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) { |
| TPRINTF("could not create thread %u\n", 2 * i + 1); |
| break; |
| } |
| thread_ready(t); |
| total++; |
| } |
| TPRINTF("ok\n"); |
| thread_sleep(1); |
| waitq_wakeup(&can_start, WAKEUP_ALL); |
| while (atomic_get(&threads_ok) != (long) total) { |
| TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok)); |
| thread_sleep(1); |
| } |
| if (atomic_get(&threads_fault) == 0) |
| return NULL; |
| return "Test failed"; |
| } |
| /tags/0.4.1/kernel/test/fpu/mips2.def |
|---|
| 0,0 → 1,6 |
| { |
| "mips2", |
| "MIPS FPU test", |
| &test_mips2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/fpu/fpu1.def |
|---|
| 0,0 → 1,6 |
| { |
| "fpu1", |
| "Intel FPU test", |
| &test_fpu1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/fpu/sse1.def |
|---|
| 0,0 → 1,6 |
| { |
| "sse1", |
| "Intel SEE test", |
| &test_sse1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/sysinfo/sysinfo1.c |
|---|
| 0,0 → 1,40 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * 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 <test.h> |
| #include <sysinfo/sysinfo.h> |
| char *test_sysinfo1(void) |
| { |
| if (!test_quiet) |
| sysinfo_dump(NULL, 0); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/sysinfo/sysinfo1.def |
|---|
| 0,0 → 1,6 |
| { |
| "sysinfo1", |
| "Sysinfo test", |
| &test_sysinfo1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/fault/fault1.c |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * 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 <debug.h> |
| #include <test.h> |
| #include <atomic.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| char *test_fault1(void) |
| { |
| ((int *)(0))[1] = 0; |
| return "Written to NULL"; |
| } |
| /tags/0.4.1/kernel/test/fault/fault1.def |
|---|
| 0,0 → 1,6 |
| { |
| "fault1", |
| "Write to NULL (maybe page fault)", |
| &test_fault1, |
| false |
| }, |
| /tags/0.4.1/kernel/test/atomic/atomic1.c |
|---|
| 0,0 → 1,63 |
| /* |
| * Copyright (c) 2006 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 <test.h> |
| #include <print.h> |
| #include <atomic.h> |
| #include <debug.h> |
| char *test_atomic1(void) |
| { |
| atomic_t a; |
| atomic_set(&a, 10); |
| if (atomic_get(&a) != 10) |
| return "Failed atomic_set()/atomic_get()"; |
| if (atomic_postinc(&a) != 10) |
| return "Failed atomic_postinc()"; |
| if (atomic_get(&a) != 11) |
| return "Failed atomic_get() after atomic_postinc()"; |
| if (atomic_postdec(&a) != 11) |
| return "Failed atomic_postdec()"; |
| if (atomic_get(&a) != 10) |
| return "Failed atomic_get() after atomic_postdec()"; |
| if (atomic_preinc(&a) != 11) |
| return "Failed atomic_preinc()"; |
| if (atomic_get(&a) != 11) |
| return "Failed atomic_get() after atomic_preinc()"; |
| if (atomic_predec(&a) != 10) |
| return "Failed atomic_predec()"; |
| if (atomic_get(&a) != 10) |
| return "Failed atomic_get() after atomic_predec()"; |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/atomic/atomic1.def |
|---|
| 0,0 → 1,6 |
| { |
| "atomic1", |
| "Test atomic operations", |
| &test_atomic1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/print/print2.c |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * 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> |
| char *test_print2(void) |
| { |
| TPRINTF("Testing printf(\"%%c %%3.2c %%-3.2c %%2.3c %%-2.3c\", 'a', 'b', 'c', 'd', 'e'):\n"); |
| TPRINTF("Expected output: [a] [ b] [c ] [ d] [e ]\n"); |
| TPRINTF("Real output: [%c] [%3.2c] [%-3.2c] [%2.3c] [%-2.3c]\n\n", 'a', 'b', 'c', 'd', 'e'); |
| TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", 1, 2, 3, 4, 5):\n"); |
| TPRINTF("Expected output: [1] [ 02] [03 ] [004] [005]\n"); |
| TPRINTF("Real output: [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", 1, 2, 3, 4, 5); |
| TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", -1, -2, -3, -4, -5):\n"); |
| TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n"); |
| TPRINTF("Real output: [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5); |
| TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n"); |
| TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n"); |
| TPRINTF("Real output: [%#x] [%#5.3x] [%#-5.3x] [%#3.5x] [%#-3.5x]\n\n", 17, 18, 19, 20, 21); |
| unative_t nat = 0x12345678u; |
| TPRINTF("Testing printf(\"%%#" PRIx64 " %%#" PRIx32 " %%#" PRIx16 " %%#" PRIx8 " %%#" PRIxn " %%#" PRIx64 " %%s\", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, \"Lovely string\"):\n"); |
| TPRINTF("Expected output: [0x1234567887654321] [0x12345678] [0x1234] [0x12] [0x12345678] [0x1234567887654321] \"Lovely string\"\n"); |
| TPRINTF("Real output: [%#" PRIx64 "] [%#" PRIx32 "] [%#" PRIx16 "] [%#" PRIx8 "] [%#" PRIxn "] [%#" PRIx64 "] \"%s\"\n\n", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, "Lovely string"); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/print/print3.c |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * 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 <macros.h> |
| #include <test.h> |
| #define BUFFER_SIZE 32 |
| char *test_print3(void) |
| { |
| char buffer[BUFFER_SIZE]; |
| int retval; |
| TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short text without parameters.\"):\n"); |
| TPRINTF("Expected result: retval=30 buffer=\"Short text without parameters.\"\n"); |
| retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters."); |
| TPRINTF("Real result: retval=%d buffer=\"%s\"\n\n", retval, buffer); |
| TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very very very long text without parameters.\"):\n"); |
| TPRINTF("Expected result: retval=44 buffer=\"Very very very long text withou\"\n"); |
| retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters."); |
| TPRINTF("Real result: retval=%d buffer=\"%s\"\n\n", retval, buffer); |
| TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short %%s.\", \"text\"):\n"); |
| TPRINTF("Expected result: retval=11 buffer=\"Short text.\"\n"); |
| retval = snprintf(buffer, BUFFER_SIZE, "Short %s.", "text"); |
| TPRINTF("Real result: retval=%d buffer=\"%s\"\n\n", retval, buffer); |
| TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very long %%s. This text's length is more than %%d. We are interested in the result.\", \"text\", " STRING(BUFFER_SIZE) "):\n"); |
| TPRINTF("Expected result: retval=84 buffer=\"Very long text. This text's len\"\n"); |
| 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); |
| TPRINTF("Real result: retval=%d buffer=\"%s\"\n\n", retval, buffer); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/print/print4.c |
|---|
| 0,0 → 1,82 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * 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> |
| char *test_print4(void) |
| { |
| TPRINTF("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n"); |
| uint8_t group; |
| for (group = 1; group < 4; group++) { |
| TPRINTF("%#" PRIx8 ": ", group << 5); |
| uint8_t index; |
| for (index = 0; index < 32; index++) |
| TPRINTF("%c", (char) ((group << 5) + index)); |
| TPRINTF(" "); |
| for (index = 0; index < 32; index++) |
| TPRINTF("%lc", (wchar_t) ((group << 5) + index)); |
| TPRINTF("\n"); |
| } |
| TPRINTF("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n"); |
| for (group = 4; group < 8; group++) { |
| TPRINTF("%#" PRIx8 ": ", group << 5); |
| uint8_t index; |
| for (index = 0; index < 32; index++) |
| TPRINTF("%lc", (wchar_t) ((group << 5) + index)); |
| TPRINTF("\n"); |
| } |
| TPRINTF("\nUTF-8 strings using printf(\"%%s\"):\n"); |
| TPRINTF("English: %s\n", "Quick brown fox jumps over the lazy dog"); |
| TPRINTF("Czech: %s\n", "Příliš žluťoučký kůň úpěl ďábelské ódy"); |
| TPRINTF("Greek: %s\n", "á½® ξεῖν’, ἀγγÎλλειν Λακεδαιμονίοις ὅτι τῇδε"); |
| TPRINTF("Hebrew: %s\n", "משוואת ברנולי היא משוואה בהידרודינמיקה"); |
| TPRINTF("Arabic: %s\n", "التوزيع الجغرافي للحمل العنقودي"); |
| TPRINTF("Russian: %s\n", "Леннон познакомился с художницей-авангардисткой"); |
| TPRINTF("Armenian: %s\n", "ÕÕ¯Õ½Õ¥Ö Õ°Ö€Õ¡Õ¿Õ¡Ö€Õ¡Õ¯Õ¾Õ¥Õ¬ ÔµÖ€Õ¸Ö‚Õ½Õ¡Õ²Õ¥Õ´Õ« Õ°Õ¡ÕµÕ¯Õ¡Õ¯Õ¡Õ¶"); |
| TPRINTF("\nUTF-32 strings using printf(\"%%ls\"):\n"); |
| TPRINTF("English: %ls\n", L"Quick brown fox jumps over the lazy dog"); |
| TPRINTF("Czech: %ls\n", L"Příliš žluťoučký kůň úpěl ďábelské ódy"); |
| TPRINTF("Greek: %ls\n", L"á½® ξεῖν’, ἀγγÎλλειν Λακεδαιμονίοις ὅτι τῇδε"); |
| TPRINTF("Hebrew: %ls\n", L"משוואת ברנולי היא משוואה בהידרודינמיקה"); |
| TPRINTF("Arabic: %ls\n", L"التوزيع الجغرافي للحمل العنقودي"); |
| TPRINTF("Russian: %ls\n", L"Леннон познакомился с художницей-авангардисткой"); |
| TPRINTF("Armenian: %ls\n", L"ÕÕ¯Õ½Õ¥Ö Õ°Ö€Õ¡Õ¿Õ¡Ö€Õ¡Õ¯Õ¾Õ¥Õ¬ ÔµÖ€Õ¸Ö‚Õ½Õ¡Õ²Õ¥Õ´Õ« Õ°Õ¡ÕµÕ¯Õ¡Õ¯Õ¡Õ¶"); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/print/print1.c |
|---|
| 0,0 → 1,55 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * 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> |
| char *test_print1(void) |
| { |
| TPRINTF("Testing printf(\"%%*.*s\", 5, 3, \"text\"):\n"); |
| TPRINTF("Expected output: \" tex\"\n"); |
| TPRINTF("Real output: \"%*.*s\"\n\n", 5, 3, "text"); |
| TPRINTF("Testing printf(\"%%10.8s\", \"very long text\"):\n"); |
| TPRINTF("Expected output: \" very lon\"\n"); |
| TPRINTF("Real output: \"%10.8s\"\n\n", "very long text"); |
| TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n"); |
| TPRINTF("Expected output: \"text\"\n"); |
| TPRINTF("Real output: \"%8.10s\"\n\n", "text"); |
| TPRINTF("Testing printf(\"%%8.10s\", \"very long text\"):\n"); |
| TPRINTF("Expected output: \"very long \"\n"); |
| TPRINTF("Real output: \"%8.10s\"\n\n", "very long text"); |
| TPRINTF("Testing printf(\"%%s\", NULL):\n"); |
| TPRINTF("Expected output: \"(NULL)\"\n"); |
| TPRINTF("Real output: \"%s\"\n\n", NULL); |
| return NULL; |
| } |
| /tags/0.4.1/kernel/test/print/print1.def |
|---|
| 0,0 → 1,6 |
| { |
| "print1", |
| "String printf test", |
| &test_print1, |
| true |
| }, |
| /tags/0.4.1/kernel/test/print/print2.def |
|---|
| 0,0 → 1,6 |
| { |
| "print2", |
| "Numeric printf test", |
| &test_print2, |
| true |
| }, |
| /tags/0.4.1/kernel/test/print/print3.def |
|---|
| 0,0 → 1,6 |
| { |
| "print3", |
| "Buffered printf test", |
| &test_print3, |
| true |
| }, |
| /tags/0.4.1/kernel/test/print/print4.def |
|---|
| 0,0 → 1,6 |
| { |
| "print4", |
| "Unicode test", |
| &test_print4, |
| true |
| }, |