[linux-2.6-block.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 u64 bm_cnt;
static u64 bm_stddev;
static unsigned int bm_avg;
static unsigned int bm_std;

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

	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.
		 */
		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;
	/* These don't need to be reset but reset them anyway */
	bm_first = 0;
	bm_std = 0;
	bm_avg = 0;
	bm_stddev = 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;
34839f5a SRRH	19	static u64 bm_cnt;
	20	static u64 bm_stddev;
	21	static unsigned int bm_avg;
	22	static unsigned int bm_std;
81dc9f0e SRRH	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;
72e2fe38	39	u64 stddev;
81dc9f0e	40	u64 seed;
81dc9f0e SRRH	41	u64 last_seed;
	42	unsigned int avg;
	43	unsigned int std = 0;
	44
	45	/* Only run if the tracepoint is actually active */
bdb5d0f9	46	if (!trace_benchmark_event_enabled() \|\| !tracing_is_on())
81dc9f0e SRRH	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
81dc9f0e SRRH	72	if (delta > bm_max)
	73	bm_max = delta;
	74	if (!bm_min \|\| delta < bm_min)
	75	bm_min = delta;
	76
34839f5a SRRH	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
81dc9f0e SRRH	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;
34839f5a SRRH	99	do_div(stddev, (u32)bm_cnt);
34839f5a SRRH	100	do_div(stddev, (u32)bm_cnt - 1);
81dc9f0e SRRH	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);
34839f5a SRRH	138
	139	bm_std = std;
	140	bm_avg = avg;
	141	bm_stddev = stddev;
81dc9f0e SRRH	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;
34839f5a	193	/* These don't need to be reset but reset them anyway */
81dc9f0e	194	bm_first = 0;
34839f5a SRRH	195	bm_std = 0;
	196	bm_avg = 0;
	197	bm_stddev = 0;
81dc9f0e	198	}