[linux-2.6-block.git] / tools / virtio / ringtest / main.h

/*
 * Copyright (C) 2016 Red Hat, Inc.
 * Author: Michael S. Tsirkin <mst@redhat.com>
 * This work is licensed under the terms of the GNU GPL, version 2.
 *
 * Common macros and functions for ring benchmarking.
 */
#ifndef MAIN_H
#define MAIN_H

#include <stdbool.h>

extern bool do_exit;

#if defined(__x86_64__) || defined(__i386__)
#include "x86intrin.h"

static inline void wait_cycles(unsigned long long cycles)
{
	unsigned long long t;

	t = __rdtsc();
	while (__rdtsc() - t < cycles) {}
}

#define VMEXIT_CYCLES 500
#define VMENTRY_CYCLES 500

#elif defined(__s390x__)
static inline void wait_cycles(unsigned long long cycles)
{
	asm volatile("0: brctg %0,0b" : : "d" (cycles));
}

/* tweak me */
#define VMEXIT_CYCLES 200
#define VMENTRY_CYCLES 200

#else
static inline void wait_cycles(unsigned long long cycles)
{
	_Exit(5);
}
#define VMEXIT_CYCLES 0
#define VMENTRY_CYCLES 0
#endif

static inline void vmexit(void)
{
	if (!do_exit)
		return;
	
	wait_cycles(VMEXIT_CYCLES);
}
static inline void vmentry(void)
{
	if (!do_exit)
		return;
	
	wait_cycles(VMENTRY_CYCLES);
}

/* implemented by ring */
void alloc_ring(void);
/* guest side */
int add_inbuf(unsigned, void *, void *);
void *get_buf(unsigned *, void **);
void disable_call();
bool used_empty();
bool enable_call();
void kick_available();
/* host side */
void disable_kick();
bool avail_empty();
bool enable_kick();
bool use_buf(unsigned *, void **);
void call_used();

/* implemented by main */
extern bool do_sleep;
void kick(void);
void wait_for_kick(void);
void call(void);
void wait_for_call(void);

extern unsigned ring_size;

/* Compiler barrier - similar to what Linux uses */
#define barrier() asm volatile("" ::: "memory")

/* Is there a portable way to do this? */
#if defined(__x86_64__) || defined(__i386__)
#define cpu_relax() asm ("rep; nop" ::: "memory")
#elif defined(__s390x__)
#define cpu_relax() barrier()
#else
#define cpu_relax() assert(0)
#endif

extern bool do_relax;

static inline void busy_wait(void)
{
	if (do_relax)
		cpu_relax();
	else
		/* prevent compiler from removing busy loops */
		barrier();
} 

/*
 * Not using __ATOMIC_SEQ_CST since gcc docs say they are only synchronized
 * with other __ATOMIC_SEQ_CST calls.
 */
#define smp_mb() __sync_synchronize()

/*
 * This abuses the atomic builtins for thread fences, and
 * adds a compiler barrier.
 */
#define smp_release() do { \
    barrier(); \
    __atomic_thread_fence(__ATOMIC_RELEASE); \
} while (0)

#define smp_acquire() do { \
    __atomic_thread_fence(__ATOMIC_ACQUIRE); \
    barrier(); \
} while (0)

#endif
Commit	Line	Data
481eaec3 MT	1	/*
	2	* Copyright (C) 2016 Red Hat, Inc.
	3	* Author: Michael S. Tsirkin <mst@redhat.com>
	4	* This work is licensed under the terms of the GNU GPL, version 2.
	5	*
	6	* Common macros and functions for ring benchmarking.
	7	*/
	8	#ifndef MAIN_H
	9	#define MAIN_H
	10
	11	#include <stdbool.h>
	12
	13	extern bool do_exit;
	14
	15	#if defined(__x86_64__) \|\| defined(__i386__)
	16	#include "x86intrin.h"
	17
	18	static inline void wait_cycles(unsigned long long cycles)
	19	{
	20	unsigned long long t;
	21
	22	t = __rdtsc();
	23	while (__rdtsc() - t < cycles) {}
	24	}
	25
	26	#define VMEXIT_CYCLES 500
	27	#define VMENTRY_CYCLES 500
	28
47a4c49a HP	29	#elif defined(__s390x__)
	30	static inline void wait_cycles(unsigned long long cycles)
	31	{
	32	asm volatile("0: brctg %0,0b" : : "d" (cycles));
	33	}
	34
	35	/* tweak me */
	36	#define VMEXIT_CYCLES 200
	37	#define VMENTRY_CYCLES 200
	38
481eaec3 MT	39	#else
	40	static inline void wait_cycles(unsigned long long cycles)
	41	{
	42	_Exit(5);
	43	}
	44	#define VMEXIT_CYCLES 0
	45	#define VMENTRY_CYCLES 0
	46	#endif
	47
	48	static inline void vmexit(void)
	49	{
	50	if (!do_exit)
	51	return;
	52
	53	wait_cycles(VMEXIT_CYCLES);
	54	}
	55	static inline void vmentry(void)
	56	{
	57	if (!do_exit)
	58	return;
	59
	60	wait_cycles(VMENTRY_CYCLES);
	61	}
	62
	63	/* implemented by ring */
	64	void alloc_ring(void);
	65	/* guest side */
	66	int add_inbuf(unsigned, void , void );
	67	void get_buf(unsigned , void **);
	68	void disable_call();
d3c3589b	69	bool used_empty();
481eaec3 MT	70	bool enable_call();
481eaec3 MT	71	void kick_available();
481eaec3 MT	72	/* host side */
481eaec3 MT	73	void disable_kick();
d3c3589b	74	bool avail_empty();
481eaec3 MT	75	bool enable_kick();
	76	bool use_buf(unsigned , void *);
	77	void call_used();
481eaec3 MT	78
	79	/* implemented by main */
	80	extern bool do_sleep;
	81	void kick(void);
	82	void wait_for_kick(void);
	83	void call(void);
	84	void wait_for_call(void);
	85
	86	extern unsigned ring_size;
	87
	88	/* Compiler barrier - similar to what Linux uses */
	89	#define barrier() asm volatile("" ::: "memory")
	90
	91	/* Is there a portable way to do this? */
	92	#if defined(__x86_64__) \|\| defined(__i386__)
	93	#define cpu_relax() asm ("rep; nop" ::: "memory")
47a4c49a HP	94	#elif defined(__s390x__)
47a4c49a HP	95	#define cpu_relax() barrier()
481eaec3 MT	96	#else
	97	#define cpu_relax() assert(0)
	98	#endif
	99
	100	extern bool do_relax;
	101
	102	static inline void busy_wait(void)
	103	{
	104	if (do_relax)
	105	cpu_relax();
	106	else
	107	/* prevent compiler from removing busy loops */
	108	barrier();
	109	}
	110
	111	/*
	112	* Not using __ATOMIC_SEQ_CST since gcc docs say they are only synchronized
	113	* with other __ATOMIC_SEQ_CST calls.
	114	*/
	115	#define smp_mb() __sync_synchronize()
	116
	117	/*
	118	* This abuses the atomic builtins for thread fences, and
	119	* adds a compiler barrier.
	120	*/
	121	#define smp_release() do { \
	122	barrier(); \
	123	__atomic_thread_fence(__ATOMIC_RELEASE); \
	124	} while (0)
	125
	126	#define smp_acquire() do { \
	127	__atomic_thread_fence(__ATOMIC_ACQUIRE); \
	128	barrier(); \
	129	} while (0)
	130
	131	#endif