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