Changeset 95155b0c in mainline for kernel/generic/src

Timestamp:

2006-12-19T10:12:24Z (19 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/generic/src

Files:

• console/cmd.c (modified) (6 diffs)
• lib/func.c (modified) (1 diff)
• proc/task.c (modified) (2 diffs)
• proc/thread.c (modified) (1 diff)

kernel/generic/src/console/cmd.c

@@ -117 +117 @@
         .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
@@ -412 +431 @@
         &tests_info,
         &test_info,
+        &bench_info,
 #endif
         NULL
@@ -872 +892 @@
         
         /* Execute the test */
-        char * ret = test->entry();
+        char * ret = test->entry(false);
         
         /* Update and read thread accounting */
@@ -881 +901 @@
         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) {
@@ -890 +914 @@
         printf("%s\n", ret);
         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;
 }
 
@@ -927 +1017 @@
         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
 

kernel/generic/src/lib/func.c

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

kernel/generic/src/proc/task.c

@@ -53 +53 @@
 #include <lib/elf.h>
 #include <errno.h>
+#include <func.h>
 #include <syscall/copy.h>
 #include <console/klog.h>
@@ -392 +393 @@
                         spinlock_lock(&t->lock);
                         
-                        uint64_t cycles = task_get_accounting(t);
+                        uint64_t cycles;
                         char 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 = ' ';
+                        order(task_get_accounting(t), &cycles, &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));

kernel/generic/src/proc/thread.c

@@ -570 +570 @@
                         uint64_t cycles;
                         char 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 = ' ';
-                        }
+                        order(t->cycles, &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);