[lttv.git] / tests / kernel / test-cmpxchg-nolock2.c

/* test-cmpxchg-nolock.c
 *
 * Compare local cmpxchg with irq disable / enable.
 */


#include <linux/jiffies.h>
#include <linux/compiler.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/calc64.h>
#include <asm/timex.h>
#include <asm/system.h>

#define NR_LOOPS 20000

int test_val;

static void do_testbaseline(void)
{
	int ret;
	long flags;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for (i = 0; i < NR_LOOPS; i++) {
		asm volatile ("");
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for baseline\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> baseline takes %llu cycles\n", time);
	printk(KERN_ALERT "test end\n");
}

static void do_test_sync_cmpxchg(void)
{
	int ret;
	long flags;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for (i = 0; i < NR_LOOPS; i++) {
#ifdef CONFIG_X86_32
		ret = sync_cmpxchg(&test_val, 0, 0);
#else
		ret = cmpxchg(&test_val, 0, 0);
#endif
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for locked cmpxchg\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> locked cmpxchg takes %llu cycles\n", time);
	printk(KERN_ALERT "test end\n");
}

static void do_test_cmpxchg(void)
{
	int ret;
	long flags;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for (i = 0; i < NR_LOOPS; i++) {
		ret = cmpxchg_local(&test_val, 0, 0);
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for non locked cmpxchg\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> non locked cmpxchg takes %llu cycles\n", time);
	printk(KERN_ALERT "test end\n");
}

/*
 * This test will have a higher standard deviation due to incoming interrupts.
 */
static void do_test_enable_int(void)
{
	long flags;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for (i = 0; i < NR_LOOPS; i++) {
		local_irq_restore(flags);
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for enabling interrupts (STI)\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> enabling interrupts (STI) takes %llu cycles\n",
					time);
	printk(KERN_ALERT "test end\n");
}

static void do_test_disable_int(void)
{
	unsigned long flags, flags2;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for ( i = 0; i < NR_LOOPS; i++) {
		local_irq_save(flags2);
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for disabling interrupts (CLI)\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> disabling interrupts (CLI) takes %llu cycles\n",
				time);
	printk(KERN_ALERT "test end\n");
}

static void do_test_int(void)
{
	long flags;
	unsigned int i;
	cycles_t time1, time2, time;
	long rem;

	local_irq_save(flags);
	preempt_disable();
	time1 = get_cycles();
	for (i = 0; i < NR_LOOPS; i++) {
		local_irq_restore(flags);
		local_irq_save(flags);
	}
	time2 = get_cycles();
	local_irq_restore(flags);
	preempt_enable();
	time = time2 - time1;

	printk(KERN_ALERT "test results: time for disabling/enabling interrupts (STI/CLI)\n");
	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	printk(KERN_ALERT "total time: %llu\n", time);
	time = div_long_long_rem(time, NR_LOOPS, &rem);
	printk(KERN_ALERT "-> enabling/disabling interrupts (STI/CLI) takes %llu cycles\n",
					time);
	printk(KERN_ALERT "test end\n");
}


static int ltt_test_init(void)
{
	printk(KERN_ALERT "test init\n");
	
	do_testbaseline();
	do_test_sync_cmpxchg();
	do_test_cmpxchg();
	do_test_enable_int();
	do_test_disable_int();
	do_test_int();
	return -EAGAIN; /* Fail will directly unload the module */
}

static void ltt_test_exit(void)
{
	printk(KERN_ALERT "test exit\n");
}

module_init(ltt_test_init)
module_exit(ltt_test_exit)

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("Cmpxchg vs int Test");
Commit	Line	Data
421991b0	1	/* test-cmpxchg-nolock.c
	2	*
	3	* Compare local cmpxchg with irq disable / enable.
	4	*/
	5
	6
	7	#include <linux/jiffies.h>
	8	#include <linux/compiler.h>
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/calc64.h>
	12	#include <asm/timex.h>
	13	#include <asm/system.h>
	14
	15	#define NR_LOOPS 20000
	16
	17	int test_val;
	18
979e6e46	19	static void do_testbaseline(void)
	20	{
	21	int ret;
	22	long flags;
	23	unsigned int i;
	24	cycles_t time1, time2, time;
	25	long rem;
	26
	27	local_irq_save(flags);
	28	preempt_disable();
	29	time1 = get_cycles();
	30	for (i = 0; i < NR_LOOPS; i++) {
	31	asm volatile ("");
	32	}
	33	time2 = get_cycles();
	34	local_irq_restore(flags);
	35	preempt_enable();
	36	time = time2 - time1;
	37
	38	printk(KERN_ALERT "test results: time for baseline\n");
	39	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	40	printk(KERN_ALERT "total time: %llu\n", time);
	41	time = div_long_long_rem(time, NR_LOOPS, &rem);
	42	printk(KERN_ALERT "-> baseline takes %llu cycles\n", time);
	43	printk(KERN_ALERT "test end\n");
	44	}
	45
f57afc80	46	static void do_test_sync_cmpxchg(void)
	47	{
	48	int ret;
	49	long flags;
	50	unsigned int i;
	51	cycles_t time1, time2, time;
	52	long rem;
	53
	54	local_irq_save(flags);
	55	preempt_disable();
	56	time1 = get_cycles();
	57	for (i = 0; i < NR_LOOPS; i++) {
	58	#ifdef CONFIG_X86_32
	59	ret = sync_cmpxchg(&test_val, 0, 0);
	60	#else
	61	ret = cmpxchg(&test_val, 0, 0);
	62	#endif
	63	}
	64	time2 = get_cycles();
	65	local_irq_restore(flags);
	66	preempt_enable();
	67	time = time2 - time1;
	68
	69	printk(KERN_ALERT "test results: time for locked cmpxchg\n");
	70	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	71	printk(KERN_ALERT "total time: %llu\n", time);
	72	time = div_long_long_rem(time, NR_LOOPS, &rem);
	73	printk(KERN_ALERT "-> locked cmpxchg takes %llu cycles\n", time);
	74	printk(KERN_ALERT "test end\n");
	75	}
	76
421991b0	77	static void do_test_cmpxchg(void)
	78	{
	79	int ret;
	80	long flags;
	81	unsigned int i;
	82	cycles_t time1, time2, time;
	83	long rem;
	84
	85	local_irq_save(flags);
	86	preempt_disable();
	87	time1 = get_cycles();
	88	for (i = 0; i < NR_LOOPS; i++) {
	89	ret = cmpxchg_local(&test_val, 0, 0);
	90	}
	91	time2 = get_cycles();
	92	local_irq_restore(flags);
	93	preempt_enable();
	94	time = time2 - time1;
	95
	96	printk(KERN_ALERT "test results: time for non locked cmpxchg\n");
	97	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	98	printk(KERN_ALERT "total time: %llu\n", time);
	99	time = div_long_long_rem(time, NR_LOOPS, &rem);
	100	printk(KERN_ALERT "-> non locked cmpxchg takes %llu cycles\n", time);
	101	printk(KERN_ALERT "test end\n");
	102	}
	103
	104	/*
	105	* This test will have a higher standard deviation due to incoming interrupts.
	106	*/
	107	static void do_test_enable_int(void)
	108	{
	109	long flags;
	110	unsigned int i;
	111	cycles_t time1, time2, time;
	112	long rem;
	113
	114	local_irq_save(flags);
	115	preempt_disable();
	116	time1 = get_cycles();
	117	for (i = 0; i < NR_LOOPS; i++) {
	118	local_irq_restore(flags);
	119	}
	120	time2 = get_cycles();
	121	local_irq_restore(flags);
	122	preempt_enable();
	123	time = time2 - time1;
	124
	125	printk(KERN_ALERT "test results: time for enabling interrupts (STI)\n");
	126	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	127	printk(KERN_ALERT "total time: %llu\n", time);
	128	time = div_long_long_rem(time, NR_LOOPS, &rem);
	129	printk(KERN_ALERT "-> enabling interrupts (STI) takes %llu cycles\n",
	130	time);
	131	printk(KERN_ALERT "test end\n");
	132	}
	133
	134	static void do_test_disable_int(void)
	135	{
	136	unsigned long flags, flags2;
	137	unsigned int i;
	138	cycles_t time1, time2, time;
	139	long rem;
	140
141	local_irq_save(flags);
142	preempt_disable();
143	time1 = get_cycles();
144	for ( i = 0; i < NR_LOOPS; i++) {
145	local_irq_save(flags2);
146	}
147	time2 = get_cycles();
148	local_irq_restore(flags);
149	preempt_enable();
150	time = time2 - time1;
151
152	printk(KERN_ALERT "test results: time for disabling interrupts (CLI)\n");
153	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
154	printk(KERN_ALERT "total time: %llu\n", time);
155	time = div_long_long_rem(time, NR_LOOPS, &rem);
7de49e3a	156	printk(KERN_ALERT "-> disabling interrupts (CLI) takes %llu cycles\n",
421991b0	157	time);
	158	printk(KERN_ALERT "test end\n");
	159	}
	160
236f9aae	161	static void do_test_int(void)
	162	{
	163	long flags;
	164	unsigned int i;
	165	cycles_t time1, time2, time;
	166	long rem;
	167
	168	local_irq_save(flags);
	169	preempt_disable();
	170	time1 = get_cycles();
	171	for (i = 0; i < NR_LOOPS; i++) {
	172	local_irq_restore(flags);
	173	local_irq_save(flags);
	174	}
	175	time2 = get_cycles();
	176	local_irq_restore(flags);
	177	preempt_enable();
	178	time = time2 - time1;
	179
	180	printk(KERN_ALERT "test results: time for disabling/enabling interrupts (STI/CLI)\n");
	181	printk(KERN_ALERT "number of loops: %d\n", NR_LOOPS);
	182	printk(KERN_ALERT "total time: %llu\n", time);
	183	time = div_long_long_rem(time, NR_LOOPS, &rem);
	184	printk(KERN_ALERT "-> enabling/disabling interrupts (STI/CLI) takes %llu cycles\n",
	185	time);
	186	printk(KERN_ALERT "test end\n");
	187	}
	188
421991b0	189
	190
	191	static int ltt_test_init(void)
	192	{
	193	printk(KERN_ALERT "test init\n");
	194
979e6e46	195	do_testbaseline();
fa2b47dd	196	do_test_sync_cmpxchg();
421991b0	197	do_test_cmpxchg();
	198	do_test_enable_int();
	199	do_test_disable_int();
236f9aae	200	do_test_int();
421991b0	201	return -EAGAIN; /* Fail will directly unload the module */
	202	}
	203
	204	static void ltt_test_exit(void)
	205	{
	206	printk(KERN_ALERT "test exit\n");
	207	}
	208
	209	module_init(ltt_test_init)
	210	module_exit(ltt_test_exit)
	211
	212	MODULE_LICENSE("GPL");
	213	MODULE_AUTHOR("Mathieu Desnoyers");
	214	MODULE_DESCRIPTION("Cmpxchg vs int Test");
	215