},
};
-struct act_prof_data {
- struct timeval sample_tv;
+struct act_slice {
uint64_t lat_buckets[ACT_MAX_CRIT];
uint64_t total_ios;
};
+struct act_run_data {
+ struct fio_mutex *mutex;
+ unsigned int pending;
+
+ struct act_slice *slices;
+ unsigned int nr_slices;
+};
+static struct act_run_data *act_run_data;
+
+struct act_prof_data {
+ struct timeval sample_tv;
+ struct act_slice *slices;
+ unsigned int cur_slice;
+ unsigned int nr_slices;
+};
+
static char *device_names;
-static unsigned int load = 1;
+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] = {
"ioengine=sync",
"random_generator=lfsr",
"group_reporting=1",
+ "thread",
NULL,
};
-static unsigned int opt_idx = 4;
+static unsigned int opt_idx = 5;
static unsigned int org_idx;
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,
.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,
.group = FIO_OPT_G_ACT,
},
+ {
+ .name = "test-duration",
+ .lname = "Test duration",
+ .type = FIO_OPT_STR_VAL_TIME,
+ .off1 = offsetof(struct act_options, test_duration),
+ .help = "How long the entire test takes to run",
+ .def = "24h",
+ .category = FIO_OPT_C_PROFILE,
+ .group = FIO_OPT_G_ACT,
+ },
{
.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",
.type = FIO_OPT_INT,
- .roff1 = &num_read_blocks,
+ .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,
.name = "large-block-op-kbytes",
.lname = "Size of large block ops (writes)",
.type = FIO_OPT_INT,
- .roff1 = &write_size,
+ .off1 = offsetof(struct act_options, write_size),
.help = "Size of large block ops (writes)",
.def = "128k",
.category = FIO_OPT_C_PROFILE,
.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,
if (prep)
return act_add_dev_prep(dev);
- if (act_add_opt("runtime=24h"))
+ if (act_add_opt("runtime=%llus", test_duration))
return 1;
if (act_add_opt("time_based=1"))
return 1;
static int act_prep_cmdline(void)
{
if (!device_names) {
- log_err("act: need device-names\n");
+ log_err("act: you need to set IO target(s) with the "
+ "device-names option.\n");
return 1;
}
static int act_io_u_lat(struct thread_data *td, uint64_t usec)
{
struct act_prof_data *apd = td->prof_data;
+ struct act_slice *slice;
int i, ret = 0;
double perm;
if (prep)
return 0;
- apd->total_ios++;
+ /*
+ * Really should not happen, but lets not let jitter at the end
+ * ruin our day.
+ */
+ if (apd->cur_slice >= apd->nr_slices)
+ return 0;
+
+ slice = &apd->slices[apd->cur_slice];
+ slice->total_ios++;
for (i = ACT_MAX_CRIT - 1; i >= 0; i--) {
if (usec > act_pass[i].max_usec) {
- apd->lat_buckets[i]++;
+ slice->lat_buckets[i]++;
break;
}
}
/* SAMPLE_SEC has passed, check criteria for pass */
for (i = 0; i < ACT_MAX_CRIT; i++) {
- perm = (1000.0 * apd->lat_buckets[i]) / apd->total_ios;
+ perm = (1000.0 * slice->lat_buckets[i]) / slice->total_ios;
if (perm < act_pass[i].max_perm)
continue;
break;
}
- memset(apd->lat_buckets, 0, sizeof(apd->lat_buckets));
- apd->total_ios = 0;
-
fio_gettime(&apd->sample_tv, NULL);
+ apd->cur_slice++;
return ret;
}
+static void get_act_ref(void)
+{
+ fio_mutex_down(act_run_data->mutex);
+ act_run_data->pending++;
+ fio_mutex_up(act_run_data->mutex);
+}
+
+static int show_slice(struct act_slice *slice, unsigned int slice_num)
+{
+ unsigned int i, failed = 0;
+
+ log_info(" %2u", slice_num);
+
+ for (i = 0; i < ACT_MAX_CRIT; i++) {
+ double perc = 0.0;
+
+ if (slice->total_ios)
+ perc = 100.0 * (double) slice->lat_buckets[i] / (double) slice->total_ios;
+ if ((perc * 10.0) >= act_pass[i].max_perm)
+ failed++;
+ log_info("\t%2.2f", perc);
+ }
+ for (i = 0; i < ACT_MAX_CRIT; i++) {
+ double perc = 0.0;
+
+ if (slice->total_ios)
+ perc = 100.0 * (double) slice->lat_buckets[i] / (double) slice->total_ios;
+ log_info("\t%2.2f", perc);
+ }
+ log_info("\n");
+
+ return failed;
+}
+
+static void act_show_all_stats(void)
+{
+ unsigned int i, fails = 0;
+
+ log_info(" trans device\n");
+ log_info(" %%>(ms) %%>(ms)\n");
+ log_info(" slice");
+
+ for (i = 0; i < ACT_MAX_CRIT; i++)
+ log_info("\t %2u", act_pass[i].max_usec / 1000);
+ for (i = 0; i < ACT_MAX_CRIT; i++)
+ log_info("\t %2u", act_pass[i].max_usec / 1000);
+
+ log_info("\n");
+ log_info(" ----- ----- ----- ------ ----- ----- ------\n");
+
+ for (i = 0; i < act_run_data->nr_slices; i++)
+ fails += show_slice(&act_run_data->slices[i], i + 1);
+
+ log_info("\nact: test complete, device(s): %s\n", fails ? "FAILED" : "PASSED");
+}
+
+static void put_act_ref(struct thread_data *td)
+{
+ struct act_prof_data *apd = td->prof_data;
+ unsigned int i, slice;
+
+ fio_mutex_down(act_run_data->mutex);
+
+ if (!act_run_data->slices) {
+ act_run_data->slices = calloc(apd->nr_slices, sizeof(struct act_slice));
+ act_run_data->nr_slices = apd->nr_slices;
+ }
+
+ for (slice = 0; slice < apd->nr_slices; slice++) {
+ struct act_slice *dst = &act_run_data->slices[slice];
+ struct act_slice *src = &apd->slices[slice];
+
+ dst->total_ios += src->total_ios;
+
+ for (i = 0; i < ACT_MAX_CRIT; i++)
+ dst->lat_buckets[i] += src->lat_buckets[i];
+ }
+
+ if (!--act_run_data->pending)
+ act_show_all_stats();
+
+ fio_mutex_up(act_run_data->mutex);
+}
+
static int act_td_init(struct thread_data *td)
{
struct act_prof_data *apd;
+ unsigned int nr_slices;
+
+ get_act_ref();
- apd = calloc(sizeof(*apd), 1);
+ apd = calloc(1, sizeof(*apd));
+ nr_slices = (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;
return 0;
static void act_td_exit(struct thread_data *td)
{
- free(td->prof_data);
+ struct act_prof_data *apd = td->prof_data;
+
+ put_act_ref(td);
+ free(apd->slices);
+ free(apd);
td->prof_data = NULL;
}
.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(1, sizeof(*act_run_data));
+ act_run_data->mutex = fio_mutex_init(FIO_MUTEX_UNLOCKED);
+
if (register_profile(&act_profile))
log_err("fio: failed to register profile 'act'\n");
}
free((void *) act_opts[++org_idx]);
unregister_profile(&act_profile);
+ fio_mutex_remove(act_run_data->mutex);
+ free(act_run_data->slices);
+ free(act_run_data);
+ act_run_data = NULL;
}