Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2049 → Rev 2050

/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 = ' ';
}
}
 
/** @}
*/