void
pmem_memset_constructor(void)
{
memset_clo[0].opt_short = 'M';
memset_clo[0].opt_long = "mem-mode";
memset_clo[0].descr = "Memory writing mode - "
"stat, seq, rand";
memset_clo[0].def = "seq";
memset_clo[0].off = clo_field_offset(struct memset_args, mode);
memset_clo[0].type = CLO_TYPE_STR;
memset_clo[1].opt_short = 'm';
memset_clo[1].opt_long = "memset";
memset_clo[1].descr = "Use libc memset()";
memset_clo[1].def = "false";
memset_clo[1].off = clo_field_offset(struct memset_args, memset);
memset_clo[1].type = CLO_TYPE_FLAG;
memset_clo[2].opt_short = 'p';
memset_clo[2].opt_long = "persist";
memset_clo[2].descr = "Use pmem_persist()";
memset_clo[2].def = "true";
memset_clo[2].off = clo_field_offset(struct memset_args, persist);
memset_clo[2].type = CLO_TYPE_FLAG;
memset_clo[3].opt_short = 'D';
memset_clo[3].opt_long = "dest-offset";
memset_clo[3].descr = "Destination cache line alignment "
"offset";
memset_clo[3].def = "0";
memset_clo[3].off = clo_field_offset(struct memset_args, dest_off);
memset_clo[3].type = CLO_TYPE_UINT;
memset_clo[3].type_uint.size =
clo_field_size(struct memset_args, dest_off);
memset_clo[3].type_uint.base = CLO_INT_BASE_DEC;
memset_clo[3].type_uint.min = 0;
memset_clo[3].type_uint.max = MAX_OFFSET;
memset_clo[4].opt_short = 'w';
memset_clo[4].opt_long = "no-warmup";
memset_clo[4].descr = "Don't do warmup";
memset_clo[4].def = "false";
memset_clo[4].type = CLO_TYPE_FLAG;
memset_clo[4].off = clo_field_offset(struct memset_args, no_warmup);
memset_clo[5].opt_short = 'S';
memset_clo[5].opt_long = "seed";
memset_clo[5].descr = "seed for random numbers";
memset_clo[5].def = "1";
memset_clo[5].off = clo_field_offset(struct memset_args, seed);
memset_clo[5].type = CLO_TYPE_UINT;
memset_clo[5].type_uint.size = clo_field_size(struct memset_args, seed);
memset_clo[5].type_uint.base = CLO_INT_BASE_DEC;
memset_clo[5].type_uint.min = 1;
memset_clo[5].type_uint.max = UINT_MAX;
memset_clo[6].opt_short = 's';
memset_clo[6].opt_long = "msync";
memset_clo[6].descr = "Use pmem_msync()";
memset_clo[6].def = "false";
memset_clo[6].off = clo_field_offset(struct memset_args, msync);
memset_clo[6].type = CLO_TYPE_FLAG;
memset_info.name = "pmem_memset";
memset_info.brief = "Benchmark for pmem_memset_persist() "
"and pmem_memset_nodrain() operations";
memset_info.init = memset_init;
memset_info.exit = memset_exit;
memset_info.multithread = true;
memset_info.multiops = true;
memset_info.operation = memset_op;
memset_info.measure_time = true;
memset_info.clos = memset_clo;
memset_info.nclos = ARRAY_SIZE(memset_clo);
memset_info.opts_size = sizeof(struct memset_args);
memset_info.rm_file = true;
memset_info.allow_poolset = false;
memset_info.print_bandwidth = true;
REGISTER_BENCHMARK(memset_info);
};
void
blk_costructor(void)
{
blk_clo[0].opt_short = 'i';
blk_clo[0].opt_long = "file-io";
blk_clo[0].descr = "File I/O mode";
blk_clo[0].type = CLO_TYPE_FLAG;
blk_clo[0].off = clo_field_offset(struct blk_args, file_io);
blk_clo[0].def = "false";
blk_clo[1].opt_short = 'w';
blk_clo[1].opt_long = "no-warmup";
blk_clo[1].descr = "Don't do warmup";
blk_clo[1].type = CLO_TYPE_FLAG;
blk_clo[1].off = clo_field_offset(struct blk_args, no_warmup);
blk_clo[2].opt_short = 'r';
blk_clo[2].opt_long = "random";
blk_clo[2].descr = "Use random block numbers "
"for write/read";
blk_clo[2].off = clo_field_offset(struct blk_args, rand);
blk_clo[2].type = CLO_TYPE_FLAG;
blk_clo[3].opt_short = 'S';
blk_clo[3].opt_long = "seed";
blk_clo[3].descr = "Random mode";
blk_clo[3].off = clo_field_offset(struct blk_args, seed);
blk_clo[3].def = "1";
blk_clo[3].type = CLO_TYPE_UINT;
blk_clo[3].type_uint.size = clo_field_size(struct blk_args, seed);
blk_clo[3].type_uint.base = CLO_INT_BASE_DEC;
blk_clo[3].type_uint.min = 1;
blk_clo[3].type_uint.max = UINT_MAX;
blk_clo[4].opt_short = 's';
blk_clo[4].opt_long = "file-size";
blk_clo[4].descr = "File size in bytes - 0 means "
"minimum";
blk_clo[4].type = CLO_TYPE_UINT;
blk_clo[4].off = clo_field_offset(struct blk_args, fsize);
blk_clo[4].def = "0";
blk_clo[4].type_uint.size = clo_field_size(struct blk_args, fsize);
blk_clo[4].type_uint.base = CLO_INT_BASE_DEC;
blk_clo[4].type_uint.min = 0;
blk_clo[4].type_uint.max = ~0;
blk_read_info.name = "blk_read";
blk_read_info.brief = "Benchmark for blk_read() operation";
blk_read_info.init = blk_read_init;
blk_read_info.exit = blk_exit;
blk_read_info.multithread = true;
blk_read_info.multiops = true;
blk_read_info.init_worker = blk_init_worker;
blk_read_info.free_worker = blk_free_worker;
blk_read_info.operation = blk_operation;
blk_read_info.clos = blk_clo;
blk_read_info.nclos = ARRAY_SIZE(blk_clo);
blk_read_info.opts_size = sizeof(struct blk_args);
blk_read_info.rm_file = true;
blk_read_info.allow_poolset = true;
REGISTER_BENCHMARK(blk_read_info);
blk_write_info.name = "blk_write";
blk_write_info.brief = "Benchmark for blk_write() operation";
blk_write_info.init = blk_write_init;
blk_write_info.exit = blk_exit;
blk_write_info.multithread = true;
blk_write_info.multiops = true;
blk_write_info.init_worker = blk_init_worker;
blk_write_info.free_worker = blk_free_worker;
blk_write_info.operation = blk_operation;
blk_write_info.clos = blk_clo;
blk_write_info.nclos = ARRAY_SIZE(blk_clo);
blk_write_info.opts_size = sizeof(struct blk_args);
blk_write_info.rm_file = true;
blk_write_info.allow_poolset = true;
REGISTER_BENCHMARK(blk_write_info);
}
void
pmemobj_gen_constructor(void)
{
pobj_direct_clo[0].opt_short = 'T';
pobj_direct_clo[0].opt_long = "type-number";
pobj_direct_clo[0].descr = "Type number mode - one, per-thread, "
"rand";
pobj_direct_clo[0].def = "one";
pobj_direct_clo[0].off = clo_field_offset(struct pobj_args, type_num);
pobj_direct_clo[0].type = CLO_TYPE_STR;
pobj_direct_clo[1].opt_short = 'm';
pobj_direct_clo[1].opt_long = "min-size";
pobj_direct_clo[1].type = CLO_TYPE_UINT;
pobj_direct_clo[1].descr = "Minimum allocation size";
pobj_direct_clo[1].off = clo_field_offset(struct pobj_args, min_size);
pobj_direct_clo[1].def = "0";
pobj_direct_clo[1].type_uint.size =
clo_field_size(struct pobj_args, min_size);
pobj_direct_clo[1].type_uint.base = CLO_INT_BASE_DEC | CLO_INT_BASE_HEX;
pobj_direct_clo[1].type_uint.min = 0;
pobj_direct_clo[1].type_uint.max = UINT_MAX;
pobj_direct_clo[2].opt_short = 'P';
pobj_direct_clo[2].opt_long = "one-pool";
pobj_direct_clo[2].descr = "Create one pool for all threads";
pobj_direct_clo[2].type = CLO_TYPE_FLAG;
pobj_direct_clo[2].off = clo_field_offset(struct pobj_args, one_pool);
pobj_direct_clo[3].opt_short = 'O';
pobj_direct_clo[3].opt_long = "one-object";
pobj_direct_clo[3].descr = "Use only one object per thread";
pobj_direct_clo[3].type = CLO_TYPE_FLAG;
pobj_direct_clo[3].off = clo_field_offset(struct pobj_args, one_obj);
pobj_open_clo[0].opt_short = 'T',
pobj_open_clo[0].opt_long = "type-number",
pobj_open_clo[0].descr = "Type number mode - one, "
"per-thread, rand",
pobj_open_clo[0].def = "one",
pobj_open_clo[0].off = clo_field_offset(struct pobj_args, type_num),
pobj_open_clo[0].type = CLO_TYPE_STR,
pobj_open_clo[1].opt_short = 'm',
pobj_open_clo[1].opt_long = "min-size",
pobj_open_clo[1].type = CLO_TYPE_UINT,
pobj_open_clo[1].descr = "Minimum allocation size",
pobj_open_clo[1].off = clo_field_offset(struct pobj_args, min_size),
pobj_open_clo[1].def = "0",
pobj_open_clo[1].type_uint.size =
clo_field_size(struct pobj_args, min_size),
pobj_open_clo[1].type_uint.base = CLO_INT_BASE_DEC | CLO_INT_BASE_HEX,
pobj_open_clo[1].type_uint.min = 0,
pobj_open_clo[1].type_uint.max = UINT_MAX,
pobj_open_clo[2].opt_short = 'o';
pobj_open_clo[2].opt_long = "objects";
pobj_open_clo[2].type = CLO_TYPE_UINT;
pobj_open_clo[2].descr = "Number of objects in each pool";
pobj_open_clo[2].off = clo_field_offset(struct pobj_args, n_objs);
pobj_open_clo[2].def = "1";
pobj_open_clo[2].type_uint.size =
clo_field_size(struct pobj_args, n_objs);
pobj_open_clo[2].type_uint.base = CLO_INT_BASE_DEC | CLO_INT_BASE_HEX;
pobj_open_clo[2].type_uint.min = 1;
pobj_open_clo[2].type_uint.max = UINT_MAX;
obj_open.name = "obj_open";
obj_open.brief = "pmemobj_open() benchmark";
obj_open.init = pobj_init;
obj_open.exit = pobj_exit;
obj_open.multithread = true;
obj_open.multiops = true;
obj_open.init_worker = pobj_init_worker;
obj_open.free_worker = pobj_free_worker;
obj_open.operation = pobj_open_op;
obj_open.measure_time = true;
obj_open.clos = pobj_open_clo;
obj_open.nclos = ARRAY_SIZE(pobj_open_clo);
obj_open.opts_size = sizeof(struct pobj_args);
obj_open.rm_file = true;
obj_open.allow_poolset = true;
REGISTER_BENCHMARK(obj_open);
obj_direct.name = "obj_direct";
obj_direct.brief = "pmemobj_direct() benchmark";
obj_direct.init = pobj_direct_init;
obj_direct.exit = pobj_exit;
obj_direct.multithread = true;
obj_direct.multiops = true;
obj_direct.init_worker = pobj_init_worker;
obj_direct.free_worker = pobj_free_worker;
obj_direct.operation = pobj_direct_op;
obj_direct.measure_time = true;
obj_direct.clos = pobj_direct_clo;
obj_direct.nclos = ARRAY_SIZE(pobj_direct_clo);
obj_direct.opts_size = sizeof(struct pobj_args);
obj_direct.rm_file = true;
obj_direct.allow_poolset = true;
REGISTER_BENCHMARK(obj_direct);
};
void
log_costructor(void)
{
log_clo[0].opt_short = 'r';
log_clo[0].opt_long = "random";
log_clo[0].descr = "Use random sizes for append/read";
log_clo[0].off = clo_field_offset(struct prog_args, rand);
log_clo[0].type = CLO_TYPE_FLAG;
log_clo[1].opt_short = 'S';
log_clo[1].opt_long = "seed";
log_clo[1].descr = "Random mode";
log_clo[1].off = clo_field_offset(struct prog_args, seed);
log_clo[1].def = "1";
log_clo[1].type = CLO_TYPE_UINT;
log_clo[1].type_uint.size = clo_field_size(struct prog_args, seed);
log_clo[1].type_uint.base = CLO_INT_BASE_DEC;
log_clo[1].type_uint.min = 1;
log_clo[1].type_uint.max = UINT_MAX;
log_clo[2].opt_short = 'i';
log_clo[2].opt_long = "file-io";
log_clo[2].descr = "File I/O mode";
log_clo[2].off = clo_field_offset(struct prog_args, fileio);
log_clo[2].type = CLO_TYPE_FLAG;
log_clo[3].opt_short = 'w';
log_clo[3].opt_long = "no-warmup";
log_clo[3].descr = "Don't do warmup", log_clo[3].type = CLO_TYPE_FLAG;
log_clo[3].off = clo_field_offset(struct prog_args, no_warmup);
log_clo[4].opt_short = 'm';
log_clo[4].opt_long = "min-size";
log_clo[4].descr = "Minimum size of append/read for "
"random mode";
log_clo[4].type = CLO_TYPE_UINT;
log_clo[4].off = clo_field_offset(struct prog_args, min_size);
log_clo[4].def = "1";
log_clo[4].type_uint.size = clo_field_size(struct prog_args, min_size);
log_clo[4].type_uint.base = CLO_INT_BASE_DEC;
log_clo[4].type_uint.min = 1;
log_clo[4].type_uint.max = UINT64_MAX;
/* this one is only for log_append */
log_clo[5].opt_short = 'v';
log_clo[5].opt_long = "vector";
log_clo[5].descr = "Vector size";
log_clo[5].off = clo_field_offset(struct prog_args, vec_size);
log_clo[5].def = "1";
log_clo[5].type = CLO_TYPE_INT;
log_clo[5].type_int.size = clo_field_size(struct prog_args, vec_size);
log_clo[5].type_int.base = CLO_INT_BASE_DEC;
log_clo[5].type_int.min = MIN_VEC_SIZE;
log_clo[5].type_int.max = INT_MAX;
log_append_info.name = "log_append";
log_append_info.brief = "Benchmark for pmemlog_append() "
"operation";
log_append_info.init = log_init;
log_append_info.exit = log_exit;
log_append_info.multithread = true;
log_append_info.multiops = true;
log_append_info.init_worker = log_init_worker;
log_append_info.free_worker = log_free_worker;
/* this will be assigned in log_init */
log_append_info.operation = NULL;
log_append_info.measure_time = true;
log_append_info.clos = log_clo;
log_append_info.nclos = ARRAY_SIZE(log_clo);
log_append_info.opts_size = sizeof(struct prog_args);
log_append_info.rm_file = true;
log_append_info.allow_poolset = true;
REGISTER_BENCHMARK(log_append_info);
log_read_info.name = "log_read";
log_read_info.brief = "Benchmark for pmemlog_walk() "
"operation";
log_read_info.init = log_init;
log_read_info.exit = log_exit;
log_read_info.multithread = true;
log_read_info.multiops = true;
log_read_info.init_worker = log_init_worker;
log_read_info.free_worker = log_free_worker;
log_read_info.operation = log_read_op;
log_read_info.measure_time = true;
log_read_info.clos = log_clo;
/* without vector */
log_read_info.nclos = ARRAY_SIZE(log_clo) - 1;
log_read_info.opts_size = sizeof(struct prog_args);
log_read_info.rm_file = true;
log_read_info.allow_poolset = true;
REGISTER_BENCHMARK(log_read_info);
};
