#include "../fio.h"
#include "../profile.h"
#include "../parse.h"
+#include "../optgroup.h"
/*
* 1x loads
static struct act_run_data *act_run_data;
struct act_prof_data {
- struct timeval sample_tv;
+ struct timespec sample_tv;
struct act_slice *slices;
unsigned int cur_slice;
unsigned int nr_slices;
};
-static char *device_names;
-static unsigned int load;
-static unsigned int prep;
-static unsigned int threads_per_queue;
-static unsigned int num_read_blocks;
-static unsigned int write_size;
-static unsigned long long test_duration;
-
#define ACT_MAX_OPTS 128
static const char *act_opts[ACT_MAX_OPTS] = {
"direct=1",
static int act_add_opt(const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
+struct act_options {
+ unsigned int pad;
+ char *device_names;
+ unsigned int load;
+ unsigned int prep;
+ unsigned int threads_per_queue;
+ unsigned int num_read_blocks;
+ unsigned int write_size;
+ unsigned long long test_duration;
+};
+
+static struct act_options act_options;
+
static struct fio_option options[] = {
{
.name = "device-names",
.lname = "device-names",
.type = FIO_OPT_STR_STORE,
- .roff1 = &device_names,
+ .off1 = offsetof(struct act_options, device_names),
.help = "Devices to use",
.category = FIO_OPT_C_PROFILE,
.group = FIO_OPT_G_ACT,
+ .no_free = true,
},
{
.name = "load",
.lname = "Load multiplier",
.type = FIO_OPT_INT,
- .roff1 = &load,
+ .off1 = offsetof(struct act_options, load),
.help = "ACT load multipler (default 1x)",
.def = "1",
.category = FIO_OPT_C_PROFILE,
.name = "test-duration",
.lname = "Test duration",
.type = FIO_OPT_STR_VAL_TIME,
- .roff1 = &test_duration,
+ .off1 = offsetof(struct act_options, test_duration),
.help = "How long the entire test takes to run",
.def = "24h",
.category = FIO_OPT_C_PROFILE,
.name = "threads-per-queue",
.lname = "Number of read IO threads per device",
.type = FIO_OPT_INT,
- .roff1 = &threads_per_queue,
+ .off1 = offsetof(struct act_options, threads_per_queue),
.help = "Number of read IO threads per device",
.def = "8",
.category = FIO_OPT_C_PROFILE,
},
{
.name = "read-req-num-512-blocks",
- .lname = "Number of 512b blocks to read",
+ .lname = "Number of 512B blocks to read",
.type = FIO_OPT_INT,
- .roff1 = &num_read_blocks,
- .help = "Number of 512b blocks to read at the time",
+ .off1 = offsetof(struct act_options, num_read_blocks),
+ .help = "Number of 512B blocks to read at the time",
.def = "3",
.category = FIO_OPT_C_PROFILE,
.group = FIO_OPT_G_ACT,
},
{
.name = "large-block-op-kbytes",
- .lname = "Size of large block ops (writes)",
+ .lname = "Size of large block ops in KiB (writes)",
.type = FIO_OPT_INT,
- .roff1 = &write_size,
- .help = "Size of large block ops (writes)",
- .def = "128k",
+ .off1 = offsetof(struct act_options, write_size),
+ .help = "Size of large block ops in KiB (writes)",
+ .def = "131072",
.category = FIO_OPT_C_PROFILE,
.group = FIO_OPT_G_ACT,
},
.name = "prep",
.lname = "Run ACT prep phase",
.type = FIO_OPT_STR_SET,
- .roff1 = &prep,
+ .off1 = offsetof(struct act_options, prep),
.help = "Set to run ACT prep phase",
.category = FIO_OPT_C_PROFILE,
.group = FIO_OPT_G_ACT,
static int act_add_rw(const char *dev, int reads)
{
+ struct act_options *ao = &act_options;
+
if (act_add_opt("name=act-%s-%s", reads ? "read" : "write", dev))
return 1;
if (act_add_opt("filename=%s", dev))
if (act_add_opt("rw=%s", reads ? "randread" : "randwrite"))
return 1;
if (reads) {
- int rload = load * R_LOAD / threads_per_queue;
+ int rload = ao->load * R_LOAD / ao->threads_per_queue;
- if (act_add_opt("numjobs=%u", threads_per_queue))
+ if (act_add_opt("numjobs=%u", ao->threads_per_queue))
return 1;
if (act_add_opt("rate_iops=%u", rload))
return 1;
- if (act_add_opt("bs=%u", num_read_blocks * 512))
+ if (act_add_opt("bs=%u", ao->num_read_blocks * 512))
return 1;
} else {
- const int rsize = write_size / (num_read_blocks * 512);
- int wload = (load * W_LOAD + rsize - 1) / rsize;
+ const int rsize = ao->write_size / (ao->num_read_blocks * 512);
+ int wload = (ao->load * W_LOAD + rsize - 1) / rsize;
if (act_add_opt("rate_iops=%u", wload))
return 1;
- if (act_add_opt("bs=%u", write_size))
+ if (act_add_opt("bs=%u", ao->write_size))
return 1;
}
return 1;
if (act_add_opt("filename=%s", dev))
return 1;
- if (act_add_opt("bs=1M"))
+ if (act_add_opt("bs=1048576"))
return 1;
if (act_add_opt("zero_buffers"))
return 1;
return 1;
if (act_add_opt("filename=%s", dev))
return 1;
- if (act_add_opt("bs=4k"))
+ if (act_add_opt("bs=4096"))
return 1;
if (act_add_opt("ioengine=libaio"))
return 1;
static int act_add_dev(const char *dev)
{
- if (prep)
+ if (act_options.prep)
return act_add_dev_prep(dev);
- if (act_add_opt("runtime=%llus", test_duration))
+ if (act_add_opt("runtime=%llus", act_options.test_duration))
return 1;
if (act_add_opt("time_based=1"))
return 1;
*/
static int act_prep_cmdline(void)
{
- if (!device_names) {
+ if (!act_options.device_names) {
log_err("act: you need to set IO target(s) with the "
"device-names option.\n");
return 1;
do {
char *dev;
- dev = strsep(&device_names, ",");
+ dev = strsep(&act_options.device_names, ",");
if (!dev)
break;
int i, ret = 0;
double perm;
- if (prep)
+ if (act_options.prep)
return 0;
/*
fio_mutex_down(act_run_data->mutex);
if (!act_run_data->slices) {
- act_run_data->slices = calloc(sizeof(struct act_slice), apd->nr_slices);
+ act_run_data->slices = calloc(apd->nr_slices, sizeof(struct act_slice));
act_run_data->nr_slices = apd->nr_slices;
}
get_act_ref();
- apd = calloc(sizeof(*apd), 1);
- nr_slices = (test_duration + SAMPLE_SEC - 1) / SAMPLE_SEC;
- apd->slices = calloc(sizeof(struct act_slice), nr_slices);
+ apd = calloc(1, sizeof(*apd));
+ nr_slices = (act_options.test_duration + SAMPLE_SEC - 1) / SAMPLE_SEC;
+ apd->slices = calloc(nr_slices, sizeof(struct act_slice));
apd->nr_slices = nr_slices;
fio_gettime(&apd->sample_tv, NULL);
td->prof_data = apd;
.name = "act",
.desc = "ACT Aerospike like benchmark",
.options = options,
+ .opt_data = &act_options,
.prep_cmd = act_prep_cmdline,
.cmdline = act_opts,
.io_ops = &act_io_ops,
static void fio_init act_register(void)
{
- act_run_data = calloc(sizeof(*act_run_data), 1);
+ act_run_data = calloc(1, sizeof(*act_run_data));
act_run_data->mutex = fio_mutex_init(FIO_MUTEX_UNLOCKED);
if (register_profile(&act_profile))