From: Jens Axboe Date: Thu, 31 Jan 2013 12:23:40 +0000 (+0100) Subject: Merge branch 'master' into gfio X-Git-Tag: fio-2.1~57^2~26 X-Git-Url: https://git.kernel.dk/?p=fio.git;a=commitdiff_plain;h=95820b6e6c92025df8d89c0bf39b174e53137c41 Merge branch 'master' into gfio Conflicts: Makefile client.c configure fio.c fio.h server.c server.h Signed-off-by: Jens Axboe --- 95820b6e6c92025df8d89c0bf39b174e53137c41 diff --cc Makefile index 038eacf1,a4a478d9..0e79720b --- a/Makefile +++ b/Makefile @@@ -31,9 -27,9 +31,9 @@@ SOURCE := gettime.c ioengines.c init.c lib/num2str.c lib/ieee754.c $(wildcard crc/*.c) engines/cpu.c \ engines/mmap.c engines/sync.c engines/null.c engines/net.c \ memalign.c server.c client.c iolog.c backend.c libfio.c flow.c \ - json.c lib/zipf.c lib/axmap.c lib/lfsr.c gettime-thread.c \ - helpers.c lib/flist_sort.c lib/hweight.c lib/getrusage.c \ - idletime.c + cconv.c lib/prio_tree.c json.c lib/zipf.c lib/axmap.c \ + lib/lfsr.c gettime-thread.c helpers.c lib/flist_sort.c \ - lib/hweight.c lib/getrusage.c ++ lib/hweight.c lib/getrusage.c idletime.c ifdef CONFIG_64BIT_LLP64 CFLAGS += -DBITS_PER_LONG=32 diff --cc backend.c index 9aa2a285,218ae254..49d6bc7c --- a/backend.c +++ b/backend.c @@@ -1506,8 -1495,13 +1507,10 @@@ static void run_threads(void unsigned long spent; unsigned int i, todo, nr_running, m_rate, t_rate, nr_started; - if (fio_pin_memory()) - return; - if (fio_gtod_offload && fio_start_gtod_thread()) return; + + fio_idle_prof_init(); set_sig_handlers(); @@@ -1724,10 -1717,17 +1730,12 @@@ while (nr_running) { reap_threads(&nr_running, &t_rate, &m_rate); - - if (is_backend) - fio_server_idle_loop(); - else - usleep(10000); + usleep(10000); } + fio_idle_prof_stop(); + update_io_ticks(); - fio_unpin_memory(); } void wait_for_disk_thread_exit(void) diff --cc cconv.c index e7339d04,00000000..3a8572ec mode 100644,000000..100644 --- a/cconv.c +++ b/cconv.c @@@ -1,416 -1,0 +1,418 @@@ +#include + +#include "thread_options.h" + +static void string_to_cpu(char **dst, const uint8_t *src) +{ + const char *__src = (const char *) src; + + if (strlen(__src)) + *dst = strdup(__src); +} + +static void string_to_net(uint8_t *dst, const char *src) +{ + if (src) + strcpy((char *) dst, src); + else + dst[0] = '\0'; +} + +void convert_thread_options_to_cpu(struct thread_options *o, + struct thread_options_pack *top) +{ + int i, j; + + string_to_cpu(&o->description, top->description); + string_to_cpu(&o->name, top->name); + string_to_cpu(&o->directory, top->directory); + string_to_cpu(&o->filename, top->filename); + string_to_cpu(&o->opendir, top->opendir); + string_to_cpu(&o->ioengine, top->ioengine); + string_to_cpu(&o->mmapfile, top->mmapfile); + string_to_cpu(&o->read_iolog_file, top->read_iolog_file); + string_to_cpu(&o->write_iolog_file, top->write_iolog_file); + string_to_cpu(&o->bw_log_file, top->bw_log_file); + string_to_cpu(&o->lat_log_file, top->lat_log_file); + string_to_cpu(&o->iops_log_file, top->iops_log_file); + string_to_cpu(&o->replay_redirect, top->replay_redirect); + string_to_cpu(&o->exec_prerun, top->exec_prerun); + string_to_cpu(&o->exec_postrun, top->exec_postrun); + string_to_cpu(&o->ioscheduler, top->ioscheduler); + string_to_cpu(&o->profile, top->profile); + string_to_cpu(&o->cgroup, top->cgroup); + + o->td_ddir = le32_to_cpu(top->td_ddir); + o->rw_seq = le32_to_cpu(top->rw_seq); + o->kb_base = le32_to_cpu(top->kb_base); + o->ddir_seq_nr = le32_to_cpu(top->ddir_seq_nr); + o->ddir_seq_add = le64_to_cpu(top->ddir_seq_add); + o->iodepth = le32_to_cpu(top->iodepth); + o->iodepth_low = le32_to_cpu(top->iodepth_low); + o->iodepth_batch = le32_to_cpu(top->iodepth_batch); + o->iodepth_batch_complete = le32_to_cpu(top->iodepth_batch_complete); + o->size = le64_to_cpu(top->size); + o->size_percent = le32_to_cpu(top->size_percent); + o->fill_device = le32_to_cpu(top->fill_device); + o->file_size_low = le64_to_cpu(top->file_size_low); + o->file_size_high = le64_to_cpu(top->file_size_high); + o->start_offset = le64_to_cpu(top->start_offset); + + for (i = 0; i < DDIR_RWDIR_CNT; i++) { + o->bs[i] = le32_to_cpu(top->bs[i]); + o->ba[i] = le32_to_cpu(top->ba[i]); + o->min_bs[i] = le32_to_cpu(top->min_bs[i]); + o->max_bs[i] = le32_to_cpu(top->max_bs[i]); + o->bssplit_nr[i] = le32_to_cpu(top->bssplit_nr[i]); + + if (o->bssplit_nr[i]) { + o->bssplit[i] = malloc(o->bssplit_nr[i] * sizeof(struct bssplit)); + for (j = 0; j < o->bssplit_nr[i]; j++) { + o->bssplit[i][j].bs = le32_to_cpu(top->bssplit[i][j].bs); + o->bssplit[i][j].perc = le32_to_cpu(top->bssplit[i][j].perc); + } + } + + o->rwmix[i] = le32_to_cpu(top->rwmix[i]); + o->rate[i] = le32_to_cpu(top->rate[i]); + o->ratemin[i] = le32_to_cpu(top->ratemin[i]); + o->rate_iops[i] = le32_to_cpu(top->rate_iops[i]); + o->rate_iops_min[i] = le32_to_cpu(top->rate_iops_min[i]); + } + + o->ratecycle = le32_to_cpu(top->ratecycle); + o->nr_files = le32_to_cpu(top->nr_files); + o->open_files = le32_to_cpu(top->open_files); + o->file_lock_mode = le32_to_cpu(top->file_lock_mode); + o->lockfile_batch = le32_to_cpu(top->lockfile_batch); + o->odirect = le32_to_cpu(top->odirect); + o->invalidate_cache = le32_to_cpu(top->invalidate_cache); + o->create_serialize = le32_to_cpu(top->create_serialize); + o->create_fsync = le32_to_cpu(top->create_fsync); + o->create_on_open = le32_to_cpu(top->create_on_open); + o->create_only = le32_to_cpu(top->create_only); + o->end_fsync = le32_to_cpu(top->end_fsync); + o->pre_read = le32_to_cpu(top->pre_read); + o->sync_io = le32_to_cpu(top->sync_io); + o->verify = le32_to_cpu(top->verify); + o->do_verify = le32_to_cpu(top->do_verify); + o->verifysort = le32_to_cpu(top->verifysort); + o->verifysort_nr = le32_to_cpu(top->verifysort_nr); + o->experimental_verify = le32_to_cpu(top->experimental_verify); + o->verify_interval = le32_to_cpu(top->verify_interval); + o->verify_offset = le32_to_cpu(top->verify_offset); + + memcpy(o->verify_pattern, top->verify_pattern, MAX_PATTERN_SIZE); + + o->verify_pattern_bytes = le32_to_cpu(top->verify_pattern_bytes); + o->verify_fatal = le32_to_cpu(top->verify_fatal); + o->verify_dump = le32_to_cpu(top->verify_dump); + o->verify_async = le32_to_cpu(top->verify_async); + o->verify_batch = le32_to_cpu(top->verify_batch); + o->use_thread = le32_to_cpu(top->use_thread); + o->unlink = le32_to_cpu(top->unlink); + o->do_disk_util = le32_to_cpu(top->do_disk_util); + o->override_sync = le32_to_cpu(top->override_sync); + o->rand_repeatable = le32_to_cpu(top->rand_repeatable); + o->use_os_rand = le32_to_cpu(top->use_os_rand); + o->log_avg_msec = le32_to_cpu(top->log_avg_msec); + o->norandommap = le32_to_cpu(top->norandommap); + o->softrandommap = le32_to_cpu(top->softrandommap); + o->bs_unaligned = le32_to_cpu(top->bs_unaligned); + o->fsync_on_close = le32_to_cpu(top->fsync_on_close); + o->random_distribution = le32_to_cpu(top->random_distribution); + o->zipf_theta.u.f = fio_uint64_to_double(le64_to_cpu(top->zipf_theta.u.i)); + o->pareto_h.u.f = fio_uint64_to_double(le64_to_cpu(top->pareto_h.u.i)); + o->random_generator = le32_to_cpu(top->random_generator); + o->hugepage_size = le32_to_cpu(top->hugepage_size); + o->rw_min_bs = le32_to_cpu(top->rw_min_bs); + o->thinktime = le32_to_cpu(top->thinktime); + o->thinktime_spin = le32_to_cpu(top->thinktime_spin); + o->thinktime_blocks = le32_to_cpu(top->thinktime_blocks); + o->fsync_blocks = le32_to_cpu(top->fsync_blocks); + o->fdatasync_blocks = le32_to_cpu(top->fdatasync_blocks); + o->barrier_blocks = le32_to_cpu(top->barrier_blocks); + + o->verify_backlog = le64_to_cpu(top->verify_backlog); + o->start_delay = le64_to_cpu(top->start_delay); + o->timeout = le64_to_cpu(top->timeout); + o->ramp_time = le64_to_cpu(top->ramp_time); + o->zone_range = le64_to_cpu(top->zone_range); + o->zone_size = le64_to_cpu(top->zone_size); + o->zone_skip = le64_to_cpu(top->zone_skip); + o->lockmem = le64_to_cpu(top->lockmem); + o->offset_increment = le64_to_cpu(top->offset_increment); + + o->overwrite = le32_to_cpu(top->overwrite); + o->bw_avg_time = le32_to_cpu(top->bw_avg_time); + o->iops_avg_time = le32_to_cpu(top->iops_avg_time); + o->loops = le32_to_cpu(top->loops); + o->mem_type = le32_to_cpu(top->mem_type); + o->mem_align = le32_to_cpu(top->mem_align); + o->max_latency = le32_to_cpu(top->max_latency); + o->stonewall = le32_to_cpu(top->stonewall); + o->new_group = le32_to_cpu(top->new_group); + o->numjobs = le32_to_cpu(top->numjobs); + o->cpumask_set = le32_to_cpu(top->cpumask_set); + o->verify_cpumask_set = le32_to_cpu(top->verify_cpumask_set); + o->iolog = le32_to_cpu(top->iolog); + o->rwmixcycle = le32_to_cpu(top->rwmixcycle); + o->nice = le32_to_cpu(top->nice); + o->ioprio = le32_to_cpu(top->ioprio); + o->ioprio_class = le32_to_cpu(top->ioprio_class); + o->file_service_type = le32_to_cpu(top->file_service_type); + o->group_reporting = le32_to_cpu(top->group_reporting); + o->fadvise_hint = le32_to_cpu(top->fadvise_hint); + o->fallocate_mode = le32_to_cpu(top->fallocate_mode); + o->zero_buffers = le32_to_cpu(top->zero_buffers); + o->refill_buffers = le32_to_cpu(top->refill_buffers); + o->scramble_buffers = le32_to_cpu(top->scramble_buffers); + o->time_based = le32_to_cpu(top->time_based); + o->disable_lat = le32_to_cpu(top->disable_lat); + o->disable_clat = le32_to_cpu(top->disable_clat); + o->disable_slat = le32_to_cpu(top->disable_slat); + o->disable_bw = le32_to_cpu(top->disable_bw); ++ o->unified_rw_rep = le32_to_cpu(top->unified_rw_rep); + o->gtod_reduce = le32_to_cpu(top->gtod_reduce); + o->gtod_cpu = le32_to_cpu(top->gtod_cpu); + o->gtod_offload = le32_to_cpu(top->gtod_offload); + o->clocksource = le32_to_cpu(top->clocksource); + o->no_stall = le32_to_cpu(top->no_stall); + o->trim_percentage = le32_to_cpu(top->trim_percentage); + o->trim_batch = le32_to_cpu(top->trim_batch); + o->trim_zero = le32_to_cpu(top->trim_zero); + o->clat_percentiles = le32_to_cpu(top->clat_percentiles); + o->overwrite_plist = le32_to_cpu(top->overwrite_plist); + o->continue_on_error = le32_to_cpu(top->continue_on_error); + o->cgroup_weight = le32_to_cpu(top->cgroup_weight); + o->cgroup_nodelete = le32_to_cpu(top->cgroup_nodelete); + o->uid = le32_to_cpu(top->uid); + o->gid = le32_to_cpu(top->gid); + o->flow_id = __le32_to_cpu(top->flow_id); + o->flow = __le32_to_cpu(top->flow); + o->flow_watermark = __le32_to_cpu(top->flow_watermark); + o->flow_sleep = le32_to_cpu(top->flow_sleep); + o->sync_file_range = le32_to_cpu(top->sync_file_range); + o->compress_percentage = le32_to_cpu(top->compress_percentage); + o->compress_chunk = le32_to_cpu(top->compress_chunk); + + o->trim_backlog = le64_to_cpu(top->trim_backlog); + + for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) + o->percentile_list[i].u.f = fio_uint64_to_double(le64_to_cpu(top->percentile_list[i].u.i)); +#if 0 + uint8_t cpumask[FIO_TOP_STR_MAX]; + uint8_t verify_cpumask[FIO_TOP_STR_MAX]; +#endif +} + +void convert_thread_options_to_net(struct thread_options_pack *top, + struct thread_options *o) +{ + int i, j; + + string_to_net(top->description, o->description); + string_to_net(top->name, o->name); + string_to_net(top->directory, o->directory); + string_to_net(top->filename, o->filename); + string_to_net(top->opendir, o->opendir); + string_to_net(top->ioengine, o->ioengine); + string_to_net(top->mmapfile, o->mmapfile); + string_to_net(top->read_iolog_file, o->read_iolog_file); + string_to_net(top->write_iolog_file, o->write_iolog_file); + string_to_net(top->bw_log_file, o->bw_log_file); + string_to_net(top->lat_log_file, o->lat_log_file); + string_to_net(top->iops_log_file, o->iops_log_file); + string_to_net(top->replay_redirect, o->replay_redirect); + string_to_net(top->exec_prerun, o->exec_prerun); + string_to_net(top->exec_postrun, o->exec_postrun); + string_to_net(top->ioscheduler, o->ioscheduler); + string_to_net(top->profile, o->profile); + string_to_net(top->cgroup, o->cgroup); + + top->td_ddir = cpu_to_le32(o->td_ddir); + top->rw_seq = cpu_to_le32(o->rw_seq); + top->kb_base = cpu_to_le32(o->kb_base); + top->ddir_seq_nr = cpu_to_le32(o->ddir_seq_nr); + top->iodepth = cpu_to_le32(o->iodepth); + top->iodepth_low = cpu_to_le32(o->iodepth_low); + top->iodepth_batch = cpu_to_le32(o->iodepth_batch); + top->iodepth_batch_complete = cpu_to_le32(o->iodepth_batch_complete); + top->size_percent = cpu_to_le32(o->size_percent); + top->fill_device = cpu_to_le32(o->fill_device); + top->ratecycle = cpu_to_le32(o->ratecycle); + top->nr_files = cpu_to_le32(o->nr_files); + top->open_files = cpu_to_le32(o->open_files); + top->file_lock_mode = cpu_to_le32(o->file_lock_mode); + top->lockfile_batch = cpu_to_le32(o->lockfile_batch); + top->odirect = cpu_to_le32(o->odirect); + top->invalidate_cache = cpu_to_le32(o->invalidate_cache); + top->create_serialize = cpu_to_le32(o->create_serialize); + top->create_fsync = cpu_to_le32(o->create_fsync); + top->create_on_open = cpu_to_le32(o->create_on_open); + top->create_only = cpu_to_le32(o->create_only); + top->end_fsync = cpu_to_le32(o->end_fsync); + top->pre_read = cpu_to_le32(o->pre_read); + top->sync_io = cpu_to_le32(o->sync_io); + top->verify = cpu_to_le32(o->verify); + top->do_verify = cpu_to_le32(o->do_verify); + top->verifysort = cpu_to_le32(o->verifysort); + top->verifysort_nr = cpu_to_le32(o->verifysort_nr); + top->experimental_verify = cpu_to_le32(o->experimental_verify); + top->verify_interval = cpu_to_le32(o->verify_interval); + top->verify_offset = cpu_to_le32(o->verify_offset); + top->verify_pattern_bytes = cpu_to_le32(o->verify_pattern_bytes); + top->verify_fatal = cpu_to_le32(o->verify_fatal); + top->verify_dump = cpu_to_le32(o->verify_dump); + top->verify_async = cpu_to_le32(o->verify_async); + top->verify_batch = cpu_to_le32(o->verify_batch); + top->use_thread = cpu_to_le32(o->use_thread); + top->unlink = cpu_to_le32(o->unlink); + top->do_disk_util = cpu_to_le32(o->do_disk_util); + top->override_sync = cpu_to_le32(o->override_sync); + top->rand_repeatable = cpu_to_le32(o->rand_repeatable); + top->use_os_rand = cpu_to_le32(o->use_os_rand); + top->log_avg_msec = cpu_to_le32(o->log_avg_msec); + top->norandommap = cpu_to_le32(o->norandommap); + top->softrandommap = cpu_to_le32(o->softrandommap); + top->bs_unaligned = cpu_to_le32(o->bs_unaligned); + top->fsync_on_close = cpu_to_le32(o->fsync_on_close); + top->random_distribution = cpu_to_le32(o->random_distribution); + top->zipf_theta.u.i = __cpu_to_le64(fio_double_to_uint64(o->zipf_theta.u.f)); + top->pareto_h.u.i = __cpu_to_le64(fio_double_to_uint64(o->pareto_h.u.f)); + top->random_generator = cpu_to_le32(o->random_generator); + top->hugepage_size = cpu_to_le32(o->hugepage_size); + top->rw_min_bs = cpu_to_le32(o->rw_min_bs); + top->thinktime = cpu_to_le32(o->thinktime); + top->thinktime_spin = cpu_to_le32(o->thinktime_spin); + top->thinktime_blocks = cpu_to_le32(o->thinktime_blocks); + top->fsync_blocks = cpu_to_le32(o->fsync_blocks); + top->fdatasync_blocks = cpu_to_le32(o->fdatasync_blocks); + top->barrier_blocks = cpu_to_le32(o->barrier_blocks); + top->overwrite = cpu_to_le32(o->overwrite); + top->bw_avg_time = cpu_to_le32(o->bw_avg_time); + top->iops_avg_time = cpu_to_le32(o->iops_avg_time); + top->loops = cpu_to_le32(o->loops); + top->mem_type = cpu_to_le32(o->mem_type); + top->mem_align = cpu_to_le32(o->mem_align); + top->max_latency = cpu_to_le32(o->max_latency); + top->stonewall = cpu_to_le32(o->stonewall); + top->new_group = cpu_to_le32(o->new_group); + top->numjobs = cpu_to_le32(o->numjobs); + top->cpumask_set = cpu_to_le32(o->cpumask_set); + top->verify_cpumask_set = cpu_to_le32(o->verify_cpumask_set); + top->iolog = cpu_to_le32(o->iolog); + top->rwmixcycle = cpu_to_le32(o->rwmixcycle); + top->nice = cpu_to_le32(o->nice); + top->ioprio = cpu_to_le32(o->ioprio); + top->ioprio_class = cpu_to_le32(o->ioprio_class); + top->file_service_type = cpu_to_le32(o->file_service_type); + top->group_reporting = cpu_to_le32(o->group_reporting); + top->fadvise_hint = cpu_to_le32(o->fadvise_hint); + top->fallocate_mode = cpu_to_le32(o->fallocate_mode); + top->zero_buffers = cpu_to_le32(o->zero_buffers); + top->refill_buffers = cpu_to_le32(o->refill_buffers); + top->scramble_buffers = cpu_to_le32(o->scramble_buffers); + top->time_based = cpu_to_le32(o->time_based); + top->disable_lat = cpu_to_le32(o->disable_lat); + top->disable_clat = cpu_to_le32(o->disable_clat); + top->disable_slat = cpu_to_le32(o->disable_slat); + top->disable_bw = cpu_to_le32(o->disable_bw); ++ top->unified_rw_rep = cpu_to_le32(o->unified_rw_rep); + top->gtod_reduce = cpu_to_le32(o->gtod_reduce); + top->gtod_cpu = cpu_to_le32(o->gtod_cpu); + top->gtod_offload = cpu_to_le32(o->gtod_offload); + top->clocksource = cpu_to_le32(o->clocksource); + top->no_stall = cpu_to_le32(o->no_stall); + top->trim_percentage = cpu_to_le32(o->trim_percentage); + top->trim_batch = cpu_to_le32(o->trim_batch); + top->trim_zero = cpu_to_le32(o->trim_zero); + top->clat_percentiles = cpu_to_le32(o->clat_percentiles); + top->overwrite_plist = cpu_to_le32(o->overwrite_plist); + top->continue_on_error = cpu_to_le32(o->continue_on_error); + top->cgroup_weight = cpu_to_le32(o->cgroup_weight); + top->cgroup_nodelete = cpu_to_le32(o->cgroup_nodelete); + top->uid = cpu_to_le32(o->uid); + top->gid = cpu_to_le32(o->gid); + top->flow_id = __cpu_to_le32(o->flow_id); + top->flow = __cpu_to_le32(o->flow); + top->flow_watermark = __cpu_to_le32(o->flow_watermark); + top->flow_sleep = cpu_to_le32(o->flow_sleep); + top->sync_file_range = cpu_to_le32(o->sync_file_range); + top->compress_percentage = cpu_to_le32(o->compress_percentage); + top->compress_chunk = cpu_to_le32(o->compress_chunk); + + for (i = 0; i < DDIR_RWDIR_CNT; i++) { + top->bs[i] = cpu_to_le32(o->bs[i]); + top->ba[i] = cpu_to_le32(o->ba[i]); + top->min_bs[i] = cpu_to_le32(o->min_bs[i]); + top->max_bs[i] = cpu_to_le32(o->max_bs[i]); + top->bssplit_nr[i] = cpu_to_le32(o->bssplit_nr[i]); + + if (o->bssplit_nr[i]) { + unsigned int bssplit_nr = o->bssplit_nr[i]; + + if (bssplit_nr > BSSPLIT_MAX) { + log_err("fio: BSSPLIT_MAX is too small\n"); + bssplit_nr = BSSPLIT_MAX; + } + for (j = 0; j < bssplit_nr; j++) { + top->bssplit[i][j].bs = cpu_to_le32(o->bssplit[i][j].bs); + top->bssplit[i][j].perc = cpu_to_le32(o->bssplit[i][j].perc); + } + } + + top->rwmix[i] = cpu_to_le32(o->rwmix[i]); + top->rate[i] = cpu_to_le32(o->rate[i]); + top->ratemin[i] = cpu_to_le32(o->ratemin[i]); + top->rate_iops[i] = cpu_to_le32(o->rate_iops[i]); + top->rate_iops_min[i] = cpu_to_le32(o->rate_iops_min[i]); + } + + memcpy(top->verify_pattern, o->verify_pattern, MAX_PATTERN_SIZE); + + top->size = __cpu_to_le64(o->size); + top->verify_backlog = __cpu_to_le64(o->verify_backlog); + top->start_delay = __cpu_to_le64(o->start_delay); + top->timeout = __cpu_to_le64(o->timeout); + top->ramp_time = __cpu_to_le64(o->ramp_time); + top->zone_range = __cpu_to_le64(o->zone_range); + top->zone_size = __cpu_to_le64(o->zone_size); + top->zone_skip = __cpu_to_le64(o->zone_skip); + top->lockmem = __cpu_to_le64(o->lockmem); + top->ddir_seq_add = __cpu_to_le64(o->ddir_seq_add); + top->file_size_low = __cpu_to_le64(o->file_size_low); + top->file_size_high = __cpu_to_le64(o->file_size_high); + top->start_offset = __cpu_to_le64(o->start_offset); + top->trim_backlog = __cpu_to_le64(o->trim_backlog); + top->offset_increment = __cpu_to_le64(o->offset_increment); + + for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) + top->percentile_list[i].u.i = __cpu_to_le64(fio_double_to_uint64(o->percentile_list[i].u.f)); +#if 0 + uint8_t cpumask[FIO_TOP_STR_MAX]; + uint8_t verify_cpumask[FIO_TOP_STR_MAX]; +#endif + +} + +/* + * Basic conversion test. We'd really need to fill in more of the options + * to have a thorough test. Even better, we should auto-generate the + * converter functions... + */ +int fio_test_cconv(struct thread_options *__o) +{ + struct thread_options o; + struct thread_options_pack top1, top2; + + memset(&top1, 0, sizeof(top1)); + memset(&top2, 0, sizeof(top2)); + + convert_thread_options_to_net(&top1, __o); + memset(&o, 0, sizeof(o)); + convert_thread_options_to_cpu(&o, &top1); + convert_thread_options_to_net(&top2, &o); + + return memcmp(&top1, &top2, sizeof(top1)); +} diff --cc client.c index c2807622,0dc620dc..fe6d75ef --- a/client.c +++ b/client.c @@@ -694,11 -591,11 +694,12 @@@ static void convert_ts(struct thread_st { int i, j; - dst->error = le32_to_cpu(src->error); - dst->groupid = le32_to_cpu(src->groupid); - dst->pid = le32_to_cpu(src->pid); - dst->members = le32_to_cpu(src->members); + dst->error = le32_to_cpu(src->error); + dst->thread_number = le32_to_cpu(src->thread_number); + dst->groupid = le32_to_cpu(src->groupid); + dst->pid = le32_to_cpu(src->pid); + dst->members = le32_to_cpu(src->members); + dst->unified_rw_rep = le32_to_cpu(src->unified_rw_rep); for (i = 0; i < DDIR_RWDIR_CNT; i++) { convert_io_stat(&dst->clat_stat[i], &src->clat_stat[i]); @@@ -787,8 -688,8 +789,9 @@@ static void handle_ts(struct fio_clien sum_group_stats(&client_gs, &p->rs); client_ts.members++; + client_ts.thread_number = p->ts.thread_number; client_ts.groupid = p->ts.groupid; + client_ts.unified_rw_rep = p->ts.unified_rw_rep; if (++sum_stat_nr == sum_stat_clients) { strcpy(client_ts.name, "All clients"); @@@ -872,14 -761,14 +875,12 @@@ static void convert_jobs_eta(struct job je->nr_ramp = le32_to_cpu(je->nr_ramp); je->nr_pending = le32_to_cpu(je->nr_pending); je->files_open = le32_to_cpu(je->files_open); - je->m_rate = le32_to_cpu(je->m_rate); - je->t_rate = le32_to_cpu(je->t_rate); - je->m_iops = le32_to_cpu(je->m_iops); - je->t_iops = le32_to_cpu(je->t_iops); for (i = 0; i < DDIR_RWDIR_CNT; i++) { - je->rate[i] = le32_to_cpu(je->rate[i]); - je->iops[i] = le32_to_cpu(je->iops[i]); + je->m_rate[i] = le32_to_cpu(je->m_rate[i]); + je->t_rate[i] = le32_to_cpu(je->t_rate[i]); + je->m_iops[i] = le32_to_cpu(je->m_iops[i]); + je->t_iops[i] = le32_to_cpu(je->t_iops[i]); - je->rate[i] = le32_to_cpu(je->rate[i]); - je->iops[i] = le32_to_cpu(je->iops[i]); } je->elapsed_sec = le64_to_cpu(je->elapsed_sec); @@@ -896,14 -784,14 +897,12 @@@ void fio_client_sum_jobs_eta(struct job dst->nr_ramp += je->nr_ramp; dst->nr_pending += je->nr_pending; dst->files_open += je->files_open; - dst->m_rate += je->m_rate; - dst->t_rate += je->t_rate; - dst->m_iops += je->m_iops; - dst->t_iops += je->t_iops; for (i = 0; i < DDIR_RWDIR_CNT; i++) { - dst->rate[i] += je->rate[i]; - dst->iops[i] += je->iops[i]; + dst->m_rate[i] += je->m_rate[i]; + dst->t_rate[i] += je->t_rate[i]; + dst->m_iops[i] += je->m_iops[i]; + dst->t_iops[i] += je->t_iops[i]; - dst->rate[i] += je->rate[i]; - dst->iops[i] += je->iops[i]; } dst->elapsed_sec += je->elapsed_sec; diff --cc configure index ff87acc5,d332c5eb..880d113d --- a/configure +++ b/configure @@@ -991,11 -983,13 +1027,17 @@@ f if test "$rusage_thread" = "yes" ; then output_sym "CONFIG_RUSAGE_THREAD" fi +if test "$gfio" = "yes" ; then + echo "CONFIG_GFIO=y" >> $config_host_mak +fi + if test "$sched_idle" = "yes" ; then + output_sym "CONFIG_SCHED_IDLE" + fi + if test "$tcp_nodelay" = "yes" ; then + output_sym "CONFIG_TCP_NODELAY" + fi echo "LIBS+=$LIBS" >> $config_host_mak +echo "CFLAGS+=$CFLAGS" >> $config_host_mak echo "CC=$cc" >> $config_host_mak echo "EXTFLAGS=$EXTFLAGS $CFLAGS" >> $config_host_mak diff --cc engines/net.c index 94511869,3e03bc9c..12f49a2a --- a/engines/net.c +++ b/engines/net.c @@@ -96,9 -92,16 +98,17 @@@ static struct fio_option options[] = }, }, }, + #ifdef CONFIG_TCP_NODELAY + { + .name = "nodelay", + .type = FIO_OPT_BOOL, + .off1 = offsetof(struct netio_options, nodelay), + .help = "Use TCP_NODELAY on TCP connections", + }, + #endif { .name = "listen", + .lname = "net engine listen", .type = FIO_OPT_STR_SET, .off1 = offsetof(struct netio_options, listen), .help = "Listen for incoming TCP connections", diff --cc fio.c index 755a4d52,af4c12cb..7e6b06d3 --- a/fio.c +++ b/fio.c @@@ -26,21 -26,50 +26,12 @@@ #include #include "fio.h" - #include "hash.h" #include "smalloc.h" - #include "verify.h" - #include "trim.h" - #include "diskutil.h" - #include "profile.h" - #include "lib/rand.h" - #include "memalign.h" - #include "client.h" - #include "server.h" -uintptr_t page_mask; -uintptr_t page_size; - -static int endian_check(void) -{ - union { - uint8_t c[8]; - uint64_t v; - } u; - int le = 0, be = 0; - - u.v = 0x12; - if (u.c[7] == 0x12) - be = 1; - else if (u.c[0] == 0x12) - le = 1; - -#if defined(CONFIG_LITTLE_ENDIAN) - if (be) - return 1; -#elif defined(CONFIG_BIG_ENDIAN) - if (le) - return 1; -#else - return 1; -#endif - - if (!le && !be) - return 1; - - return 0; -} - int main(int argc, char *argv[], char *envp[]) { - long ps; - - if (endian_check()) { - log_err("fio: endianness settings appear wrong.\n"); - log_err("fio: please report this to fio@vger.kernel.org\n"); + if (initialize_fio(envp)) return 1; - } #if !defined(CONFIG_GETTIMEOFDAY) && !defined(CONFIG_CLOCK_GETTIME) #error "No available clock source!" diff --cc iolog.c index 137c1e98,e4c1fef9..e54016d6 --- a/iolog.c +++ b/iolog.c @@@ -534,15 -534,9 +534,15 @@@ void finish_log_named(struct thread_dat { char file_name[256], *p; - snprintf(file_name, 200, "%s_%s.log", prefix, postfix); + snprintf(file_name, sizeof(file_name), "%s_%s.log", prefix, postfix); p = basename(file_name); - __finish_log(log, p); + + if (td->client_type == FIO_CLIENT_TYPE_GUI) { + fio_send_iolog(td, log, p); + free(log->log); + free(log); + } else + __finish_log(log, p); } void finish_log(struct thread_data *td, struct io_log *log, const char *name) diff --cc log.c index a26dee87,08509b32..d481edf2 --- a/log.c +++ b/log.c @@@ -58,9 -60,10 +60,10 @@@ int log_info(const char *format, ... va_start(args, format); len = vsnprintf(buffer, sizeof(buffer), format, args); va_end(args); + len = min(len, sizeof(buffer) - 1); if (is_backend) - return fio_server_text_output(buffer, len); + return fio_server_text_output(FIO_LOG_INFO, buffer, len); else if (log_syslog) { syslog(LOG_INFO, "%s", buffer); return len; @@@ -77,9 -80,10 +80,10 @@@ int log_err(const char *format, ... va_start(args, format); len = vsnprintf(buffer, sizeof(buffer), format, args); va_end(args); + len = min(len, sizeof(buffer) - 1); if (is_backend) - return fio_server_text_output(buffer, len); + return fio_server_text_output(FIO_LOG_ERR, buffer, len); else if (log_syslog) { syslog(LOG_INFO, "%s", buffer); return len; diff --cc options.c index 9d49ff17,799e77a4..c39a6b40 --- a/options.c +++ b/options.c @@@ -2938,12 -2495,16 +2938,19 @@@ struct fio_option fio_options[FIO_MAX_O .cb = str_gtod_cpu_cb, .help = "Set up dedicated gettimeofday() thread on this CPU", .verify = gtod_cpu_verify, + .category = FIO_OPT_C_GENERAL, + .group = FIO_OPT_G_CLOCK, }, + { + .name = "unified_rw_reporting", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(unified_rw_rep), + .help = "Unify reporting across data direction", + .def = "0", + }, { .name = "continue_on_error", + .lname = "Continue on error", .type = FIO_OPT_STR, .off1 = td_var_offset(continue_on_error), .help = "Continue on non-fatal errors during IO", diff --cc server.c index 514306dc,ad785720..8e5ca50f --- a/server.c +++ b/server.c @@@ -660,14 -440,14 +660,12 @@@ static int handle_send_eta_cmd(struct f je->nr_ramp = cpu_to_le32(je->nr_ramp); je->nr_pending = cpu_to_le32(je->nr_pending); je->files_open = cpu_to_le32(je->files_open); - je->m_rate = cpu_to_le32(je->m_rate); - je->t_rate = cpu_to_le32(je->t_rate); - je->m_iops = cpu_to_le32(je->m_iops); - je->t_iops = cpu_to_le32(je->t_iops); for (i = 0; i < DDIR_RWDIR_CNT; i++) { - je->rate[i] = cpu_to_le32(je->rate[i]); - je->iops[i] = cpu_to_le32(je->iops[i]); + je->m_rate[i] = cpu_to_le32(je->m_rate[i]); + je->t_rate[i] = cpu_to_le32(je->t_rate[i]); + je->m_iops[i] = cpu_to_le32(je->m_iops[i]); + je->t_iops[i] = cpu_to_le32(je->t_iops[i]); - je->rate[i] = cpu_to_le32(je->rate[i]); - je->iops[i] = cpu_to_le32(je->iops[i]); } je->elapsed_sec = cpu_to_le64(je->elapsed_sec); @@@ -957,11 -668,12 +956,12 @@@ void fio_server_send_ts(struct thread_s strcpy(p.ts.verror, ts->verror); strcpy(p.ts.description, ts->description); - p.ts.error = cpu_to_le32(ts->error); - p.ts.groupid = cpu_to_le32(ts->groupid); - p.ts.unified_rw_rep = cpu_to_le32(ts->unified_rw_rep); - p.ts.pid = cpu_to_le32(ts->pid); - p.ts.members = cpu_to_le32(ts->members); + p.ts.error = cpu_to_le32(ts->error); + p.ts.thread_number = cpu_to_le32(ts->thread_number); + p.ts.groupid = cpu_to_le32(ts->groupid); + p.ts.pid = cpu_to_le32(ts->pid); + p.ts.members = cpu_to_le32(ts->members); + p.ts.unified_rw_rep = cpu_to_le32(ts->unified_rw_rep); for (i = 0; i < DDIR_RWDIR_CNT; i++) { convert_io_stat(&p.ts.clat_stat[i], &ts->clat_stat[i]); diff --cc server.h index fa88d241,15b802b4..e84a7095 --- a/server.h +++ b/server.h @@@ -38,39 -36,33 +38,39 @@@ struct fio_net_cmd_reply }; enum { - FIO_SERVER_VER = 19, - FIO_SERVER_VER = 10, - - FIO_SERVER_MAX_PDU = 1024, - - FIO_NET_CMD_QUIT = 1, - FIO_NET_CMD_EXIT = 2, - FIO_NET_CMD_JOB = 3, - FIO_NET_CMD_JOBLINE = 4, - FIO_NET_CMD_TEXT = 5, - FIO_NET_CMD_TS = 6, - FIO_NET_CMD_GS = 7, - FIO_NET_CMD_SEND_ETA = 8, - FIO_NET_CMD_ETA = 9, - FIO_NET_CMD_PROBE = 10, - FIO_NET_CMD_START = 11, - FIO_NET_CMD_STOP = 12, - FIO_NET_CMD_DU = 13, - FIO_NET_CMD_RUN = 14, - FIO_NET_CMD_NR = 15, - - FIO_NET_CMD_F_MORE = 1UL << 0, ++ FIO_SERVER_VER = 20, + + FIO_SERVER_MAX_FRAGMENT_PDU = 1024, + + FIO_NET_CMD_QUIT = 1, + FIO_NET_CMD_EXIT = 2, + FIO_NET_CMD_JOB = 3, + FIO_NET_CMD_JOBLINE = 4, + FIO_NET_CMD_TEXT = 5, + FIO_NET_CMD_TS = 6, + FIO_NET_CMD_GS = 7, + FIO_NET_CMD_SEND_ETA = 8, + FIO_NET_CMD_ETA = 9, + FIO_NET_CMD_PROBE = 10, + FIO_NET_CMD_START = 11, + FIO_NET_CMD_STOP = 12, + FIO_NET_CMD_DU = 13, + FIO_NET_CMD_SERVER_START = 14, + FIO_NET_CMD_ADD_JOB = 15, + FIO_NET_CMD_RUN = 16, + FIO_NET_CMD_IOLOG = 17, + FIO_NET_CMD_UPDATE_JOB = 18, + FIO_NET_CMD_NR = 19, + + FIO_NET_CMD_F_MORE = 1UL << 0, /* crc does not include the crc fields */ - FIO_NET_CMD_CRC_SZ = sizeof(struct fio_net_cmd) - - 2 * sizeof(uint16_t), + FIO_NET_CMD_CRC_SZ = sizeof(struct fio_net_cmd) - + 2 * sizeof(uint16_t), + + FIO_NET_NAME_MAX = 256, - FIO_NET_CLIENT_TIMEOUT = 5000, + FIO_NET_CLIENT_TIMEOUT = 5000, }; struct cmd_ts_pdu { diff --cc thread_options.h index 21c1dac5,00000000..ae83f08a mode 100644,000000..100644 --- a/thread_options.h +++ b/thread_options.h @@@ -1,457 -1,0 +1,459 @@@ +#ifndef FIO_THREAD_OPTIONS_H +#define FIO_THREAD_OPTIONS_H + +#include "arch/arch.h" +#include "os/os.h" +#include "stat.h" +#include "gettime.h" + +/* + * What type of allocation to use for io buffers + */ +enum fio_memtype { + MEM_MALLOC = 0, /* ordinary malloc */ + MEM_SHM, /* use shared memory segments */ + MEM_SHMHUGE, /* use shared memory segments with huge pages */ + MEM_MMAP, /* use anonynomous mmap */ + MEM_MMAPHUGE, /* memory mapped huge file */ +}; + +/* + * What type of errors to continue on when continue_on_error is used + */ +enum error_type_bit { + ERROR_TYPE_READ_BIT = 0, + ERROR_TYPE_WRITE_BIT = 1, + ERROR_TYPE_VERIFY_BIT = 2, + ERROR_TYPE_CNT = 3, +}; + +#define ERROR_STR_MAX 128 + +enum error_type { + ERROR_TYPE_NONE = 0, + ERROR_TYPE_READ = 1 << ERROR_TYPE_READ_BIT, + ERROR_TYPE_WRITE = 1 << ERROR_TYPE_WRITE_BIT, + ERROR_TYPE_VERIFY = 1 << ERROR_TYPE_VERIFY_BIT, + ERROR_TYPE_ANY = 0xffff, +}; + +#define BSSPLIT_MAX 64 + +struct bssplit { + uint32_t bs; + uint32_t perc; +}; + +struct thread_options { + int pad; + char *description; + char *name; + char *directory; + char *filename; + char *opendir; + char *ioengine; + char *mmapfile; + enum td_ddir td_ddir; + unsigned int rw_seq; + unsigned int kb_base; + unsigned int ddir_seq_nr; + long ddir_seq_add; + unsigned int iodepth; + unsigned int iodepth_low; + unsigned int iodepth_batch; + unsigned int iodepth_batch_complete; + + unsigned long long size; + unsigned int size_percent; + unsigned int fill_device; + unsigned long long file_size_low; + unsigned long long file_size_high; + unsigned long long start_offset; + + unsigned int bs[DDIR_RWDIR_CNT]; + unsigned int ba[DDIR_RWDIR_CNT]; + unsigned int min_bs[DDIR_RWDIR_CNT]; + unsigned int max_bs[DDIR_RWDIR_CNT]; + struct bssplit *bssplit[DDIR_RWDIR_CNT]; + unsigned int bssplit_nr[DDIR_RWDIR_CNT]; + + int *ignore_error[ERROR_TYPE_CNT]; + unsigned int ignore_error_nr[ERROR_TYPE_CNT]; + unsigned int error_dump; + + unsigned int nr_files; + unsigned int open_files; + enum file_lock_mode file_lock_mode; + unsigned int lockfile_batch; + + unsigned int odirect; + unsigned int invalidate_cache; + unsigned int create_serialize; + unsigned int create_fsync; + unsigned int create_on_open; + unsigned int create_only; + unsigned int end_fsync; + unsigned int pre_read; + unsigned int sync_io; + unsigned int verify; + unsigned int do_verify; + unsigned int verifysort; + unsigned int verifysort_nr; + unsigned int verify_interval; + unsigned int verify_offset; + char verify_pattern[MAX_PATTERN_SIZE]; + unsigned int verify_pattern_bytes; + unsigned int verify_fatal; + unsigned int verify_dump; + unsigned int verify_async; + unsigned long long verify_backlog; + unsigned int verify_batch; + unsigned int experimental_verify; + unsigned int use_thread; + unsigned int unlink; + unsigned int do_disk_util; + unsigned int override_sync; + unsigned int rand_repeatable; + unsigned int use_os_rand; + unsigned int log_avg_msec; + unsigned int norandommap; + unsigned int softrandommap; + unsigned int bs_unaligned; + unsigned int fsync_on_close; + + unsigned int random_distribution; + fio_fp64_t zipf_theta; + fio_fp64_t pareto_h; + + unsigned int random_generator; + + unsigned int hugepage_size; + unsigned int rw_min_bs; + unsigned int thinktime; + unsigned int thinktime_spin; + unsigned int thinktime_blocks; + unsigned int fsync_blocks; + unsigned int fdatasync_blocks; + unsigned int barrier_blocks; + unsigned long long start_delay; + unsigned long long timeout; + unsigned long long ramp_time; + unsigned int overwrite; + unsigned int bw_avg_time; + unsigned int iops_avg_time; + unsigned int loops; + unsigned long long zone_range; + unsigned long long zone_size; + unsigned long long zone_skip; + unsigned long long lockmem; + enum fio_memtype mem_type; + unsigned int mem_align; + + unsigned max_latency; + + unsigned int stonewall; + unsigned int new_group; + unsigned int numjobs; + os_cpu_mask_t cpumask; + unsigned int cpumask_set; + os_cpu_mask_t verify_cpumask; + unsigned int verify_cpumask_set; +#ifdef CONFIG_LIBNUMA + struct bitmask *numa_cpunodesmask; + unsigned int numa_cpumask_set; + unsigned short numa_mem_mode; + unsigned int numa_mem_prefer_node; + struct bitmask *numa_memnodesmask; + unsigned int numa_memmask_set; +#endif + unsigned int iolog; + unsigned int rwmixcycle; + unsigned int rwmix[2]; + unsigned int nice; + unsigned int ioprio; + unsigned int ioprio_class; + unsigned int file_service_type; + unsigned int group_reporting; + unsigned int fadvise_hint; + enum fio_fallocate_mode fallocate_mode; + unsigned int zero_buffers; + unsigned int refill_buffers; + unsigned int scramble_buffers; + unsigned int compress_percentage; + unsigned int compress_chunk; + unsigned int time_based; + unsigned int disable_lat; + unsigned int disable_clat; + unsigned int disable_slat; + unsigned int disable_bw; ++ unsigned int unified_rw_rep; + unsigned int gtod_reduce; + unsigned int gtod_cpu; + unsigned int gtod_offload; + enum fio_cs clocksource; + unsigned int no_stall; + unsigned int trim_percentage; + unsigned int trim_batch; + unsigned int trim_zero; + unsigned long long trim_backlog; + unsigned int clat_percentiles; + unsigned int overwrite_plist; + fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN]; + + char *read_iolog_file; + char *write_iolog_file; + char *bw_log_file; + char *lat_log_file; + char *iops_log_file; + char *replay_redirect; + + /* + * Pre-run and post-run shell + */ + char *exec_prerun; + char *exec_postrun; + + unsigned int rate[DDIR_RWDIR_CNT]; + unsigned int ratemin[DDIR_RWDIR_CNT]; + unsigned int ratecycle; + unsigned int rate_iops[DDIR_RWDIR_CNT]; + unsigned int rate_iops_min[DDIR_RWDIR_CNT]; + + char *ioscheduler; + + /* + * I/O Error handling + */ + enum error_type continue_on_error; + + /* + * Benchmark profile type + */ + char *profile; + + /* + * blkio cgroup support + */ + char *cgroup; + unsigned int cgroup_weight; + unsigned int cgroup_nodelete; + + unsigned int uid; + unsigned int gid; + + int flow_id; + int flow; + int flow_watermark; + unsigned int flow_sleep; + + unsigned long long offset_increment; + + unsigned int sync_file_range; +}; + +#define FIO_TOP_STR_MAX 256 + +struct thread_options_pack { + uint8_t description[FIO_TOP_STR_MAX]; + uint8_t name[FIO_TOP_STR_MAX]; + uint8_t directory[FIO_TOP_STR_MAX]; + uint8_t filename[FIO_TOP_STR_MAX]; + uint8_t opendir[FIO_TOP_STR_MAX]; + uint8_t ioengine[FIO_TOP_STR_MAX]; + uint8_t mmapfile[FIO_TOP_STR_MAX]; + uint32_t td_ddir; + uint32_t rw_seq; + uint32_t kb_base; + uint32_t ddir_seq_nr; + uint64_t ddir_seq_add; + uint32_t iodepth; + uint32_t iodepth_low; + uint32_t iodepth_batch; + uint32_t iodepth_batch_complete; + + uint64_t size; + uint32_t size_percent; + uint32_t fill_device; + uint64_t file_size_low; + uint64_t file_size_high; + uint64_t start_offset; + + uint32_t bs[DDIR_RWDIR_CNT]; + uint32_t ba[DDIR_RWDIR_CNT]; + uint32_t min_bs[DDIR_RWDIR_CNT]; + uint32_t max_bs[DDIR_RWDIR_CNT]; + struct bssplit bssplit[DDIR_RWDIR_CNT][BSSPLIT_MAX]; + uint32_t bssplit_nr[DDIR_RWDIR_CNT]; + + uint32_t ignore_error[ERROR_TYPE_CNT][ERROR_STR_MAX]; + uint32_t ignore_error_nr[ERROR_TYPE_CNT]; + uint32_t error_dump; + + uint32_t nr_files; + uint32_t open_files; + uint32_t file_lock_mode; + uint32_t lockfile_batch; + + uint32_t odirect; + uint32_t invalidate_cache; + uint32_t create_serialize; + uint32_t create_fsync; + uint32_t create_on_open; + uint32_t create_only; + uint32_t end_fsync; + uint32_t pre_read; + uint32_t sync_io; + uint32_t verify; + uint32_t do_verify; + uint32_t verifysort; + uint32_t verifysort_nr; + uint32_t verify_interval; + uint32_t verify_offset; + uint8_t verify_pattern[MAX_PATTERN_SIZE]; + uint32_t verify_pattern_bytes; + uint32_t verify_fatal; + uint32_t verify_dump; + uint32_t verify_async; + uint64_t verify_backlog; + uint32_t verify_batch; + uint32_t experimental_verify; + uint32_t use_thread; + uint32_t unlink; + uint32_t do_disk_util; + uint32_t override_sync; + uint32_t rand_repeatable; + uint32_t use_os_rand; + uint32_t log_avg_msec; + uint32_t norandommap; + uint32_t softrandommap; + uint32_t bs_unaligned; + uint32_t fsync_on_close; + + uint32_t random_distribution; + fio_fp64_t zipf_theta; + fio_fp64_t pareto_h; + + uint32_t random_generator; + + uint32_t hugepage_size; + uint32_t rw_min_bs; + uint32_t thinktime; + uint32_t thinktime_spin; + uint32_t thinktime_blocks; + uint32_t fsync_blocks; + uint32_t fdatasync_blocks; + uint32_t barrier_blocks; + uint64_t start_delay; + uint64_t timeout; + uint64_t ramp_time; + uint32_t overwrite; + uint32_t bw_avg_time; + uint32_t iops_avg_time; + uint32_t loops; + uint64_t zone_range; + uint64_t zone_size; + uint64_t zone_skip; + uint64_t lockmem; + uint32_t mem_type; + uint32_t mem_align; + + uint32_t max_latency; + + uint32_t stonewall; + uint32_t new_group; + uint32_t numjobs; + uint8_t cpumask[FIO_TOP_STR_MAX]; + uint32_t cpumask_set; + uint8_t verify_cpumask[FIO_TOP_STR_MAX]; + uint32_t verify_cpumask_set; + uint32_t iolog; + uint32_t rwmixcycle; + uint32_t rwmix[2]; + uint32_t nice; + uint32_t ioprio; + uint32_t ioprio_class; + uint32_t file_service_type; + uint32_t group_reporting; + uint32_t fadvise_hint; + uint32_t fallocate_mode; + uint32_t zero_buffers; + uint32_t refill_buffers; + uint32_t scramble_buffers; + unsigned int compress_percentage; + unsigned int compress_chunk; + uint32_t time_based; + uint32_t disable_lat; + uint32_t disable_clat; + uint32_t disable_slat; + uint32_t disable_bw; ++ uint32_t unified_rw_rep; + uint32_t gtod_reduce; + uint32_t gtod_cpu; + uint32_t gtod_offload; + uint32_t clocksource; + uint32_t no_stall; + uint32_t trim_percentage; + uint32_t trim_batch; + uint32_t trim_zero; + uint64_t trim_backlog; + uint32_t clat_percentiles; + uint32_t overwrite_plist; + fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN]; + + uint8_t read_iolog_file[FIO_TOP_STR_MAX]; + uint8_t write_iolog_file[FIO_TOP_STR_MAX]; + uint8_t bw_log_file[FIO_TOP_STR_MAX]; + uint8_t lat_log_file[FIO_TOP_STR_MAX]; + uint8_t iops_log_file[FIO_TOP_STR_MAX]; + uint8_t replay_redirect[FIO_TOP_STR_MAX]; + + /* + * Pre-run and post-run shell + */ + uint8_t exec_prerun[FIO_TOP_STR_MAX]; + uint8_t exec_postrun[FIO_TOP_STR_MAX]; + + uint32_t rate[DDIR_RWDIR_CNT]; + uint32_t ratemin[DDIR_RWDIR_CNT]; + uint32_t ratecycle; + uint32_t rate_iops[DDIR_RWDIR_CNT]; + uint32_t rate_iops_min[DDIR_RWDIR_CNT]; + + uint8_t ioscheduler[FIO_TOP_STR_MAX]; + + /* + * I/O Error handling + */ + uint32_t continue_on_error; + + /* + * Benchmark profile type + */ + uint8_t profile[FIO_TOP_STR_MAX]; + + /* + * blkio cgroup support + */ + uint8_t cgroup[FIO_TOP_STR_MAX]; + uint32_t cgroup_weight; + uint32_t cgroup_nodelete; + + uint32_t uid; + uint32_t gid; + + int32_t flow_id; + int32_t flow; + int32_t flow_watermark; + uint32_t flow_sleep; + + uint64_t offset_increment; + + uint32_t sync_file_range; +} __attribute__((packed)); + +extern void convert_thread_options_to_cpu(struct thread_options *o, struct thread_options_pack *top); +extern void convert_thread_options_to_net(struct thread_options_pack *top, struct thread_options *); +extern int fio_test_cconv(struct thread_options *); +extern void options_default_fill(struct thread_options *o); + +#endif