Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229// SPDX-License-Identifier: GPL-2.0#include <linux/delay.h>#include <linux/module.h>#include <linux/kthread.h>#include <linux/trace_clock.h>
#define CREATE_TRACE_POINTS#include "trace_benchmark.h"
static struct task_struct *bm_event_thread;
static char bm_str[BENCHMARK_EVENT_STRLEN] = "START";
static u64 bm_total;static u64 bm_totalsq;static u64 bm_last;static u64 bm_max;static u64 bm_min;static u64 bm_first;static u64 bm_cnt;static u64 bm_stddev;static unsigned int bm_avg;static unsigned int bm_std;
static bool ok_to_run;
/* * This gets called in a loop recording the time it took to write * the tracepoint. What it writes is the time statistics of the last * tracepoint write. As there is nothing to write the first time * it simply writes "START". As the first write is cold cache and * the rest is hot, we save off that time in bm_first and it is * reported as "first", which is shown in the second write to the * tracepoint. The "first" field is written within the statics from * then on but never changes. */static void trace_do_benchmark(void){ u64 start; u64 stop; u64 delta; u64 stddev; u64 seed; u64 last_seed; unsigned int avg; unsigned int std = 0;
/* Only run if the tracepoint is actually active */ if (!trace_benchmark_event_enabled() || !tracing_is_on()) return;
local_irq_disable(); start = trace_clock_local(); trace_benchmark_event(bm_str, bm_last); stop = trace_clock_local(); local_irq_enable();
bm_cnt++;
delta = stop - start;
/* * The first read is cold cached, keep it separate from the * other calculations. */ if (bm_cnt == 1) { bm_first = delta; scnprintf(bm_str, BENCHMARK_EVENT_STRLEN, "first=%llu [COLD CACHED]", bm_first); return; }
bm_last = delta;
if (delta > bm_max) bm_max = delta; if (!bm_min || delta < bm_min) bm_min = delta;
/* * When bm_cnt is greater than UINT_MAX, it breaks the statistics * accounting. Freeze the statistics when that happens. * We should have enough data for the avg and stddev anyway. */ if (bm_cnt > UINT_MAX) { scnprintf(bm_str, BENCHMARK_EVENT_STRLEN, "last=%llu first=%llu max=%llu min=%llu ** avg=%u std=%d std^2=%lld", bm_last, bm_first, bm_max, bm_min, bm_avg, bm_std, bm_stddev); return; }
bm_total += delta; bm_totalsq += delta * delta;
if (bm_cnt > 1) { /* * Apply Welford's method to calculate standard deviation: * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2) */ stddev = (u64)bm_cnt * bm_totalsq - bm_total * bm_total; do_div(stddev, (u32)bm_cnt); do_div(stddev, (u32)bm_cnt - 1); } else stddev = 0;
delta = bm_total; do_div(delta, (u32)bm_cnt); avg = delta;
if (stddev > 0) { int i = 0; /* * stddev is the square of standard deviation but * we want the actually number. Use the average * as our seed to find the std. * * The next try is: * x = (x + N/x) / 2 * * Where N is the squared number to find the square * root of. */ seed = avg; do { last_seed = seed; seed = stddev; if (!last_seed) break; seed = div64_u64(seed, last_seed); seed += last_seed; do_div(seed, 2); } while (i++ < 10 && last_seed != seed);
std = seed; }
scnprintf(bm_str, BENCHMARK_EVENT_STRLEN, "last=%llu first=%llu max=%llu min=%llu avg=%u std=%d std^2=%lld", bm_last, bm_first, bm_max, bm_min, avg, std, stddev);
bm_std = std; bm_avg = avg; bm_stddev = stddev;}
static int benchmark_event_kthread(void *arg){ /* sleep a bit to make sure the tracepoint gets activated */ msleep(100);
while (!kthread_should_stop()) {
trace_do_benchmark();
/* * We don't go to sleep, but let others run as well. * This is basically a "yield()" to let any task that * wants to run, schedule in, but if the CPU is idle, * we'll keep burning cycles. * * Note the tasks_rcu_qs() version of cond_resched() will * notify synchronize_rcu_tasks() that this thread has * passed a quiescent state for rcu_tasks. Otherwise * this thread will never voluntarily schedule which would * block synchronize_rcu_tasks() indefinitely. */ cond_resched_tasks_rcu_qs(); }
return 0;}
/* * When the benchmark tracepoint is enabled, it calls this * function and the thread that calls the tracepoint is created. */int trace_benchmark_reg(void){ if (!ok_to_run) { pr_warn("trace benchmark cannot be started via kernel command line\n"); return -EBUSY; }
bm_event_thread = kthread_run(benchmark_event_kthread, NULL, "event_benchmark"); if (IS_ERR(bm_event_thread)) { pr_warn("trace benchmark failed to create kernel thread\n"); return PTR_ERR(bm_event_thread); }
return 0;}
/* * When the benchmark tracepoint is disabled, it calls this * function and the thread that calls the tracepoint is deleted * and all the numbers are reset. */void trace_benchmark_unreg(void){ if (!bm_event_thread) return;
kthread_stop(bm_event_thread); bm_event_thread = NULL;
strcpy(bm_str, "START"); bm_total = 0; bm_totalsq = 0; bm_last = 0; bm_max = 0; bm_min = 0; bm_cnt = 0; /* These don't need to be reset but reset them anyway */ bm_first = 0; bm_std = 0; bm_avg = 0; bm_stddev = 0;}
static __init int ok_to_run_trace_benchmark(void){ ok_to_run = true;
return 0;}
early_initcall(ok_to_run_trace_benchmark);