Changeset 95155b0c in mainline


Ignore:
Timestamp:
2006-12-19T10:12:24Z (18 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c8410ec9
Parents:
7e7c8747
Message:

benchmarking with statistics (initial)

Location:
kernel
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/func.h

    r7e7c8747 r95155b0c  
    4949extern void strncpy(char *dest, const char *src, size_t len);
    5050extern unative_t atoi(const char *text);
     51extern void order(const uint64_t val, uint64_t *rv, char *suffix);
    5152
    5253#endif

  • kernel/generic/src/console/cmd.c

    r7e7c8747 r95155b0c  
    117117        .argc = 1,
    118118        .argv = test_argv
     119};
     120
     121static int cmd_bench(cmd_arg_t *argv);
     122static cmd_arg_t bench_argv[] = {
     123        {
     124                .type = ARG_TYPE_STRING,
     125                .buffer = test_buf,
     126                .len = sizeof(test_buf)
     127        },
     128        {
     129                .type = ARG_TYPE_INT,
     130        }
     131};
     132static cmd_info_t bench_info = {
     133        .name = "bench",
     134        .description = "Run kernel test as benchmark.",
     135        .func = cmd_bench,
     136        .argc = 2,
     137        .argv = bench_argv
    119138};
    120139#endif
    … …  
    412431        &tests_info,
    413432        &test_info,
     433        &bench_info,
    414434#endif
    415435        NULL
    … …  
    872892       
    873893        /* Execute the test */
    874         char * ret = test->entry();
     894        char * ret = test->entry(false);
    875895       
    876896        /* Update and read thread accounting */
    … …  
    881901        interrupts_restore(ipl);
    882902       
    883         printf("Time: %llu cycles\n", dt);
     903        uint64_t cycles;
     904        char suffix;
     905        order(dt, &cycles, &suffix);
     906               
     907        printf("Time: %llu%c cycles\n", cycles, suffix);
    884908       
    885909        if (ret == NULL) {
    … …  
    890914        printf("%s\n", ret);
    891915        return false;
     916}
     917
     918static bool run_bench(const test_t *test, const uint32_t cnt)
     919{
     920        uint32_t i;
     921        bool ret = true;
     922        uint64_t cycles;
     923        char suffix;
     924       
     925        if (cnt < 1)
     926                return true;
     927       
     928        uint64_t *data = malloc(sizeof(uint64_t) * cnt, 0);
     929        if (data == NULL) {
     930                printf("Error allocating memory for statistics\n");
     931                return false;
     932        }
     933       
     934        for (i = 0; i < cnt; i++) {
     935                printf("%s (%d/%d) ... ", test->name, i + 1, cnt);
     936               
     937                /* Update and read thread accounting
     938                   for benchmarking */
     939                ipl_t ipl = interrupts_disable();
     940                spinlock_lock(&TASK->lock);
     941                uint64_t t0 = task_get_accounting(TASK);
     942                spinlock_unlock(&TASK->lock);
     943                interrupts_restore(ipl);
     944               
     945                /* Execute the test */
     946                char * ret = test->entry(true);
     947               
     948                /* Update and read thread accounting */
     949                ipl = interrupts_disable();
     950                spinlock_lock(&TASK->lock);
     951                uint64_t dt = task_get_accounting(TASK) - t0;
     952                spinlock_unlock(&TASK->lock);
     953                interrupts_restore(ipl);
     954               
     955                if (ret != NULL) {
     956                        printf("%s\n", ret);
     957                        ret = false;
     958                        break;
     959                }
     960               
     961                data[i] = dt;
     962                order(dt, &cycles, &suffix);
     963                printf("OK (%llu%c cycles)\n", cycles, suffix);
     964        }
     965       
     966        if (ret) {
     967                printf("\n");
     968               
     969                uint64_t sum = 0;
     970               
     971                for (i = 0; i < cnt; i++) {
     972                        sum += data[i];
     973                }
     974               
     975                order(sum / (uint64_t) cnt, &cycles, &suffix);
     976                printf("Average\t\t%llu%c\n", cycles, suffix);
     977        }
     978       
     979        free(data);
     980       
     981        return ret;
    892982}
    893983
    … …  
    9271017        return 1;
    9281018}
     1019
     1020/** Command for returning kernel tests as benchmarks
     1021 *
     1022 * @param argv Argument vector.
     1023 *
     1024 * return Always 1.
     1025 */
     1026int cmd_bench(cmd_arg_t *argv)
     1027{
     1028        test_t *test;
     1029        uint32_t cnt = argv[1].intval;
     1030       
     1031        bool fnd = false;
     1032       
     1033        for (test = tests; test->name != NULL; test++) {
     1034                if (strcmp(test->name, argv->buffer) == 0) {
     1035                        fnd = true;
     1036                        run_bench(test, cnt);
     1037                        break;
     1038                }
     1039        }
     1040               
     1041        if (!fnd)
     1042                printf("Unknown test\n");
     1043
     1044        return 1;
     1045}
     1046
    9291047#endif
    9301048

  • kernel/generic/src/lib/func.c

    r7e7c8747 r95155b0c  
    222222}
    223223
     224
     225void order(const uint64_t val, uint64_t *rv, char *suffix)
     226{
     227        if (val > 1000000000000000000LL) {
     228                *rv = val / 1000000000000000000LL;
     229                *suffix = 'E';
     230        } else if (val > 1000000000000LL) {
     231                *rv = val / 1000000000000LL;
     232                *suffix = 'T';
     233        } else if (val > 1000000LL) {
     234                *rv = val / 1000000LL;
     235                *suffix = 'M';
     236        } else {
     237                *rv = val;
     238                *suffix = ' ';
     239        }
     240}
     241
    224242/** @}
    225243 */

  • kernel/generic/src/proc/task.c

    r7e7c8747 r95155b0c  
    5353#include <lib/elf.h>
    5454#include <errno.h>
     55#include <func.h>
    5556#include <syscall/copy.h>
    5657#include <console/klog.h>
    … …  
    392393                        spinlock_lock(&t->lock);
    393394                       
    394                         uint64_t cycles = task_get_accounting(t);
     395                        uint64_t cycles;
    395396                        char suffix;
    396                        
    397                         if (cycles > 1000000000000000000LL) {
    398                                 cycles = cycles / 1000000000000000000LL;
    399                                 suffix = 'E';
    400                         } else if (cycles > 1000000000000LL) {
    401                                 cycles = cycles / 1000000000000LL;
    402                                 suffix = 'T';
    403                         } else if (cycles > 1000000LL) {
    404                                 cycles = cycles / 1000000LL;
    405                                 suffix = 'M';
    406                         } else
    407                                 suffix = ' ';
     397                        order(task_get_accounting(t), &cycles, &suffix);
    408398                       
    409399                        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));

  • kernel/generic/src/proc/thread.c

    r7e7c8747 r95155b0c  
    570570                        uint64_t cycles;
    571571                        char suffix;
    572                        
    573                         if (t->cycles > 1000000000000000000LL) {
    574                                 cycles = t->cycles / 1000000000000000000LL;
    575                                 suffix = 'E';
    576                         } else if (t->cycles > 1000000000000LL) {
    577                                 cycles = t->cycles / 1000000000000LL;
    578                                 suffix = 'T';
    579                         } else if (t->cycles > 1000000LL) {
    580                                 cycles = t->cycles / 1000000LL;
    581                                 suffix = 'M';
    582                         } else {
    583                                 cycles = t->cycles;
    584                                 suffix = ' ';
    585                         }
     572                        order(t->cycles, &cycles, &suffix);
    586573                       
    587574                        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);

  • kernel/test/atomic/atomic1.c

    r7e7c8747 r95155b0c  
    3232#include <debug.h>
    3333
    34 char * test_atomic1(void)
     34char * test_atomic1(bool quiet)
    3535{
    3636        atomic_t a;

  • kernel/test/btree/btree1.c

    r7e7c8747 r95155b0c  
    3434static void *data = (void *) 0xdeadbeef;
    3535
    36 char * test_btree1(void)
     36char * test_btree1(bool quiet)
    3737{
    3838        btree_t t;
    … …  
    4040
    4141        btree_create(&t);
    42 
    43         printf("Inserting keys.\n");
     42       
     43        if (!quiet)
     44                printf("Inserting keys.\n");
    4445        btree_insert(&t, 19, data, NULL);
    4546        btree_insert(&t, 20, data, NULL);
    … …  
    7778        for (i = 100; i >= 50; i--)
    7879                btree_insert(&t, i, data, NULL);
    79 
    80         btree_print(&t);
    8180       
    82         printf("Removing keys.\n");
     81        if (!quiet)
     82                btree_print(&t);
     83       
     84        if (!quiet)
     85                printf("Removing keys.\n");
    8386        btree_remove(&t, 50, NULL);
    8487        btree_remove(&t, 49, NULL);
    … …  
    155158        btree_remove(&t, 35, NULL);
    156159        btree_remove(&t, 36, NULL);
    157 
    158         btree_print(&t);
     160       
     161        if (!quiet)
     162                btree_print(&t);
    159163       
    160164        return NULL;

  • kernel/test/debug/mips1.c

    r7e7c8747 r95155b0c  
    3939#include <arch.h>
    4040
    41 char * test_mips1(void)
     41char * test_mips1(bool quiet)
    4242{
    4343        printf("You should enter kconsole debug mode now.\n");

  • kernel/test/fault/fault1.c

    r7e7c8747 r95155b0c  
    3838
    3939
    40 char * test_fault1(void)
     40char * test_fault1(bool quiet)
    4141{
    4242        ((int *)(0))[1] = 0;

  • kernel/test/fpu/fpu1.c

    r7e7c8747 r95155b0c  
    174174}
    175175
    176 char * test_fpu1(void)
     176char * test_fpu1(bool quiet)
    177177{
    178178        unsigned int i, total = 0;

  • kernel/test/fpu/mips2.c

    r7e7c8747 r95155b0c  
    111111
    112112
    113 char * test_mips2(void)
     113char * test_mips2(bool quiet)
    114114{
    115115        unsigned int i, total = 0;

  • kernel/test/fpu/sse1.c

    r7e7c8747 r95155b0c  
    110110
    111111
    112 char * test_sse1(void)
     112char * test_sse1(bool quiet)
    113113{
    114114        unsigned int i, total = 0;

  • kernel/test/mm/falloc1.c

    r7e7c8747 r95155b0c  
    4141#define TEST_RUNS 2
    4242
    43 char * test_falloc1(void) {
     43char * test_falloc1(bool quiet) {
    4444        uintptr_t * frames = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
    4545        int results[MAX_ORDER + 1];

  • kernel/test/mm/falloc2.c

    r7e7c8747 r95155b0c  
    100100}
    101101
    102 char * test_falloc2(void)
     102char * test_falloc2(bool quiet)
    103103{
    104104        unsigned int i;

  • kernel/test/mm/mapping1.c

    r7e7c8747 r95155b0c  
    4242#define VALUE1  0x89abcdef
    4343
    44 char * test_mapping1(void)
     44char * test_mapping1(bool quiet)
    4545{
    4646        uintptr_t frame0, frame1;

  • kernel/test/mm/purge1.c

    r7e7c8747 r95155b0c  
    4242extern void tlb_invalidate_pages(asid_t asid, uintptr_t va, count_t cnt);
    4343
    44 char * test_purge1(void)
     44char * test_purge1(bool quiet)
    4545{
    4646        tlb_entry_t entryi;

  • kernel/test/mm/slab1.c

    r7e7c8747 r95155b0c  
    153153}
    154154
    155 char * test_slab1(void)
     155char * test_slab1(bool quiet)
    156156{
    157157        testsimple();

  • kernel/test/mm/slab2.c

    r7e7c8747 r95155b0c  
    206206}
    207207
    208 char * test_slab2(void)
     208char * test_slab2(bool quiet)
    209209{
    210210        printf("Running reclaim single-thread test .. pass 1\n");

  • kernel/test/print/print1.c

    r7e7c8747 r95155b0c  
    3131#define BUFFER_SIZE 32
    3232
    33 char * test_print1(void)
     33char * test_print1(bool quiet)
    3434{
    3535        int retval;

  • kernel/test/synch/rwlock1.c

    r7e7c8747 r95155b0c  
    4141static rwlock_t rwlock;
    4242
    43 char * test_rwlock1(void)
     43char * test_rwlock1(bool quiet)
    4444{
    4545        rwlock_initialize(&rwlock);

  • kernel/test/synch/rwlock2.c

    r7e7c8747 r95155b0c  
    5656}
    5757
    58 char * test_rwlock2(void)
     58char * test_rwlock2(bool quiet)
    5959{
    6060        thread_t *thrd;

  • kernel/test/synch/rwlock3.c

    r7e7c8747 r95155b0c  
    5656}
    5757
    58 char * test_rwlock3(void)
     58char * test_rwlock3(bool quiet)
    5959{
    6060        int i;

  • kernel/test/synch/rwlock4.c

    r7e7c8747 r95155b0c  
    114114}
    115115
    116 char * test_rwlock4(void)
     116char * test_rwlock4(bool quiet)
    117117{
    118118        context_t ctx;

  • kernel/test/synch/rwlock5.c

    r7e7c8747 r95155b0c  
    6767}
    6868
    69 char * test_rwlock5(void)
     69char * test_rwlock5(bool quiet)
    7070{
    7171        int i, j, k;

  • kernel/test/synch/semaphore1.c

    r7e7c8747 r95155b0c  
    7070}
    7171
    72 char * test_semaphore1(void)
     72char * test_semaphore1(bool quiet)
    7373{
    7474        int i, j, k;

  • kernel/test/synch/semaphore2.c

    r7e7c8747 r95155b0c  
    8282}
    8383
    84 char * test_semaphore2(void)
     84char * test_semaphore2(bool quiet)
    8585{
    8686        uint32_t i, k;

  • kernel/test/sysinfo/sysinfo1.c

    r7e7c8747 r95155b0c  
    3333#include <sysinfo/sysinfo.h>
    3434
    35 char * test_sysinfo1(void)
     35char * test_sysinfo1(bool quiet)
    3636{
    3737        sysinfo_dump(NULL, 0);

  • kernel/test/test.h

    r7e7c8747 r95155b0c  
    3939#include <typedefs.h>
    4040
    41 typedef char * (* test_entry_t)();
     41typedef char * (* test_entry_t)(bool);
    4242
    4343typedef struct {
    … …  
    4848} test_t;
    4949
    50 extern char * test_atomic1(void);
    51 extern char * test_btree1(void);
    52 extern char * test_mips1(void);
    53 extern char * test_fault1(void);
    54 extern char * test_fpu1(void);
    55 extern char * test_sse1(void);
    56 extern char * test_mips2(void);
    57 extern char * test_falloc1(void);
    58 extern char * test_falloc2(void);
    59 extern char * test_mapping1(void);
    60 extern char * test_purge1(void);
    61 extern char * test_slab1(void);
    62 extern char * test_slab2(void);
    63 extern char * test_rwlock1(void);
    64 extern char * test_rwlock2(void);
    65 extern char * test_rwlock3(void);
    66 extern char * test_rwlock4(void);
    67 extern char * test_rwlock5(void);
    68 extern char * test_semaphore1(void);
    69 extern char * test_semaphore2(void);
    70 extern char * test_print1(void);
    71 extern char * test_thread1(void);
    72 extern char * test_sysinfo1(void);
     50extern char * test_atomic1(bool quiet);
     51extern char * test_btree1(bool quiet);
     52extern char * test_mips1(bool quiet);
     53extern char * test_fault1(bool quiet);
     54extern char * test_fpu1(bool quiet);
     55extern char * test_sse1(bool quiet);
     56extern char * test_mips2(bool quiet);
     57extern char * test_falloc1(bool quiet);
     58extern char * test_falloc2(bool quiet);
     59extern char * test_mapping1(bool quiet);
     60extern char * test_purge1(bool quiet);
     61extern char * test_slab1(bool quiet);
     62extern char * test_slab2(bool quiet);
     63extern char * test_rwlock1(bool quiet);
     64extern char * test_rwlock2(bool quiet);
     65extern char * test_rwlock3(bool quiet);
     66extern char * test_rwlock4(bool quiet);
     67extern char * test_rwlock5(bool quiet);
     68extern char * test_semaphore1(bool quiet);
     69extern char * test_semaphore2(bool quiet);
     70extern char * test_print1(bool quiet);
     71extern char * test_thread1(bool quiet);
     72extern char * test_sysinfo1(bool quiet);
    7373
    7474extern test_t tests[];

  • kernel/test/thread/thread1.c

    r7e7c8747 r95155b0c  
    5353}
    5454
    55 char * test_thread1(void)
     55char * test_thread1(bool quiet)
    5656{
    5757        unsigned int i, total = 0;
Note: See TracChangeset for help on using the changeset viewer.