[mirror_ubuntu-focal-kernel.git] / kernel / trace / trace_benchmark.c

#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 s64 bm_cnt;

/*
 * 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 writen within the statics from
 * then on but never changes.
 */
static void trace_do_benchmark(void)
{
	u64 start;
	u64 stop;
	u64 delta;
	s64 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())
		return;

	local_irq_disable();
	start = trace_clock_local();
	trace_benchmark_event(bm_str);
	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;

	bm_total += delta;
	bm_totalsq += delta * delta;

	if (delta > bm_max)
		bm_max = delta;
	if (!bm_min || delta < bm_min)
		bm_min = 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, bm_cnt);
		do_div(stddev, bm_cnt - 1);
	} else
		stddev = 0;

	delta = bm_total;
	do_div(delta, bm_cnt);
	avg = delta;

	if (stddev > 0) {
		int i = 0;
		/*
		 * stddev is the square of standard deviation but
		 * we want the actualy 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;
			do_div(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);
}

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.
		 */
		cond_resched();
	}

	return 0;
}

/*
 * When the benchmark tracepoint is enabled, it calls this
 * function and the thread that calls the tracepoint is created.
 */
void trace_benchmark_reg(void)
{
	bm_event_thread = kthread_run(benchmark_event_kthread,
				      NULL, "event_benchmark");
	WARN_ON(!bm_event_thread);
}

/*
 * 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);

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