X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=5bd1baefc29849ec58c225e4443f8a829b95df5d;hp=cedbfb0d44e61bce100fbe5bf1b902d5b4a91ebe;hb=d6aed795f2e3e403828abf60874dd2d6e8342a1b;hpb=4950421a7e379ba0ca642390ae4ae7b68e92a42f diff --git a/fio.c b/fio.c index cedbfb0d..5bd1baef 100644 --- a/fio.c +++ b/fio.c @@ -52,16 +52,18 @@ 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]; #define TERMINATE_ALL (-1) #define JOB_START_TIMEOUT (5 * 1000) -static inline void td_set_runstate(struct thread_data *td, int runstate) +void td_set_runstate(struct thread_data *td, int runstate) { if (td->runstate == runstate) return; @@ -107,7 +109,7 @@ static void status_timer_arm(void) setitimer(ITIMER_REAL, &itimer, NULL); } -static void sig_alrm(int sig) +static void sig_alrm(int fio_unused sig) { if (threads) { update_io_ticks(); @@ -116,6 +118,13 @@ static void sig_alrm(int sig) } } +/* + * Happens on thread runs with ctrl-c, ignore our own SIGQUIT + */ +static void sig_quit(int sig) +{ +} + static void sig_int(int sig) { if (threads) { @@ -125,6 +134,17 @@ static void sig_int(int sig) } } +static void sig_ill(int fio_unused sig) +{ + if (!threads) + return; + + log_err("fio: illegal instruction. your cpu does not support " + "the sse4.2 instruction for crc32c\n"); + terminate_threads(TERMINATE_ALL); + exit(4); +} + static void set_sig_handlers(void) { struct sigaction act; @@ -138,6 +158,29 @@ static void set_sig_handlers(void) act.sa_handler = sig_int; act.sa_flags = SA_RESTART; sigaction(SIGINT, &act, NULL); + + memset(&act, 0, sizeof(act)); + act.sa_handler = sig_ill; + act.sa_flags = SA_RESTART; + sigaction(SIGILL, &act, NULL); + + memset(&act, 0, sizeof(act)); + act.sa_handler = sig_quit; + act.sa_flags = SA_RESTART; + sigaction(SIGQUIT, &act, NULL); +} + +static inline int should_check_rate(struct thread_data *td) +{ + struct thread_options *o = &td->o; + + /* + * If some rate setting was given, we need to check it + */ + if (o->rate || o->ratemin || o->rate_iops || o->rate_iops_min) + return 1; + + return 0; } /* @@ -150,12 +193,6 @@ static int check_min_rate(struct thread_data *td, struct timeval *now) unsigned long spent; unsigned long rate; - /* - * No minimum rate set, always ok - */ - if (!td->o.ratemin && !td->o.rate_iops_min) - return 0; - /* * allow a 2 second settle period in the beginning */ @@ -324,6 +361,12 @@ requeue: return 0; } +static inline void update_tv_cache(struct thread_data *td) +{ + if ((++td->tv_cache_nr & td->tv_cache_mask) == td->tv_cache_mask) + fio_gettime(&td->tv_cache, NULL); +} + /* * The main verify engine. Runs over the writes we previously submitted, * reads the blocks back in, and checks the crc/md5 of the data. @@ -340,7 +383,7 @@ static void do_verify(struct thread_data *td) * read from disk. */ for_each_file(td, f, i) { - if (!(f->flags & FIO_FILE_OPEN)) + if (!fio_file_open(f)) continue; if (fio_io_sync(td, f)) break; @@ -361,7 +404,9 @@ static void do_verify(struct thread_data *td) if (!io_u) break; - if (runtime_exceeded(td, &io_u->start_time)) { + update_tv_cache(td); + + if (runtime_exceeded(td, &td->tv_cache)) { put_io_u(td, io_u); td->terminate = 1; break; @@ -474,12 +519,14 @@ sync_done: */ static void do_io(struct thread_data *td) { - struct timeval s; unsigned long usec; unsigned int i; int ret = 0; - td_set_runstate(td, TD_RUNNING); + if (in_ramp_time(td)) + td_set_runstate(td, TD_RAMP); + else + td_set_runstate(td, TD_RUNNING); while ((td->this_io_bytes[0] + td->this_io_bytes[1]) < td->o.size) { struct timeval comp_time; @@ -495,9 +542,9 @@ static void do_io(struct thread_data *td) if (!io_u) break; - memcpy(&s, &io_u->start_time, sizeof(s)); + update_tv_cache(td); - if (runtime_exceeded(td, &s)) { + if (runtime_exceeded(td, &td->tv_cache)) { put_io_u(td, io_u); td->terminate = 1; break; @@ -510,7 +557,9 @@ static void do_io(struct thread_data *td) if (td->o.verify != VERIFY_NONE && io_u->ddir == DDIR_READ) { io_u->end_io = verify_io_u; td_set_runstate(td, TD_VERIFYING); - } else + } else if (in_ramp_time(td)) + td_set_runstate(td, TD_RAMP); + else td_set_runstate(td, TD_RUNNING); ret = td_io_queue(td, io_u); @@ -543,7 +592,9 @@ static void do_io(struct thread_data *td) requeue_io_u(td, &io_u); } else { sync_done: - fio_gettime(&comp_time, NULL); + if (should_check_rate(td)) + fio_gettime(&comp_time, NULL); + bytes_done = io_u_sync_complete(td, io_u); if (bytes_done < 0) ret = bytes_done; @@ -582,7 +633,8 @@ sync_done: if (full && !min_evts) min_evts = 1; - fio_gettime(&comp_time, NULL); + if (should_check_rate(td)) + fio_gettime(&comp_time, NULL); do { ret = io_u_queued_complete(td, min_evts); @@ -603,15 +655,17 @@ sync_done: * of completions except the very first one which may look * a little bursty */ - usec = utime_since(&s, &comp_time); + if (!in_ramp_time(td) && should_check_rate(td)) { + usec = utime_since(&td->tv_cache, &comp_time); - rate_throttle(td, usec, bytes_done); + rate_throttle(td, usec, bytes_done); - if (check_min_rate(td, &comp_time)) { - if (exitall_on_terminate) - terminate_threads(td->groupid); - td_verror(td, EIO, "check_min_rate"); - break; + if (check_min_rate(td, &comp_time)) { + if (exitall_on_terminate) + terminate_threads(td->groupid); + td_verror(td, EIO, "check_min_rate"); + break; + } } if (td->o.thinktime) { @@ -622,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) @@ -646,7 +700,7 @@ sync_done: td_set_runstate(td, TD_FSYNCING); for_each_file(td, f, i) { - if (!(f->flags & FIO_FILE_OPEN)) + if (!fio_file_open(f)) continue; fio_io_sync(td, f); } @@ -680,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; @@ -708,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); @@ -727,8 +791,6 @@ static int init_io_u(struct thread_data *td) flist_add(&io_u->list, &td->io_u_freelist); } - io_u_init_timeout(); - return 0; } @@ -809,12 +871,8 @@ static int keep_running(struct thread_data *td) return 0; } -static int clear_io_state(struct thread_data *td) +static void reset_io_counters(struct thread_data *td) { - struct fio_file *f; - unsigned int i; - int ret; - td->ts.stat_io_bytes[0] = td->ts.stat_io_bytes[1] = 0; td->this_io_bytes[0] = td->this_io_bytes[1] = 0; td->zone_bytes = 0; @@ -830,16 +888,56 @@ static int clear_io_state(struct thread_data *td) if (td->o.time_based || td->o.loops) td->nr_done_files = 0; - close_files(td); + /* + * Set the same seed to get repeatable runs + */ + td_fill_rand_seeds(td); +} - ret = 0; - for_each_file(td, f, i) { - f->flags &= ~FIO_FILE_DONE; - ret = td_io_open_file(td, f); - if (ret) - break; +void reset_all_stats(struct thread_data *td) +{ + struct timeval tv; + int i; + + reset_io_counters(td); + + for (i = 0; i < 2; i++) { + td->io_bytes[i] = 0; + td->io_blocks[i] = 0; + td->io_issues[i] = 0; + td->ts.total_io_u[i] = 0; } + + fio_gettime(&tv, NULL); + memcpy(&td->epoch, &tv, sizeof(tv)); + memcpy(&td->start, &tv, sizeof(tv)); +} + +static void clear_io_state(struct thread_data *td) +{ + struct fio_file *f; + unsigned int i; + + reset_io_counters(td); + close_files(td); + for_each_file(td, f, i) + fio_file_clear_done(f); +} + +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; } @@ -868,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 @@ -892,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"); @@ -913,19 +1026,20 @@ 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; } fio_gettime(&td->epoch, NULL); - memcpy(&td->timeout_end, &td->epoch, sizeof(td->epoch)); getrusage(RUSAGE_SELF, &td->ts.ru_start); runtime[0] = runtime[1] = 0; @@ -933,13 +1047,14 @@ static void *thread_main(void *data) while (keep_running(td)) { fio_gettime(&td->start, NULL); memcpy(&td->ts.stat_sample_time, &td->start, sizeof(td->start)); + memcpy(&td->tv_cache, &td->start, sizeof(td->start)); if (td->o.ratemin) 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); @@ -974,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); @@ -994,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); @@ -1016,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 */ @@ -1145,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. */ @@ -1157,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) @@ -1260,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"); @@ -1280,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"); } /* @@ -1329,7 +1515,10 @@ static void run_threads(void) if (td->runstate != TD_INITIALIZED) continue; - td_set_runstate(td, TD_RUNNING); + if (in_ramp_time(td)) + td_set_runstate(td, TD_RAMP); + else + td_set_runstate(td, TD_RUNNING); nr_running++; nr_started--; m_rate += td->o.ratemin; @@ -1387,6 +1576,7 @@ int main(int argc, char *argv[]) } startup_mutex = fio_mutex_init(0); + writeout_mutex = fio_mutex_init(1); set_genesis_time(); @@ -1404,5 +1594,6 @@ int main(int argc, char *argv[]) } fio_mutex_remove(startup_mutex); + fio_mutex_remove(writeout_mutex); return exit_value; }