[lttv.git] / trunk / tests / kernel / test-prefix-speed.c

/* test-nop-speed.c
 *
 */

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/timex.h>
#include <asm/atomic.h>
#include <asm/ptrace.h>

#define NR_TESTS 10000000

int var, var2;
atomic64_t atomicval;

struct proc_dir_entry *pentry = NULL;


static inline long test_nop_atomic64_add_return(long i, atomic64_t *v)
{
	long __i = i;
	asm volatile(".byte 0x90;"
		     "xaddq %0, %1;"
		     : "+r" (i), "+m" (v->counter)
		     : : "memory");
	return i + __i;
}

static inline long test_prefix_atomic64_add_return(long i, atomic64_t *v)
{
	long __i = i;
	asm volatile(".byte 0x3E;"
		     "xaddq %0, %1;"
		     : "+r" (i), "+m" (v->counter)
		     : : "memory");
	return i + __i;
}

static inline long test_lock_atomic64_add_return(long i, atomic64_t *v)
{
	long __i = i;
	asm volatile(".byte 0xf0;"
		     "xaddq %0, %1;"
		     : "+r" (i), "+m" (v->counter)
		     : : "memory");
	return i + __i;
}


void empty(void)
{
	asm volatile ("");
	var += 50;
	var /= 10;
	var *= var2;
}

void testnop(void)
{
	test_nop_atomic64_add_return(5, &atomicval);
	var += 50;
	var /= 10;
	var *= var2;
}

void testprefix(void)
{
	test_prefix_atomic64_add_return(5, &atomicval);
	var += 50;
	var /= 10;
	var *= var2;
}

void testlock(void)
{
	test_lock_atomic64_add_return(5, &atomicval);
	var += 50;
	var /= 10;
	var *= var2;
}


void perform_test(const char *name, void (*callback)(void))
{
	unsigned int i;
	cycles_t cycles1, cycles2;
	unsigned long flags;

	local_irq_save(flags);
	rdtsc_barrier();
	cycles1 = get_cycles();
	rdtsc_barrier();
	for(i=0; i<NR_TESTS; i++) {
		callback();
	}
	rdtsc_barrier();
	cycles2 = get_cycles();
	rdtsc_barrier();
	local_irq_restore(flags);
	printk("test %s cycles : %llu\n", name, cycles2-cycles1);
}

static int my_open(struct inode *inode, struct file *file)
{
	printk("NR_TESTS %d\n", NR_TESTS);

	perform_test("empty", empty);
	printk("value : %ld\n", atomic64_read(&atomicval));
	perform_test("test 1-byte nop xadd", testnop);
	printk("value : %ld\n", atomic64_read(&atomicval));
	perform_test("test DS override prefix xadd", testprefix);
	printk("value : %ld\n", atomic64_read(&atomicval));
	perform_test("test LOCK xadd", testlock);
	printk("value : %ld\n", atomic64_read(&atomicval));

	return -EPERM;
}


static struct file_operations my_operations = {
	.open = my_open,
};

int init_module(void)
{
	pentry = create_proc_entry("testprefix", 0444, NULL);
	if (pentry)
		pentry->proc_fops = &my_operations;

	return 0;
}

