| // Copyright 2016 The Fuchsia Authors |
| // Copyright (c) 2008-2015 Travis Geiselbrecht |
| // |
| // Use of this source code is governed by a MIT-style |
| // license that can be found in the LICENSE file or at |
| // https://opensource.org/licenses/MIT |
| |
| #include "tests.h" |
| |
| #include <assert.h> |
| #include <debug.h> |
| #include <err.h> |
| #include <inttypes.h> |
| #include <kernel/event.h> |
| #include <kernel/mutex.h> |
| #include <kernel/thread.h> |
| #include <platform.h> |
| #include <rand.h> |
| #include <string.h> |
| #include <trace.h> |
| |
| static int sleep_thread(void* arg) { |
| for (;;) { |
| printf("sleeper %p\n", get_current_thread()); |
| thread_sleep_relative(LK_MSEC(rand() % 500)); |
| } |
| return 0; |
| } |
| |
| static int sleep_test(void) { |
| int i; |
| for (i = 0; i < 16; i++) |
| thread_detach_and_resume(thread_create("sleeper", &sleep_thread, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| return 0; |
| } |
| |
| static int mutex_thread(void* arg) { |
| int i; |
| const int iterations = 1000000; |
| int count = 0; |
| |
| static volatile uintptr_t shared = 0; |
| |
| mutex_t* m = (mutex_t*)arg; |
| |
| printf("mutex tester thread %p starting up, will go for %d iterations\n", get_current_thread(), iterations); |
| |
| for (i = 0; i < iterations; i++) { |
| mutex_acquire(m); |
| |
| if (shared != 0) |
| panic("someone else has messed with the shared data\n"); |
| |
| shared = (intptr_t)get_current_thread(); |
| if ((rand() % 5) == 0) |
| thread_yield(); |
| |
| if (++count % 10000 == 0) |
| printf("%p: count %d\n", get_current_thread(), count); |
| shared = 0; |
| |
| mutex_release(m); |
| if ((rand() % 5) == 0) |
| thread_yield(); |
| } |
| |
| printf("mutex tester %p done\n", get_current_thread()); |
| |
| return 0; |
| } |
| |
| static int mutex_test(void) { |
| static mutex_t imutex = MUTEX_INITIAL_VALUE(imutex); |
| printf("preinitialized mutex:\n"); |
| hexdump(&imutex, sizeof(imutex)); |
| |
| mutex_t m; |
| mutex_init(&m); |
| |
| thread_t* threads[5]; |
| |
| for (uint i = 0; i < countof(threads); i++) { |
| threads[i] = thread_create("mutex tester", &mutex_thread, &m, |
| get_current_thread()->base_priority, DEFAULT_STACK_SIZE); |
| thread_resume(threads[i]); |
| } |
| |
| for (uint i = 0; i < countof(threads); i++) { |
| thread_join(threads[i], NULL, INFINITE_TIME); |
| } |
| |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| printf("done with mutex tests\n"); |
| |
| return 0; |
| } |
| |
| static event_t e; |
| |
| static int event_signaler(void* arg) { |
| printf("event signaler pausing\n"); |
| thread_sleep_relative(LK_SEC(1)); |
| |
| // for (;;) { |
| printf("signaling event\n"); |
| event_signal(&e, true); |
| printf("done signaling event\n"); |
| thread_yield(); |
| // } |
| |
| return 0; |
| } |
| |
| static int event_waiter(void* arg) { |
| uintptr_t count = (uintptr_t)arg; |
| |
| while (count > 0) { |
| printf("thread %p: waiting on event...\n", get_current_thread()); |
| status_t err = event_wait_deadline(&e, INFINITE_TIME, true); |
| if (err == ZX_ERR_INTERNAL_INTR_KILLED) { |
| printf("thread %p: killed\n"); |
| return -1; |
| } else if (err < 0) { |
| printf("thread %p: event_wait() returned error %d\n", get_current_thread(), err); |
| return -1; |
| } |
| printf("thread %p: done waiting on event\n", get_current_thread()); |
| thread_yield(); |
| count--; |
| } |
| |
| return 0; |
| } |
| |
| static void event_test(void) { |
| thread_t* threads[5]; |
| |
| static event_t ievent = EVENT_INITIAL_VALUE(ievent, true, 0x1234); |
| printf("preinitialized event:\n"); |
| hexdump(&ievent, sizeof(ievent)); |
| |
| printf("event tests starting\n"); |
| |
| /* make sure signaling the event wakes up all the threads and stays signaled */ |
| printf("creating event, waiting on it with 4 threads, signaling it and making sure all threads fall through twice\n"); |
| event_init(&e, false, 0); |
| threads[0] = thread_create("event signaler", &event_signaler, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[1] = thread_create("event waiter 0", &event_waiter, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[2] = thread_create("event waiter 1", &event_waiter, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[3] = thread_create("event waiter 2", &event_waiter, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[4] = thread_create("event waiter 3", &event_waiter, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| |
| for (uint i = 0; i < countof(threads); i++) |
| thread_resume(threads[i]); |
| |
| for (uint i = 0; i < countof(threads); i++) |
| thread_join(threads[i], NULL, INFINITE_TIME); |
| |
| thread_sleep_relative(LK_SEC(2)); |
| printf("destroying event\n"); |
| event_destroy(&e); |
| |
| /* make sure signaling the event wakes up precisely one thread */ |
| printf("creating event, waiting on it with 4 threads, signaling it and making sure only one thread wakes up\n"); |
| event_init(&e, false, EVENT_FLAG_AUTOUNSIGNAL); |
| threads[0] = thread_create("event signaler", &event_signaler, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[1] = thread_create("event waiter 0", &event_waiter, (void*)99, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[2] = thread_create("event waiter 1", &event_waiter, (void*)99, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[3] = thread_create("event waiter 2", &event_waiter, (void*)99, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[4] = thread_create("event waiter 3", &event_waiter, (void*)99, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| |
| for (uint i = 0; i < countof(threads); i++) |
| thread_resume(threads[i]); |
| |
| thread_sleep_relative(LK_SEC(2)); |
| |
| for (uint i = 0; i < countof(threads); i++) { |
| thread_kill(threads[i], true); |
| thread_join(threads[i], NULL, INFINITE_TIME); |
| } |
| |
| event_destroy(&e); |
| |
| printf("event tests done\n"); |
| } |
| |
| static int quantum_tester(void* arg) { |
| for (;;) { |
| printf("%p: in this thread. rq %" PRIu64 "\n", get_current_thread(), get_current_thread()->remaining_time_slice); |
| } |
| return 0; |
| } |
| |
| static void quantum_test(void) { |
| thread_detach_and_resume(thread_create("quantum tester 0", &quantum_tester, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("quantum tester 1", &quantum_tester, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("quantum tester 2", &quantum_tester, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("quantum tester 3", &quantum_tester, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| } |
| |
| static event_t context_switch_event; |
| static event_t context_switch_done_event; |
| |
| static int context_switch_tester(void* arg) { |
| int i; |
| uint64_t total_count = 0; |
| const int iter = 100000; |
| uintptr_t thread_count = (uintptr_t)arg; |
| |
| event_wait(&context_switch_event); |
| |
| uint64_t count = arch_cycle_count(); |
| for (i = 0; i < iter; i++) { |
| thread_yield(); |
| } |
| total_count += arch_cycle_count() - count; |
| thread_sleep_relative(LK_SEC(1)); |
| printf("took %" PRIu64 " cycles to yield %d times, %" PRIu64 " per yield, %" PRIu64 " per yield per thread\n", |
| total_count, iter, total_count / iter, total_count / iter / thread_count); |
| |
| event_signal(&context_switch_done_event, true); |
| |
| return 0; |
| } |
| |
| static void context_switch_test(void) { |
| event_init(&context_switch_event, false, 0); |
| event_init(&context_switch_done_event, false, 0); |
| |
| thread_detach_and_resume(thread_create("context switch idle", &context_switch_tester, (void*)1, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_sleep_relative(LK_MSEC(100)); |
| event_signal(&context_switch_event, true); |
| event_wait(&context_switch_done_event); |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| event_unsignal(&context_switch_event); |
| event_unsignal(&context_switch_done_event); |
| thread_detach_and_resume(thread_create("context switch 2a", &context_switch_tester, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("context switch 2b", &context_switch_tester, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_sleep_relative(LK_MSEC(100)); |
| event_signal(&context_switch_event, true); |
| event_wait(&context_switch_done_event); |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| event_unsignal(&context_switch_event); |
| event_unsignal(&context_switch_done_event); |
| thread_detach_and_resume(thread_create("context switch 4a", &context_switch_tester, (void*)4, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("context switch 4b", &context_switch_tester, (void*)4, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("context switch 4c", &context_switch_tester, (void*)4, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_detach_and_resume(thread_create("context switch 4d", &context_switch_tester, (void*)4, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); |
| thread_sleep_relative(LK_MSEC(100)); |
| event_signal(&context_switch_event, true); |
| event_wait(&context_switch_done_event); |
| thread_sleep_relative(LK_MSEC(100)); |
| } |
| |
| static volatile int atomic; |
| static volatile int atomic_count; |
| |
| static int atomic_tester(void* arg) { |
| int add = (int)(uintptr_t)arg; |
| int i; |
| |
| const int iter = 10000000; |
| |
| TRACEF("add %d, %d iterations\n", add, iter); |
| |
| for (i = 0; i < iter; i++) { |
| atomic_add(&atomic, add); |
| } |
| |
| int old = atomic_add(&atomic_count, -1); |
| TRACEF("exiting, old count %d\n", old); |
| |
| return 0; |
| } |
| |
| static void atomic_test(void) { |
| atomic = 0; |
| atomic_count = 8; |
| |
| printf("testing atomic routines\n"); |
| |
| thread_t* threads[8]; |
| threads[0] = thread_create("atomic tester 1", &atomic_tester, (void*)1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[1] = thread_create("atomic tester 1", &atomic_tester, (void*)1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[2] = thread_create("atomic tester 1", &atomic_tester, (void*)1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[3] = thread_create("atomic tester 1", &atomic_tester, (void*)1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[4] = thread_create("atomic tester 2", &atomic_tester, (void*)-1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[5] = thread_create("atomic tester 2", &atomic_tester, (void*)-1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[6] = thread_create("atomic tester 2", &atomic_tester, (void*)-1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| threads[7] = thread_create("atomic tester 2", &atomic_tester, (void*)-1, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| |
| /* start all the threads */ |
| for (uint i = 0; i < countof(threads); i++) |
| thread_resume(threads[i]); |
| |
| /* wait for them to all stop */ |
| for (uint i = 0; i < countof(threads); i++) { |
| thread_join(threads[i], NULL, INFINITE_TIME); |
| } |
| |
| printf("atomic count == %d (should be zero)\n", atomic); |
| } |
| |
| static volatile int preempt_count; |
| |
| static int preempt_tester(void* arg) { |
| spin(1000000); |
| |
| printf("exiting ts %" PRIu64 " ns\n", current_time()); |
| |
| atomic_add(&preempt_count, -1); |
| |
| return 0; |
| } |
| |
| static void preempt_test(void) { |
| /* create 5 threads, let them run. If the system is properly timer preempting, |
| * the threads should interleave each other at a fine enough granularity so |
| * that they complete at roughly the same time. */ |
| printf("testing preemption\n"); |
| |
| preempt_count = 5; |
| |
| for (int i = 0; i < preempt_count; i++) |
| thread_detach_and_resume(thread_create("preempt tester", &preempt_tester, NULL, LOW_PRIORITY, DEFAULT_STACK_SIZE)); |
| |
| while (preempt_count > 0) { |
| thread_sleep_relative(LK_SEC(1)); |
| } |
| |
| printf("done with preempt test, above time stamps should be very close\n"); |
| |
| /* do the same as above, but mark the threads as real time, which should |
| * effectively disable timer based preemption for them. They should |
| * complete in order, about a second apart. */ |
| printf("testing real time preemption\n"); |
| |
| const int num_threads = 5; |
| preempt_count = num_threads; |
| |
| for (int i = 0; i < num_threads; i++) { |
| thread_t* t = thread_create("preempt tester", &preempt_tester, NULL, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_set_real_time(t); |
| thread_set_pinned_cpu(t, 0); |
| thread_detach_and_resume(t); |
| } |
| |
| while (preempt_count > 0) { |
| thread_sleep_relative(LK_SEC(1)); |
| } |
| |
| printf("done with real-time preempt test, above time stamps should be 1 second apart\n"); |
| } |
| |
| static int join_tester(void* arg) { |
| int val = (int)(uintptr_t)arg; |
| |
| printf("\t\tjoin tester starting\n"); |
| thread_sleep_relative(LK_MSEC(500)); |
| printf("\t\tjoin tester exiting with result %d\n", val); |
| |
| return val; |
| } |
| |
| static int join_tester_server(void* arg) { |
| int ret; |
| status_t err; |
| thread_t* t; |
| |
| printf("\ttesting thread_join/thread_detach\n"); |
| |
| printf("\tcreating and waiting on thread to exit with thread_join\n"); |
| t = thread_create("join tester", &join_tester, (void*)1, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_resume(t); |
| ret = 99; |
| printf("\tthread magic is 0x%x (should be 0x%x)\n", t->magic, THREAD_MAGIC); |
| err = thread_join(t, &ret, INFINITE_TIME); |
| printf("\tthread_join returns err %d, retval %d\n", err, ret); |
| printf("\tthread magic is 0x%x (should be 0)\n", t->magic); |
| |
| printf("\tcreating and waiting on thread to exit with thread_join, after thread has exited\n"); |
| t = thread_create("join tester", &join_tester, (void*)2, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_resume(t); |
| thread_sleep_relative(LK_SEC(1)); // wait until thread is already dead |
| ret = 99; |
| printf("\tthread magic is 0x%x (should be 0x%x)\n", t->magic, THREAD_MAGIC); |
| err = thread_join(t, &ret, INFINITE_TIME); |
| printf("\tthread_join returns err %d, retval %d\n", err, ret); |
| printf("\tthread magic is 0x%x (should be 0)\n", t->magic); |
| |
| printf("\tcreating a thread, detaching it, let it exit on its own\n"); |
| t = thread_create("join tester", &join_tester, (void*)3, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_detach(t); |
| thread_resume(t); |
| thread_sleep_relative(LK_SEC(1)); // wait until the thread should be dead |
| printf("\tthread magic is 0x%x (should be 0)\n", t->magic); |
| |
| printf("\tcreating a thread, detaching it after it should be dead\n"); |
| t = thread_create("join tester", &join_tester, (void*)4, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_resume(t); |
| thread_sleep_relative(LK_SEC(1)); // wait until thread is already dead |
| printf("\tthread magic is 0x%x (should be 0x%x)\n", t->magic, THREAD_MAGIC); |
| thread_detach(t); |
| printf("\tthread magic is 0x%x\n", t->magic); |
| |
| printf("\texiting join tester server\n"); |
| |
| return 55; |
| } |
| |
| static void join_test(void) { |
| int ret; |
| status_t err; |
| thread_t* t; |
| |
| printf("testing thread_join/thread_detach\n"); |
| |
| printf("creating thread join server thread\n"); |
| t = thread_create("join tester server", &join_tester_server, (void*)1, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE); |
| thread_resume(t); |
| ret = 99; |
| err = thread_join(t, &ret, INFINITE_TIME); |
| printf("thread_join returns err %d, retval %d (should be 0 and 55)\n", err, ret); |
| } |
| |
| static void spinlock_test(void) { |
| spin_lock_saved_state_t state; |
| spin_lock_t lock; |
| |
| spin_lock_init(&lock); |
| |
| // verify basic functionality (single core) |
| printf("testing spinlock:\n"); |
| ASSERT(!spin_lock_held(&lock)); |
| ASSERT(!arch_ints_disabled()); |
| spin_lock_irqsave(&lock, state); |
| ASSERT(arch_ints_disabled()); |
| ASSERT(spin_lock_held(&lock)); |
| ASSERT(spin_lock_holder_cpu(&lock) == arch_curr_cpu_num()); |
| spin_unlock_irqrestore(&lock, state); |
| ASSERT(!spin_lock_held(&lock)); |
| ASSERT(!arch_ints_disabled()); |
| printf("seems to work\n"); |
| } |
| |
| static void sleeper_thread_exit(enum thread_user_state_change new_state, void* arg) { |
| TRACEF("arg %p\n", arg); |
| } |
| |
| static int sleeper_kill_thread(void* arg) { |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| lk_time_t t = current_time(); |
| status_t err = thread_sleep_etc(t + LK_SEC(5), true); |
| t = (current_time() - t) / LK_MSEC(1); |
| TRACEF("thread_sleep_etc returns %d after %" PRIu64 " msecs\n", err, t); |
| |
| return 0; |
| } |
| |
| static void waiter_thread_exit(enum thread_user_state_change new_state, void* arg) { |
| TRACEF("arg %p\n", arg); |
| } |
| |
| static int waiter_kill_thread_infinite_wait(void* arg) { |
| event_t* e = (event_t*)arg; |
| |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| lk_time_t t = current_time(); |
| status_t err = event_wait_deadline(e, INFINITE_TIME, true); |
| t = (current_time() - t) / LK_MSEC(1); |
| TRACEF("event_wait_deadline returns %d after %" PRIu64 " msecs\n", err, t); |
| |
| return 0; |
| } |
| |
| static int waiter_kill_thread(void* arg) { |
| event_t* e = (event_t*)arg; |
| |
| thread_sleep_relative(LK_MSEC(100)); |
| |
| lk_time_t t = current_time(); |
| status_t err = event_wait_deadline(e, t + LK_SEC(5), true); |
| t = (current_time() - t) / LK_MSEC(1); |
| TRACEF("event_wait_deadline with deadline returns %d after %" PRIu64 " msecs\n", err, t); |
| |
| return 0; |
| } |
| |
| static void kill_tests(void) { |
| thread_t* t; |
| |
| printf("starting sleeper thread, then killing it while it sleeps.\n"); |
| t = thread_create("sleeper", sleeper_kill_thread, 0, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &sleeper_thread_exit); |
| thread_resume(t); |
| thread_sleep_relative(LK_MSEC(200)); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| |
| printf("starting sleeper thread, then killing it before it wakes up.\n"); |
| t = thread_create("sleeper", sleeper_kill_thread, 0, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &sleeper_thread_exit); |
| thread_resume(t); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| |
| printf("starting sleeper thread, then killing it before it is unsuspended.\n"); |
| t = thread_create("sleeper", sleeper_kill_thread, 0, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &sleeper_thread_exit); |
| thread_kill(t, false); // kill it before it is resumed |
| thread_resume(t); |
| thread_join(t, NULL, INFINITE_TIME); |
| |
| event_t e; |
| |
| printf("starting waiter thread that waits forever, then killing it while it blocks.\n"); |
| event_init(&e, false, 0); |
| t = thread_create("waiter", waiter_kill_thread_infinite_wait, &e, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &waiter_thread_exit); |
| thread_resume(t); |
| thread_sleep_relative(LK_MSEC(200)); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| event_destroy(&e); |
| |
| printf("starting waiter thread that waits forever, then killing it before it wakes up.\n"); |
| event_init(&e, false, 0); |
| t = thread_create("waiter", waiter_kill_thread_infinite_wait, &e, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &waiter_thread_exit); |
| thread_resume(t); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| event_destroy(&e); |
| |
| printf("starting waiter thread that waits some time, then killing it while it blocks.\n"); |
| event_init(&e, false, 0); |
| t = thread_create("waiter", waiter_kill_thread, &e, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &waiter_thread_exit); |
| thread_resume(t); |
| thread_sleep_relative(LK_MSEC(200)); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| event_destroy(&e); |
| |
| printf("starting waiter thread that waits some time, then killing it before it wakes up.\n"); |
| event_init(&e, false, 0); |
| t = thread_create("waiter", waiter_kill_thread, &e, LOW_PRIORITY, DEFAULT_STACK_SIZE); |
| t->user_thread = t; |
| thread_set_user_callback(t, &waiter_thread_exit); |
| thread_resume(t); |
| thread_kill(t, true); |
| thread_join(t, NULL, INFINITE_TIME); |
| event_destroy(&e); |
| } |
| |
| int thread_tests(void) { |
| kill_tests(); |
| |
| mutex_test(); |
| event_test(); |
| |
| spinlock_test(); |
| atomic_test(); |
| |
| thread_sleep_relative(LK_MSEC(200)); |
| context_switch_test(); |
| |
| preempt_test(); |
| |
| join_test(); |
| |
| return 0; |
| } |
| |
| static int spinner_thread(void* arg) { |
| for (;;) |
| ; |
| |
| return 0; |
| } |
| |
| int spinner(int argc, const cmd_args* argv) { |
| if (argc < 2) { |
| printf("not enough args\n"); |
| printf("usage: %s <priority> <rt>\n", argv[0].str); |
| return -1; |
| } |
| |
| thread_t* t = thread_create("spinner", spinner_thread, NULL, (int)argv[1].u, DEFAULT_STACK_SIZE); |
| if (!t) |
| return ZX_ERR_NO_MEMORY; |
| |
| if (argc >= 3 && !strcmp(argv[2].str, "rt")) { |
| thread_set_real_time(t); |
| } |
| thread_detach_and_resume(t); |
| |
| return 0; |
| } |