X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=62fab49c17ea4be20e416344f90c9278333976f2;hp=2aa8b40156ce60abf93efd0a657286159f6a2a26;hb=398e8c4ddb1e4c05159cf86b6367156bdfd2b084;hpb=5f8f9726e7466419db8b8e9c2205430ad1d33aad diff --git a/fio.c b/fio.c index 2aa8b401..62fab49c 100644 --- a/fio.c +++ b/fio.c @@ -52,9 +52,11 @@ int temp_stall_ts; unsigned long done_secs = 0; static struct fio_mutex *startup_mutex; +static struct fio_mutex *writeout_mutex; static volatile int fio_abort; static int exit_value; static struct itimerval itimer; +static pthread_t gtod_thread; struct io_log *agg_io_log[2]; @@ -170,13 +172,15 @@ static void set_sig_handlers(void) static inline int should_check_rate(struct thread_data *td) { + struct thread_options *o = &td->o; + /* - * No minimum rate set, always ok + * If some rate setting was given, we need to check it */ - if (!td->o.ratemin && !td->o.rate_iops_min) - return 0; + if (o->rate || o->ratemin || o->rate_iops || o->rate_iops_min) + return 1; - return 1; + return 0; } /* @@ -672,7 +676,7 @@ sync_done: int left; if (td->o.thinktime_spin) - __usec_sleep(td->o.thinktime_spin); + usec_spin(td->o.thinktime_spin); left = td->o.thinktime - td->o.thinktime_spin; if (left) @@ -730,7 +734,7 @@ static int init_io_u(struct thread_data *td) { struct io_u *io_u; unsigned int max_bs; - int i, max_units; + int cl_align, i, max_units; char *p; max_units = td->o.iodepth; @@ -758,10 +762,20 @@ static int init_io_u(struct thread_data *td) else p = td->orig_buffer; + cl_align = os_cache_line_size(); + for (i = 0; i < max_units; i++) { + void *ptr; + if (td->terminate) return 1; - io_u = malloc(sizeof(*io_u)); + + if (posix_memalign(&ptr, cl_align, sizeof(*io_u))) { + log_err("fio: posix_memalign=%s\n", strerror(errno)); + break; + } + + io_u = ptr; memset(io_u, 0, sizeof(*io_u)); INIT_FLIST_HEAD(&io_u->list); @@ -873,6 +887,11 @@ static void reset_io_counters(struct thread_data *td) */ if (td->o.time_based || td->o.loops) td->nr_done_files = 0; + + /* + * Set the same seed to get repeatable runs + */ + td_fill_rand_seeds(td); } void reset_all_stats(struct thread_data *td) @@ -894,24 +913,31 @@ void reset_all_stats(struct thread_data *td) memcpy(&td->start, &tv, sizeof(tv)); } -static int clear_io_state(struct thread_data *td) +static void clear_io_state(struct thread_data *td) { struct fio_file *f; unsigned int i; - int ret; reset_io_counters(td); close_files(td); - - ret = 0; - for_each_file(td, f, i) { + for_each_file(td, f, i) f->flags &= ~FIO_FILE_DONE; - ret = td_io_open_file(td, f); - if (ret) - break; - } +} + +static int exec_string(const char *string) +{ + int ret, newlen = strlen(string) + 1 + 8; + char *str; + str = malloc(newlen); + sprintf(str, "sh -c %s", string); + + ret = system(str); + if (ret == -1) + log_err("fio: exec of cmd <%s> failed\n", str); + + free(str); return ret; } @@ -940,8 +966,11 @@ static void *thread_main(void *data) td->io_hist_tree = RB_ROOT; td_set_runstate(td, TD_INITIALIZED); + dprint(FD_MUTEX, "up startup_mutex\n"); fio_mutex_up(startup_mutex); + dprint(FD_MUTEX, "wait on td->mutex\n"); fio_mutex_down(td->mutex); + dprint(FD_MUTEX, "done waiting on td->mutex\n"); /* * the ->mutex mutex is now no longer used, close it to avoid @@ -964,6 +993,18 @@ static void *thread_main(void *data) goto err; } + /* + * If we have a gettimeofday() thread, make sure we exclude that + * thread from this job + */ + if (td->o.gtod_cpu) { + fio_cpu_clear(&td->o.cpumask, td->o.gtod_cpu); + if (fio_setaffinity(td) == -1) { + td_verror(td, errno, "cpu_set_affinity"); + goto err; + } + } + if (td->ioprio_set) { if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) { td_verror(td, errno, "ioprio_set"); @@ -985,14 +1026,16 @@ static void *thread_main(void *data) if (td_io_init(td)) goto err; - if (open_files(td)) - goto err; - if (init_random_map(td)) goto err; if (td->o.exec_prerun) { - if (system(td->o.exec_prerun) < 0) + if (exec_string(td->o.exec_prerun)) + goto err; + } + + if (td->o.pre_read) { + if (pre_read_files(td) < 0) goto err; } @@ -1010,8 +1053,8 @@ static void *thread_main(void *data) memcpy(&td->lastrate, &td->ts.stat_sample_time, sizeof(td->lastrate)); - if (clear_state && clear_io_state(td)) - break; + if (clear_state) + clear_io_state(td); prune_io_piece_log(td); @@ -1046,8 +1089,7 @@ static void *thread_main(void *data) (td->io_ops->flags & FIO_UNIDIR)) continue; - if (clear_io_state(td)) - break; + clear_io_state(td); fio_gettime(&td->start, NULL); @@ -1066,16 +1108,31 @@ static void *thread_main(void *data) td->ts.io_bytes[0] = td->io_bytes[0]; td->ts.io_bytes[1] = td->io_bytes[1]; - if (td->ts.bw_log) - finish_log(td, td->ts.bw_log, "bw"); - if (td->ts.slat_log) - finish_log(td, td->ts.slat_log, "slat"); - if (td->ts.clat_log) - finish_log(td, td->ts.clat_log, "clat"); - if (td->o.exec_postrun) { - if (system(td->o.exec_postrun) < 0) - log_err("fio: postrun %s failed\n", td->o.exec_postrun); + fio_mutex_down(writeout_mutex); + if (td->ts.bw_log) { + if (td->o.bw_log_file) { + finish_log_named(td, td->ts.bw_log, + td->o.bw_log_file, "bw"); + } else + finish_log(td, td->ts.bw_log, "bw"); + } + if (td->ts.slat_log) { + if (td->o.lat_log_file) { + finish_log_named(td, td->ts.slat_log, + td->o.lat_log_file, "slat"); + } else + finish_log(td, td->ts.slat_log, "slat"); } + if (td->ts.clat_log) { + if (td->o.lat_log_file) { + finish_log_named(td, td->ts.clat_log, + td->o.lat_log_file, "clat"); + } else + finish_log(td, td->ts.clat_log, "clat"); + } + fio_mutex_up(writeout_mutex); + if (td->o.exec_postrun) + exec_string(td->o.exec_postrun); if (exitall_on_terminate) terminate_threads(td->groupid); @@ -1088,6 +1145,12 @@ err: close_ioengine(td); cleanup_io_u(td); + if (td->o.cpumask_set) { + int ret = fio_cpuset_exit(&td->o.cpumask); + + td_verror(td, ret, "fio_cpuset_exit"); + } + /* * do this very late, it will log file closing as well */ @@ -1217,6 +1280,46 @@ reaped: terminate_threads(TERMINATE_ALL); } +static void *gtod_thread_main(void *data) +{ + fio_mutex_up(startup_mutex); + + /* + * As long as we have jobs around, update the clock. It would be nice + * to have some way of NOT hammering that CPU with gettimeofday(), + * but I'm not sure what to use outside of a simple CPU nop to relax + * it - we don't want to lose precision. + */ + while (threads) { + fio_gtod_update(); + nop; + } + + return NULL; +} + +static int fio_start_gtod_thread(void) +{ + int ret; + + ret = pthread_create(>od_thread, NULL, gtod_thread_main, NULL); + if (ret) { + log_err("Can't create gtod thread: %s\n", strerror(ret)); + return 1; + } + + ret = pthread_detach(gtod_thread); + if (ret) { + log_err("Can't detatch gtod thread: %s\n", strerror(ret)); + return 1; + } + + dprint(FD_MUTEX, "wait on startup_mutex\n"); + fio_mutex_down(startup_mutex); + dprint(FD_MUTEX, "done waiting on startup_mutex\n"); + return 0; +} + /* * Main function for kicking off and reaping jobs, as needed. */ @@ -1229,6 +1332,9 @@ static void run_threads(void) if (fio_pin_memory()) return; + if (fio_gtod_offload && fio_start_gtod_thread()) + return; + if (!terse_output) { printf("Starting "); if (nr_thread) @@ -1332,15 +1438,21 @@ static void run_threads(void) nr_started++; if (td->o.use_thread) { + int ret; + dprint(FD_PROCESS, "will pthread_create\n"); - if (pthread_create(&td->thread, NULL, - thread_main, td)) { - perror("pthread_create"); + ret = pthread_create(&td->thread, NULL, + thread_main, td); + if (ret) { + log_err("pthread_create: %s\n", + strerror(ret)); nr_started--; break; } - if (pthread_detach(td->thread) < 0) - perror("pthread_detach"); + ret = pthread_detach(td->thread); + if (ret) + log_err("pthread_detach: %s", + strerror(ret)); } else { pid_t pid; dprint(FD_PROCESS, "will fork\n"); @@ -1352,7 +1464,9 @@ static void run_threads(void) } else if (i == fio_debug_jobno) *fio_debug_jobp = pid; } + dprint(FD_MUTEX, "wait on startup_mutex\n"); fio_mutex_down(startup_mutex); + dprint(FD_MUTEX, "done waiting on startup_mutex\n"); } /* @@ -1462,6 +1576,7 @@ int main(int argc, char *argv[]) } startup_mutex = fio_mutex_init(0); + writeout_mutex = fio_mutex_init(1); set_genesis_time(); @@ -1479,5 +1594,6 @@ int main(int argc, char *argv[]) } fio_mutex_remove(startup_mutex); + fio_mutex_remove(writeout_mutex); return exit_value; }