kernel/trace/trace_benchmark.c

   1 #include <linux/delay.h>
   2 #include <linux/module.h>
   3 #include <linux/kthread.h>
   4 #include <linux/trace_clock.h>
   5
   6 #define CREATE_TRACE_POINTS
   7 #include "trace_benchmark.h"
   8
   9 static struct task_struct *bm_event_thread;
  10
  11 static char bm_str[BENCHMARK_EVENT_STRLEN] = "START";
  12
  13 static u64 bm_total;
  14 static u64 bm_totalsq;
  15 static u64 bm_last;
  16 static u64 bm_max;
  17 static u64 bm_min;
  18 static u64 bm_first;
  19 static u64 bm_cnt;
  20 static u64 bm_stddev;
  21 static unsigned int bm_avg;
  22 static unsigned int bm_std;
  23
  24 static bool ok_to_run;
  25
  26 /*
  27  * This gets called in a loop recording the time it took to write
  28  * the tracepoint. What it writes is the time statistics of the last
  29  * tracepoint write. As there is nothing to write the first time
  30  * it simply writes "START". As the first write is cold cache and
  31  * the rest is hot, we save off that time in bm_first and it is
  32  * reported as "first", which is shown in the second write to the
  33  * tracepoint. The "first" field is writen within the statics from
  34  * then on but never changes.
  35  */
  36 static void trace_do_benchmark(void)
  37 {
  38         u64 start;
  39         u64 stop;
  40         u64 delta;
  41         u64 stddev;
  42         u64 seed;
  43         u64 last_seed;
  44         unsigned int avg;
  45         unsigned int std = 0;
  46
  47         /* Only run if the tracepoint is actually active */
  48         if (!trace_benchmark_event_enabled() || !tracing_is_on())
  49                 return;
  50
  51         local_irq_disable();
  52         start = trace_clock_local();
  53         trace_benchmark_event(bm_str);
  54         stop = trace_clock_local();
  55         local_irq_enable();
  56
  57         bm_cnt++;
  58
  59         delta = stop - start;
  60
  61         /*
  62          * The first read is cold cached, keep it separate from the
  63          * other calculations.
  64          */
  65         if (bm_cnt == 1) {
  66                 bm_first = delta;
  67                 scnprintf(bm_str, BENCHMARK_EVENT_STRLEN,
  68                           "first=%llu [COLD CACHED]", bm_first);
  69                 return;
  70         }
  71
  72         bm_last = delta;
  73
  74         if (delta > bm_max)
  75                 bm_max = delta;
  76         if (!bm_min || delta < bm_min)
  77                 bm_min = delta;
  78
  79         /*
  80          * When bm_cnt is greater than UINT_MAX, it breaks the statistics
  81          * accounting. Freeze the statistics when that happens.
  82          * We should have enough data for the avg and stddev anyway.
  83          */
  84         if (bm_cnt > UINT_MAX) {
  85                 scnprintf(bm_str, BENCHMARK_EVENT_STRLEN,
  86                     "last=%llu first=%llu max=%llu min=%llu ** avg=%u std=%d std^2=%lld",
  87                           bm_last, bm_first, bm_max, bm_min, bm_avg, bm_std, bm_stddev);
  88                 return;
  89         }
  90
  91         bm_total += delta;
  92         bm_totalsq += delta * delta;
  93
  94
  95         if (bm_cnt > 1) {
  96                 /*
  97                  * Apply Welford's method to calculate standard deviation:
  98                  * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
  99                  */
 100                 stddev = (u64)bm_cnt * bm_totalsq - bm_total * bm_total;
 101                 do_div(stddev, (u32)bm_cnt);
 102                 do_div(stddev, (u32)bm_cnt - 1);
 103         } else
 104                 stddev = 0;
 105
 106         delta = bm_total;
 107         do_div(delta, bm_cnt);
 108         avg = delta;
 109
 110         if (stddev > 0) {
 111                 int i = 0;
 112                 /*
 113                  * stddev is the square of standard deviation but
 114                  * we want the actualy number. Use the average
 115                  * as our seed to find the std.
 116                  *
 117                  * The next try is:
 118                  *  x = (x + N/x) / 2
 119                  *
 120                  * Where N is the squared number to find the square
 121                  * root of.
 122                  */
 123                 seed = avg;
 124                 do {
 125                         last_seed = seed;
 126                         seed = stddev;
 127                         if (!last_seed)
 128                                 break;
 129                         do_div(seed, last_seed);
 130                         seed += last_seed;
 131                         do_div(seed, 2);
 132                 } while (i++ < 10 && last_seed != seed);
 133
 134                 std = seed;
 135         }
 136
 137         scnprintf(bm_str, BENCHMARK_EVENT_STRLEN,
 138                   "last=%llu first=%llu max=%llu min=%llu avg=%u std=%d std^2=%lld",
 139                   bm_last, bm_first, bm_max, bm_min, avg, std, stddev);
 140
 141         bm_std = std;
 142         bm_avg = avg;
 143         bm_stddev = stddev;
 144 }
 145
 146 static int benchmark_event_kthread(void *arg)
 147 {
 148         /* sleep a bit to make sure the tracepoint gets activated */
 149         msleep(100);
 150
 151         while (!kthread_should_stop()) {
 152
 153                 trace_do_benchmark();
 154
 155                 /*
 156                  * We don't go to sleep, but let others
 157                  * run as well.
 158                  */
 159                 cond_resched();
 160         }
 161
 162         return 0;
 163 }
 164
 165 /*
 166  * When the benchmark tracepoint is enabled, it calls this
 167  * function and the thread that calls the tracepoint is created.
 168  */
 169 int trace_benchmark_reg(void)
 170 {
 171         if (!ok_to_run) {
 172                 pr_warning("trace benchmark cannot be started via kernel command line\n");
 173                 return -EBUSY;
 174         }
 175
 176         bm_event_thread = kthread_run(benchmark_event_kthread,
 177                                       NULL, "event_benchmark");
 178         if (!bm_event_thread) {
 179                 pr_warning("trace benchmark failed to create kernel thread\n");
 180                 return -ENOMEM;
 181         }
 182
 183         return 0;
 184 }
 185
 186 /*
 187  * When the benchmark tracepoint is disabled, it calls this
 188  * function and the thread that calls the tracepoint is deleted
 189  * and all the numbers are reset.
 190  */
 191 void trace_benchmark_unreg(void)
 192 {
 193         if (!bm_event_thread)
 194                 return;
 195
 196         kthread_stop(bm_event_thread);
 197         bm_event_thread = NULL;
 198
 199         strcpy(bm_str, "START");
 200         bm_total = 0;
 201         bm_totalsq = 0;
 202         bm_last = 0;
 203         bm_max = 0;
 204         bm_min = 0;
 205         bm_cnt = 0;
 206         /* These don't need to be reset but reset them anyway */
 207         bm_first = 0;
 208         bm_std = 0;
 209         bm_avg = 0;
 210         bm_stddev = 0;
 211 }
 212
 213 static __init int ok_to_run_trace_benchmark(void)
 214 {
 215         ok_to_run = true;
 216
 217         return 0;
 218 }
 219
 220 early_initcall(ok_to_run_trace_benchmark);