[fio.git] / profiles / tiobench.c

#include "../fio.h"
#include "../profile.h"
#include "../parse.h"
#include "../optgroup.h"

static unsigned long long size;
static unsigned int loops = 1;
static unsigned int bs = 4096;
static unsigned int nthreads = 1;
static char *dir;

static char sz_idx[80], bs_idx[80], loop_idx[80], dir_idx[80], t_idx[80];

static const char *tb_opts[] = {
	"buffered=0", sz_idx, bs_idx, loop_idx, dir_idx, t_idx,
	"timeout=600", "group_reporting", "thread", "overwrite=1",
	"filename=.fio.tio.1:.fio.tio.2:.fio.tio.3:.fio.tio.4",
	"ioengine=sync",
	"name=seqwrite", "rw=write", "end_fsync=1",
	"name=randwrite", "stonewall", "rw=randwrite", "end_fsync=1",
	"name=seqread", "stonewall", "rw=read",
	"name=randread", "stonewall", "rw=randread", NULL,
};

struct tiobench_options {
	unsigned int pad;
	unsigned long long size;
	unsigned int loops;
	unsigned int bs;
	unsigned int nthreads;
	char *dir;
};

static struct tiobench_options tiobench_options;

static struct fio_option options[] = {
	{
		.name	= "size",
		.lname	= "Tiobench size",
		.type	= FIO_OPT_STR_VAL,
		.off1	= offsetof(struct tiobench_options, size),
		.help	= "Size in MiB",
		.category = FIO_OPT_C_PROFILE,
		.group	= FIO_OPT_G_TIOBENCH,
	},
	{
		.name	= "block",
		.lname	= "Tiobench block",
		.type	= FIO_OPT_INT,
		.off1	= offsetof(struct tiobench_options, bs),
		.help	= "Block size in bytes",
		.def	= "4096",
		.category = FIO_OPT_C_PROFILE,
		.group	= FIO_OPT_G_TIOBENCH,
	},
	{
		.name	= "numruns",
		.lname	= "Tiobench numruns",
		.type	= FIO_OPT_INT,
		.off1	= offsetof(struct tiobench_options, loops),
		.help	= "Number of runs",
		.category = FIO_OPT_C_PROFILE,
		.group	= FIO_OPT_G_TIOBENCH,
	},
	{
		.name	= "dir",
		.lname	= "Tiobench directory",
		.type	= FIO_OPT_STR_STORE,
		.off1	= offsetof(struct tiobench_options, dir),
		.help	= "Test directory",
		.category = FIO_OPT_C_PROFILE,
		.group	= FIO_OPT_G_TIOBENCH,
		.no_free = true,
	},
	{
		.name	= "threads",
		.lname	= "Tiobench threads",
		.type	= FIO_OPT_INT,
		.off1	= offsetof(struct tiobench_options, nthreads),
		.help	= "Number of Threads",
		.category = FIO_OPT_C_PROFILE,
		.group	= FIO_OPT_G_TIOBENCH,
	},
	{
		.name	= NULL,
	},
};

/*
 * Fill our private options into the command line
 */
static int tb_prep_cmdline(void)
{
	/*
	 * tiobench uses size as MiB, so multiply up
	 */
	size *= 1024 * 1024ULL;
	if (size)
		sprintf(sz_idx, "size=%llu", size);
	else
		strcpy(sz_idx, "size=4*1024*$mb_memory");

	sprintf(bs_idx, "bs=%u", bs);
	sprintf(loop_idx, "loops=%u", loops);

	if (dir)
		sprintf(dir_idx, "directory=%s", dir);
	else
		sprintf(dir_idx, "directory=./");

	sprintf(t_idx, "numjobs=%u", nthreads);
	return 0;
}

static struct profile_ops tiobench_profile = {
	.name		= "tiobench",
	.desc		= "tiotest/tiobench benchmark",
	.prep_cmd	= tb_prep_cmdline,
	.cmdline	= tb_opts,
	.options	= options,
	.opt_data	= &tiobench_options,
};

static void fio_init tiobench_register(void)
{
	if (register_profile(&tiobench_profile))
		log_err("fio: failed to register profile 'tiobench'\n");
}