void cleanup_module(void)
{
	remove_proc_entry("testprefix", NULL);
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("prefix test");
Commit	Line	Data
2bbb1cab	1	/* test-nop-speed.c
	2	*
	3	*/
	4
	5	#include <linux/module.h>
	6	#include <linux/proc_fs.h>
	7	#include <linux/sched.h>
	8	#include <linux/timex.h>
	9	#include <asm/atomic.h>
	10	#include <asm/ptrace.h>
	11
	12	#define NR_TESTS 10000000
	13
	14	int var, var2;
	15	atomic64_t atomicval;
	16
	17	struct proc_dir_entry *pentry = NULL;
	18
	19
	20	static inline long test_nop_atomic64_add_return(long i, atomic64_t *v)
	21	{
	22	long __i = i;
	23	asm volatile(".byte 0x90;"
	24	"xaddq %0, %1;"
	25	: "+r" (i), "+m" (v->counter)
	26	: : "memory");
	27	return i + __i;
	28	}
	29
	30	static inline long test_prefix_atomic64_add_return(long i, atomic64_t *v)
	31	{
	32	long __i = i;
	33	asm volatile(".byte 0x3E;"
	34	"xaddq %0, %1;"
	35	: "+r" (i), "+m" (v->counter)
	36	: : "memory");
	37	return i + __i;
	38	}
	39
	40	static inline long test_lock_atomic64_add_return(long i, atomic64_t *v)
	41	{
	42	long __i = i;
	43	asm volatile(".byte 0xf0;"
	44	"xaddq %0, %1;"
	45	: "+r" (i), "+m" (v->counter)
	46	: : "memory");
	47	return i + __i;
	48	}
	49
	50
	51
	52	void empty(void)
	53	{
	54	asm volatile ("");
	55	var += 50;
	56	var /= 10;
	57	var *= var2;
	58	}
	59
	60	void testnop(void)
	61	{
	62	test_nop_atomic64_add_return(5, &atomicval);
	63	var += 50;
	64	var /= 10;
65	var *= var2;
66	}
67
68	void testprefix(void)
69	{
70	test_prefix_atomic64_add_return(5, &atomicval);
71	var += 50;
72	var /= 10;
73	var *= var2;
74	}
75
76	void testlock(void)
77	{
78	test_lock_atomic64_add_return(5, &atomicval);
79	var += 50;
80	var /= 10;
81	var *= var2;
82	}
83
84
85
86	void perform_test(const char name, void (callback)(void))
87	{
88	unsigned int i;
89	cycles_t cycles1, cycles2;
90	unsigned long flags;
91
92	local_irq_save(flags);
93	rdtsc_barrier();
94	cycles1 = get_cycles();
95	rdtsc_barrier();
96	for(i=0; i<NR_TESTS; i++) {
97	callback();
98	}
99	rdtsc_barrier();
100	cycles2 = get_cycles();
101	rdtsc_barrier();
102	local_irq_restore(flags);
103	printk("test %s cycles : %llu\n", name, cycles2-cycles1);
104	}
105
106	static int my_open(struct inode inode, struct file file)
107	{
108	printk("NR_TESTS %d\n", NR_TESTS);
109
110	perform_test("empty", empty);
f0a36bb1	111	printk("value : %ld\n", atomic64_read(&atomicval));
2bbb1cab	112	perform_test("test 1-byte nop xadd", testnop);
f0a36bb1	113	printk("value : %ld\n", atomic64_read(&atomicval));
2bbb1cab	114	perform_test("test DS override prefix xadd", testprefix);
f0a36bb1	115	printk("value : %ld\n", atomic64_read(&atomicval));
2bbb1cab	116	perform_test("test LOCK xadd", testlock);
f0a36bb1	117	printk("value : %ld\n", atomic64_read(&atomicval));
2bbb1cab	118
	119	return -EPERM;
	120	}
	121
	122
	123	static struct file_operations my_operations = {
	124	.open = my_open,
	125	};
	126
	127	int init_module(void)
	128	{
980ef4a0	129	pentry = create_proc_entry("testprefix", 0444, NULL);
2bbb1cab	130	if (pentry)
	131	pentry->proc_fops = &my_operations;
	132
	133	return 0;
	134	}
	135
	136	void cleanup_module(void)
	137	{
980ef4a0	138	remove_proc_entry("testprefix", NULL);
2bbb1cab	139	}
	140
	141	MODULE_LICENSE("GPL");
	142	MODULE_AUTHOR("Mathieu Desnoyers");
980ef4a0	143	MODULE_DESCRIPTION("prefix test");