/trunk/kernel/test/btree/btree1.c |
---|
33,14 → 33,15 |
static void *data = (void *) 0xdeadbeef; |
char * test_btree1(void) |
char * test_btree1(bool quiet) |
{ |
btree_t t; |
int i; |
btree_create(&t); |
printf("Inserting keys.\n"); |
if (!quiet) |
printf("Inserting keys.\n"); |
btree_insert(&t, 19, data, NULL); |
btree_insert(&t, 20, data, NULL); |
btree_insert(&t, 21, data, NULL); |
76,10 → 77,12 |
btree_insert(&t, i, data, NULL); |
for (i = 100; i >= 50; i--) |
btree_insert(&t, i, data, NULL); |
btree_print(&t); |
printf("Removing keys.\n"); |
if (!quiet) |
btree_print(&t); |
if (!quiet) |
printf("Removing keys.\n"); |
btree_remove(&t, 50, NULL); |
btree_remove(&t, 49, NULL); |
btree_remove(&t, 51, NULL); |
154,8 → 157,9 |
btree_remove(&t, 34, NULL); |
btree_remove(&t, 35, NULL); |
btree_remove(&t, 36, NULL); |
btree_print(&t); |
if (!quiet) |
btree_print(&t); |
return NULL; |
} |
/trunk/kernel/test/synch/rwlock1.c |
---|
40,7 → 40,7 |
static rwlock_t rwlock; |
char * test_rwlock1(void) |
char * test_rwlock1(bool quiet) |
{ |
rwlock_initialize(&rwlock); |
/trunk/kernel/test/synch/rwlock2.c |
---|
55,7 → 55,7 |
printf("Test passed.\n"); |
} |
char * test_rwlock2(void) |
char * test_rwlock2(bool quiet) |
{ |
thread_t *thrd; |
/trunk/kernel/test/synch/rwlock3.c |
---|
55,7 → 55,7 |
printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid); |
} |
char * test_rwlock3(void) |
char * test_rwlock3(bool quiet) |
{ |
int i; |
thread_t *thrd; |
/trunk/kernel/test/synch/semaphore1.c |
---|
69,7 → 69,7 |
semaphore_up(&sem); |
} |
char * test_semaphore1(void) |
char * test_semaphore1(bool quiet) |
{ |
int i, j, k; |
int consumers, producers; |
/trunk/kernel/test/synch/rwlock4.c |
---|
113,7 → 113,7 |
printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid); |
} |
char * test_rwlock4(void) |
char * test_rwlock4(bool quiet) |
{ |
context_t ctx; |
uint32_t i, k; |
/trunk/kernel/test/synch/semaphore2.c |
---|
81,7 → 81,7 |
printf("cpu%d, tid %d up\n", CPU->id, THREAD->tid); |
} |
char * test_semaphore2(void) |
char * test_semaphore2(bool quiet) |
{ |
uint32_t i, k; |
/trunk/kernel/test/synch/rwlock5.c |
---|
66,7 → 66,7 |
rwlock_read_unlock(&rwlock); |
} |
char * test_rwlock5(void) |
char * test_rwlock5(bool quiet) |
{ |
int i, j, k; |
count_t readers, writers; |
/trunk/kernel/test/test.h |
---|
38,7 → 38,7 |
#include <arch/types.h> |
#include <typedefs.h> |
typedef char * (* test_entry_t)(); |
typedef char * (* test_entry_t)(bool); |
typedef struct { |
char * name; |
47,29 → 47,29 |
bool safe; |
} test_t; |
extern char * test_atomic1(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_thread1(void); |
extern char * test_sysinfo1(void); |
extern char * test_atomic1(bool quiet); |
extern char * test_btree1(bool quiet); |
extern char * test_mips1(bool quiet); |
extern char * test_fault1(bool quiet); |
extern char * test_fpu1(bool quiet); |
extern char * test_sse1(bool quiet); |
extern char * test_mips2(bool quiet); |
extern char * test_falloc1(bool quiet); |
extern char * test_falloc2(bool quiet); |
extern char * test_mapping1(bool quiet); |
extern char * test_purge1(bool quiet); |
extern char * test_slab1(bool quiet); |
extern char * test_slab2(bool quiet); |
extern char * test_rwlock1(bool quiet); |
extern char * test_rwlock2(bool quiet); |
extern char * test_rwlock3(bool quiet); |
extern char * test_rwlock4(bool quiet); |
extern char * test_rwlock5(bool quiet); |
extern char * test_semaphore1(bool quiet); |
extern char * test_semaphore2(bool quiet); |
extern char * test_print1(bool quiet); |
extern char * test_thread1(bool quiet); |
extern char * test_sysinfo1(bool quiet); |
extern test_t tests[]; |
/trunk/kernel/test/debug/mips1.c |
---|
38,7 → 38,7 |
#include <arch.h> |
char * test_mips1(void) |
char * test_mips1(bool quiet) |
{ |
printf("You should enter kconsole debug mode now.\n"); |
/trunk/kernel/test/thread/thread1.c |
---|
52,7 → 52,7 |
atomic_inc(&threads_finished); |
} |
char * test_thread1(void) |
char * test_thread1(bool quiet) |
{ |
unsigned int i, total = 0; |
/trunk/kernel/test/mm/falloc1.c |
---|
40,7 → 40,7 |
#define MAX_ORDER 8 |
#define TEST_RUNS 2 |
char * test_falloc1(void) { |
char * test_falloc1(bool quiet) { |
uintptr_t * frames = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0); |
int results[MAX_ORDER + 1]; |
/trunk/kernel/test/mm/falloc2.c |
---|
99,7 → 99,7 |
atomic_dec(&thread_count); |
} |
char * test_falloc2(void) |
char * test_falloc2(bool quiet) |
{ |
unsigned int i; |
/trunk/kernel/test/mm/slab1.c |
---|
152,7 → 152,7 |
} |
char * test_slab1(void) |
char * test_slab1(bool quiet) |
{ |
testsimple(); |
testthreads(); |
/trunk/kernel/test/mm/purge1.c |
---|
41,7 → 41,7 |
extern void tlb_invalidate_all(void); |
extern void tlb_invalidate_pages(asid_t asid, uintptr_t va, count_t cnt); |
char * test_purge1(void) |
char * test_purge1(bool quiet) |
{ |
tlb_entry_t entryi; |
tlb_entry_t entryd; |
/trunk/kernel/test/mm/slab2.c |
---|
205,7 → 205,7 |
printf("Stress test complete.\n"); |
} |
char * test_slab2(void) |
char * test_slab2(bool quiet) |
{ |
printf("Running reclaim single-thread test .. pass 1\n"); |
totalmemtest(); |
/trunk/kernel/test/mm/mapping1.c |
---|
41,7 → 41,7 |
#define VALUE0 0x01234567 |
#define VALUE1 0x89abcdef |
char * test_mapping1(void) |
char * test_mapping1(bool quiet) |
{ |
uintptr_t frame0, frame1; |
uint32_t v0, v1; |
/trunk/kernel/test/fpu/mips2.c |
---|
110,7 → 110,7 |
} |
char * test_mips2(void) |
char * test_mips2(bool quiet) |
{ |
unsigned int i, total = 0; |
/trunk/kernel/test/fpu/fpu1.c |
---|
173,7 → 173,7 |
atomic_inc(&threads_ok); |
} |
char * test_fpu1(void) |
char * test_fpu1(bool quiet) |
{ |
unsigned int i, total = 0; |
/trunk/kernel/test/fpu/sse1.c |
---|
109,7 → 109,7 |
} |
char * test_sse1(void) |
char * test_sse1(bool quiet) |
{ |
unsigned int i, total = 0; |
/trunk/kernel/test/sysinfo/sysinfo1.c |
---|
32,7 → 32,7 |
#include <test.h> |
#include <sysinfo/sysinfo.h> |
char * test_sysinfo1(void) |
char * test_sysinfo1(bool quiet) |
{ |
sysinfo_dump(NULL, 0); |
return NULL; |
/trunk/kernel/test/fault/fault1.c |
---|
37,7 → 37,7 |
#include <arch.h> |
char * test_fault1(void) |
char * test_fault1(bool quiet) |
{ |
((int *)(0))[1] = 0; |
/trunk/kernel/test/atomic/atomic1.c |
---|
31,7 → 31,7 |
#include <atomic.h> |
#include <debug.h> |
char * test_atomic1(void) |
char * test_atomic1(bool quiet) |
{ |
atomic_t a; |
/trunk/kernel/test/print/print1.c |
---|
30,7 → 30,7 |
#define BUFFER_SIZE 32 |
char * test_print1(void) |
char * test_print1(bool quiet) |
{ |
int retval; |
unative_t nat = 0x12345678u; |
/trunk/kernel/generic/include/func.h |
---|
48,6 → 48,7 |
extern int strncmp(const char *src, const char *dst, size_t len); |
extern void strncpy(char *dest, const char *src, size_t len); |
extern unative_t atoi(const char *text); |
extern void order(const uint64_t val, uint64_t *rv, char *suffix); |
#endif |
/trunk/kernel/generic/src/console/cmd.c |
---|
117,6 → 117,25 |
.argc = 1, |
.argv = test_argv |
}; |
static int cmd_bench(cmd_arg_t *argv); |
static cmd_arg_t bench_argv[] = { |
{ |
.type = ARG_TYPE_STRING, |
.buffer = test_buf, |
.len = sizeof(test_buf) |
}, |
{ |
.type = ARG_TYPE_INT, |
} |
}; |
static cmd_info_t bench_info = { |
.name = "bench", |
.description = "Run kernel test as benchmark.", |
.func = cmd_bench, |
.argc = 2, |
.argv = bench_argv |
}; |
#endif |
/* Data and methods for 'description' command. */ |
411,6 → 430,7 |
#ifdef CONFIG_TEST |
&tests_info, |
&test_info, |
&bench_info, |
#endif |
NULL |
}; |
871,7 → 891,7 |
interrupts_restore(ipl); |
/* Execute the test */ |
char * ret = test->entry(); |
char * ret = test->entry(false); |
/* Update and read thread accounting */ |
ipl = interrupts_disable(); |
880,7 → 900,11 |
spinlock_unlock(&TASK->lock); |
interrupts_restore(ipl); |
printf("Time: %llu cycles\n", dt); |
uint64_t cycles; |
char suffix; |
order(dt, &cycles, &suffix); |
printf("Time: %llu%c cycles\n", cycles, suffix); |
if (ret == NULL) { |
printf("Test passed\n"); |
891,6 → 915,72 |
return false; |
} |
static bool run_bench(const test_t *test, const uint32_t cnt) |
{ |
uint32_t i; |
bool ret = true; |
uint64_t cycles; |
char suffix; |
if (cnt < 1) |
return true; |
uint64_t *data = malloc(sizeof(uint64_t) * cnt, 0); |
if (data == NULL) { |
printf("Error allocating memory for statistics\n"); |
return false; |
} |
for (i = 0; i < cnt; i++) { |
printf("%s (%d/%d) ... ", test->name, i + 1, cnt); |
/* Update and read thread accounting |
for benchmarking */ |
ipl_t ipl = interrupts_disable(); |
spinlock_lock(&TASK->lock); |
uint64_t t0 = task_get_accounting(TASK); |
spinlock_unlock(&TASK->lock); |
interrupts_restore(ipl); |
/* Execute the test */ |
char * ret = test->entry(true); |
/* Update and read thread accounting */ |
ipl = interrupts_disable(); |
spinlock_lock(&TASK->lock); |
uint64_t dt = task_get_accounting(TASK) - t0; |
spinlock_unlock(&TASK->lock); |
interrupts_restore(ipl); |
if (ret != NULL) { |
printf("%s\n", ret); |
ret = false; |
break; |
} |
data[i] = dt; |
order(dt, &cycles, &suffix); |
printf("OK (%llu%c cycles)\n", cycles, suffix); |
} |
if (ret) { |
printf("\n"); |
uint64_t sum = 0; |
for (i = 0; i < cnt; i++) { |
sum += data[i]; |
} |
order(sum / (uint64_t) cnt, &cycles, &suffix); |
printf("Average\t\t%llu%c\n", cycles, suffix); |
} |
free(data); |
return ret; |
} |
/** Command for returning kernel tests |
* |
* @param argv Argument vector. |
926,6 → 1016,34 |
return 1; |
} |
/** Command for returning kernel tests as benchmarks |
* |
* @param argv Argument vector. |
* |
* return Always 1. |
*/ |
int cmd_bench(cmd_arg_t *argv) |
{ |
test_t *test; |
uint32_t cnt = argv[1].intval; |
bool fnd = false; |
for (test = tests; test->name != NULL; test++) { |
if (strcmp(test->name, argv->buffer) == 0) { |
fnd = true; |
run_bench(test, cnt); |
break; |
} |
} |
if (!fnd) |
printf("Unknown test\n"); |
return 1; |
} |
#endif |
/** @} |
/trunk/kernel/generic/src/proc/task.c |
---|
52,6 → 52,7 |
#include <print.h> |
#include <lib/elf.h> |
#include <errno.h> |
#include <func.h> |
#include <syscall/copy.h> |
#include <console/klog.h> |
391,21 → 392,10 |
spinlock_lock(&t->lock); |
uint64_t cycles = task_get_accounting(t); |
uint64_t cycles; |
char suffix; |
order(task_get_accounting(t), &cycles, &suffix); |
if (cycles > 1000000000000000000LL) { |
cycles = cycles / 1000000000000000000LL; |
suffix = 'E'; |
} else if (cycles > 1000000000000LL) { |
cycles = cycles / 1000000000000LL; |
suffix = 'T'; |
} else if (cycles > 1000000LL) { |
cycles = cycles / 1000000LL; |
suffix = 'M'; |
} else |
suffix = ' '; |
printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd %6zd", t->taskid, t->name, t->context, t, t->as, cycles, suffix, t->refcount, atomic_get(&t->active_calls)); |
for (j = 0; j < IPC_MAX_PHONES; j++) { |
if (t->phones[j].callee) |
/trunk/kernel/generic/src/proc/thread.c |
---|
569,21 → 569,8 |
uint64_t cycles; |
char suffix; |
order(t->cycles, &cycles, &suffix); |
if (t->cycles > 1000000000000000000LL) { |
cycles = t->cycles / 1000000000000000000LL; |
suffix = 'E'; |
} else if (t->cycles > 1000000000000LL) { |
cycles = t->cycles / 1000000000000LL; |
suffix = 'T'; |
} else if (t->cycles > 1000000LL) { |
cycles = t->cycles / 1000000LL; |
suffix = 'M'; |
} else { |
cycles = t->cycles; |
suffix = ' '; |
} |
printf("%-6zd %-10s %#10zx %-8s %#10zx %-3ld %#10zx %#10zx %9llu%c ", t->tid, t->name, t, thread_states[t->state], t->task, t->task->context, t->thread_code, t->kstack, cycles, suffix); |
if (t->cpu) |
/trunk/kernel/generic/src/lib/func.c |
---|
221,5 → 221,23 |
return result; |
} |
void order(const uint64_t val, uint64_t *rv, char *suffix) |
{ |
if (val > 1000000000000000000LL) { |
*rv = val / 1000000000000000000LL; |
*suffix = 'E'; |
} else if (val > 1000000000000LL) { |
*rv = val / 1000000000000LL; |
*suffix = 'T'; |
} else if (val > 1000000LL) { |
*rv = val / 1000000LL; |
*suffix = 'M'; |
} else { |
*rv = val; |
*suffix = ' '; |
} |
} |
/** @} |
*/ |