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