static void fio_exit tiobench_unregister(void)
{
	unregister_profile(&tiobench_profile);
}
Commit	Line	Data
	1	#include "../fio.h"
	2	#include "../profile.h"
	3	#include "../parse.h"
	4	#include "../optgroup.h"
	5
	6	static unsigned long long size;
	7	static unsigned int loops = 1;
	8	static unsigned int bs = 4096;
	9	static unsigned int nthreads = 1;
	10	static char *dir;
	11
	12	static char sz_idx[80], bs_idx[80], loop_idx[80], dir_idx[80], t_idx[80];
	13
	14	static const char *tb_opts[] = {
	15	"buffered=0", sz_idx, bs_idx, loop_idx, dir_idx, t_idx,
	16	"timeout=600", "group_reporting", "thread", "overwrite=1",
	17	"filename=.fio.tio.1:.fio.tio.2:.fio.tio.3:.fio.tio.4",
	18	"ioengine=sync",
	19	"name=seqwrite", "rw=write", "end_fsync=1",
	20	"name=randwrite", "stonewall", "rw=randwrite", "end_fsync=1",
	21	"name=seqread", "stonewall", "rw=read",
	22	"name=randread", "stonewall", "rw=randread", NULL,
	23	};
	24
	25	struct tiobench_options {
	26	unsigned int pad;
	27	unsigned long long size;
	28	unsigned int loops;
	29	unsigned int bs;
	30	unsigned int nthreads;
	31	char *dir;
	32	};
	33
	34	static struct tiobench_options tiobench_options;
	35
	36	static struct fio_option options[] = {
	37	{
	38	.name = "size",
	39	.lname = "Tiobench size",
	40	.type = FIO_OPT_STR_VAL,
	41	.off1 = offsetof(struct tiobench_options, size),
	42	.help = "Size in MiB",
	43	.category = FIO_OPT_C_PROFILE,
	44	.group = FIO_OPT_G_TIOBENCH,
	45	},
	46	{
	47	.name = "block",
	48	.lname = "Tiobench block",
	49	.type = FIO_OPT_INT,
	50	.off1 = offsetof(struct tiobench_options, bs),
	51	.help = "Block size in bytes",
	52	.def = "4096",
	53	.category = FIO_OPT_C_PROFILE,
	54	.group = FIO_OPT_G_TIOBENCH,
	55	},
	56	{
	57	.name = "numruns",
	58	.lname = "Tiobench numruns",
	59	.type = FIO_OPT_INT,
	60	.off1 = offsetof(struct tiobench_options, loops),
	61	.help = "Number of runs",
	62	.category = FIO_OPT_C_PROFILE,
	63	.group = FIO_OPT_G_TIOBENCH,
	64	},
	65	{
	66	.name = "dir",
	67	.lname = "Tiobench directory",
	68	.type = FIO_OPT_STR_STORE,
	69	.off1 = offsetof(struct tiobench_options, dir),
	70	.help = "Test directory",
	71	.category = FIO_OPT_C_PROFILE,
	72	.group = FIO_OPT_G_TIOBENCH,
	73	.no_free = true,
	74	},
	75	{
	76	.name = "threads",
	77	.lname = "Tiobench threads",
	78	.type = FIO_OPT_INT,
	79	.off1 = offsetof(struct tiobench_options, nthreads),
	80	.help = "Number of Threads",
	81	.category = FIO_OPT_C_PROFILE,
	82	.group = FIO_OPT_G_TIOBENCH,
	83	},
	84	{
	85	.name = NULL,
	86	},
	87	};
	88
	89	/*
	90	* Fill our private options into the command line
	91	*/
	92	static int tb_prep_cmdline(void)
	93	{
	94	/*
	95	* tiobench uses size as MiB, so multiply up
	96	*/
	97	size = 1024 1024ULL;
	98	if (size)
	99	sprintf(sz_idx, "size=%llu", size);
	100	else
	101	strcpy(sz_idx, "size=41024$mb_memory");
	102
	103	sprintf(bs_idx, "bs=%u", bs);
	104	sprintf(loop_idx, "loops=%u", loops);
	105
	106	if (dir)
	107	sprintf(dir_idx, "directory=%s", dir);
	108	else
	109	sprintf(dir_idx, "directory=./");
	110
	111	sprintf(t_idx, "numjobs=%u", nthreads);
	112	return 0;
	113	}
	114
	115	static struct profile_ops tiobench_profile = {
	116	.name = "tiobench",
	117	.desc = "tiotest/tiobench benchmark",
	118	.prep_cmd = tb_prep_cmdline,
	119	.cmdline = tb_opts,
	120	.options = options,
	121	.opt_data = &tiobench_options,
	122	};
	123
	124	static void fio_init tiobench_register(void)
	125	{
	126	if (register_profile(&tiobench_profile))
	127	log_err("fio: failed to register profile 'tiobench'\n");
	128	}
	129
	130	static void fio_exit tiobench_unregister(void)
	131	{
	132	unregister_profile(&tiobench_profile);
	133	}