X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=87136141b0e34770851dbab53a942d9774eb6f48;hp=bdfbd827806502d5ee85e721b753d4dcb3683748;hb=74b025b071b5bfbffa7ad7682b66b749e8d1f955;hpb=b4a6a59a939f0e6554632de311e7d1d1b7633ccf diff --git a/fio.c b/fio.c index bdfbd827..87136141 100644 --- a/fio.c +++ b/fio.c @@ -4,10 +4,12 @@ * Copyright (C) 2005 Jens Axboe * Copyright (C) 2006 Jens Axboe * + * The license below covers all files distributed with fio unless otherwise + * noted in the file itself. + * * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -43,9 +45,6 @@ int groupid = 0; int thread_number = 0; int shm_id = 0; int temp_stall_ts; -char *fio_inst_prefix = _INST_PREFIX; - -#define should_fsync(td) ((td_write(td) || td_rw(td)) && (!(td)->odirect || (td)->override_sync)) static volatile int startup_sem; @@ -106,7 +105,7 @@ static int check_min_rate(struct thread_data *td, struct timeval *now) rate = (td->this_io_bytes[ddir] - td->rate_bytes) / spent; if (rate < td->ratemin) { - fprintf(f_out, "%s: min rate %d not met, got %ldKiB/sec\n", td->name, td->ratemin, rate); + fprintf(f_out, "%s: min rate %u not met, got %luKiB/sec\n", td->name, td->ratemin, rate); return 1; } } @@ -195,13 +194,56 @@ static void cleanup_pending_aio(struct thread_data *td) } } +/* + * Helper to handle the final sync of a file. Works just like the normal + * io path, just does everything sync. + */ +static int fio_io_sync(struct thread_data *td, struct fio_file *f) +{ + struct io_u *io_u = __get_io_u(td); + struct io_completion_data icd; + int ret; + + if (!io_u) + return 1; + + io_u->ddir = DDIR_SYNC; + io_u->file = f; + + if (td_io_prep(td, io_u)) { + put_io_u(td, io_u); + return 1; + } + + ret = td_io_queue(td, io_u); + if (ret) { + td_verror(td, io_u->error); + put_io_u(td, io_u); + return 1; + } + + ret = td_io_getevents(td, 1, td->cur_depth, NULL); + if (ret < 0) { + td_verror(td, ret); + return 1; + } + + icd.nr = ret; + ios_completed(td, &icd); + if (icd.error) { + td_verror(td, icd.error); + return 1; + } + + return 0; +} + /* * The main verify engine. Runs over the writes we previusly submitted, * reads the blocks back in, and checks the crc/md5 of the data. */ -void do_verify(struct thread_data *td) +static void do_verify(struct thread_data *td) { - struct timeval t; struct io_u *io_u, *v_io_u = NULL; struct io_completion_data icd; struct fio_file *f; @@ -212,7 +254,7 @@ void do_verify(struct thread_data *td) * read from disk. */ for_each_file(td, f, i) { - td_io_sync(td, f); + fio_io_sync(td, f); file_invalidate_cache(td, f); } @@ -222,14 +264,15 @@ void do_verify(struct thread_data *td) if (td->terminate) break; - gettimeofday(&t, NULL); - if (runtime_exceeded(td, &t)) - break; - io_u = __get_io_u(td); if (!io_u) break; + if (runtime_exceeded(td, &io_u->start_time)) { + put_io_u(td, io_u); + break; + } + if (get_next_verify(td, io_u)) { put_io_u(td, io_u); break; @@ -248,8 +291,8 @@ void do_verify(struct thread_data *td) ret = td_io_queue(td, io_u); if (ret) { + td_verror(td, io_u->error); put_io_u(td, io_u); - td_verror(td, ret); break; } @@ -270,6 +313,7 @@ void do_verify(struct thread_data *td) v_io_u = td->io_ops->event(td, 0); icd.nr = 1; icd.error = 0; + fio_gettime(&icd.time, NULL); io_completed(td, v_io_u, &icd); if (icd.error) { @@ -306,7 +350,7 @@ static void do_cpuio(struct thread_data *td) int i = 0; while (!td->terminate) { - gettimeofday(&e, NULL); + fio_gettime(&e, NULL); if (runtime_exceeded(td, &e)) break; @@ -327,7 +371,7 @@ static void do_cpuio(struct thread_data *td) static void do_io(struct thread_data *td) { struct io_completion_data icd; - struct timeval s, e; + struct timeval s; unsigned long usec; struct fio_file *f; int i, ret = 0; @@ -355,8 +399,8 @@ static void do_io(struct thread_data *td) ret = td_io_queue(td, io_u); if (ret) { + td_verror(td, io_u->error); put_io_u(td, io_u); - td_verror(td, ret); break; } @@ -372,7 +416,7 @@ static void do_io(struct thread_data *td) ret = td_io_getevents(td, min_evts, td->cur_depth, timeout); if (ret < 0) { - td_verror(td, -ret); + td_verror(td, ret); break; } else if (!ret) continue; @@ -389,37 +433,32 @@ static void do_io(struct thread_data *td) * of completions except the very first one which may look * a little bursty */ - gettimeofday(&e, NULL); - usec = utime_since(&s, &e); + usec = utime_since(&s, &icd.time); - rate_throttle(td, usec, icd.bytes_done[td->ddir]); + rate_throttle(td, usec, icd.bytes_done[td->ddir], td->ddir); - if (check_min_rate(td, &e)) { - if (rate_quit) + if (check_min_rate(td, &icd.time)) { + if (exitall_on_terminate) terminate_threads(td->groupid); td_verror(td, ENOMEM); break; } - if (runtime_exceeded(td, &e)) + if (runtime_exceeded(td, &icd.time)) break; if (td->thinktime) usec_sleep(td, td->thinktime); - - if (should_fsync(td) && td->fsync_blocks && - (td->io_blocks[DDIR_WRITE] % td->fsync_blocks) == 0) - td_io_sync(td, f); } - if (!ret) { + if (!td->error) { if (td->cur_depth) cleanup_pending_aio(td); if (should_fsync(td) && td->end_fsync) { td_set_runstate(td, TD_FSYNCING); for_each_file(td, f, i) - td_io_sync(td, f); + fio_io_sync(td, f); } } } @@ -439,9 +478,23 @@ static void cleanup_io_u(struct thread_data *td) free_io_mem(td); } +/* + * "randomly" fill the buffer contents + */ +static void fill_rand_buf(struct io_u *io_u, int max_bs) +{ + int *ptr = io_u->buf; + + while ((void *) ptr - io_u->buf < max_bs) { + *ptr = rand() * 0x9e370001; + ptr++; + } +} + static int init_io_u(struct thread_data *td) { struct io_u *io_u; + unsigned int max_bs; int i, max_units; char *p; @@ -453,7 +506,13 @@ static int init_io_u(struct thread_data *td) else max_units = td->iodepth; - td->orig_buffer_size = td->max_bs * max_units + MASK; + max_bs = max(td->max_bs[DDIR_READ], td->max_bs[DDIR_WRITE]); + td->orig_buffer_size = max_bs * max_units; + + if (td->mem_type == MEM_SHMHUGE) + td->orig_buffer_size = (td->orig_buffer_size + FIO_HUGE_PAGE - 1) & ~FIO_HUGE_PAGE; + else + td->orig_buffer_size += MASK; if (allocate_io_mem(td)) return 1; @@ -464,7 +523,10 @@ static int init_io_u(struct thread_data *td) memset(io_u, 0, sizeof(*io_u)); INIT_LIST_HEAD(&io_u->list); - io_u->buf = p + td->max_bs * i; + io_u->buf = p + max_bs * i; + if (td_write(td) || td_rw(td)) + fill_rand_buf(io_u, max_bs); + io_u->index = i; list_add(&io_u->list, &td->io_u_freelist); } @@ -478,6 +540,9 @@ static int switch_ioscheduler(struct thread_data *td) FILE *f; int ret; + if (td->io_ops->flags & FIO_CPUIO) + return 0; + sprintf(tmp, "%s/queue/scheduler", td->sysfs_root); f = fopen(tmp, "r+"); @@ -545,6 +610,7 @@ static void clear_io_state(struct thread_data *td) */ static void *thread_main(void *data) { + unsigned long long runtime[2]; struct thread_data *td = data; if (!td->use_thread) @@ -586,13 +652,8 @@ static void *thread_main(void *data) if (init_random_state(td)) goto err; - if (td->ioscheduler) { - int ret = switch_ioscheduler(td); - - free(td->ioscheduler); - if (ret) - goto err; - } + if (td->ioscheduler && switch_ioscheduler(td)) + goto err; td_set_runstate(td, TD_INITIALIZED); fio_sem_up(&startup_sem); @@ -600,17 +661,18 @@ static void *thread_main(void *data) if (!td->create_serialize && setup_files(td)) goto err; + if (open_files(td)) + goto err; - gettimeofday(&td->epoch, NULL); - - if (td->exec_prerun) { + if (td->exec_prerun) system(td->exec_prerun); - free(td->exec_prerun); - } + fio_gettime(&td->epoch, NULL); + getrusage(RUSAGE_SELF, &td->ru_start); + + runtime[0] = runtime[1] = 0; while (td->loops--) { - getrusage(RUSAGE_SELF, &td->ru_start); - gettimeofday(&td->start, NULL); + fio_gettime(&td->start, NULL); memcpy(&td->stat_sample_time, &td->start, sizeof(td->start)); if (td->ratemin) @@ -624,11 +686,9 @@ static void *thread_main(void *data) else do_io(td); - td->runtime[td->ddir] += mtime_since_now(&td->start); + runtime[td->ddir] += utime_since_now(&td->start); if (td_rw(td) && td->io_bytes[td->ddir ^ 1]) - td->runtime[td->ddir ^ 1] = td->runtime[td->ddir]; - - update_rusage_stat(td); + runtime[td->ddir ^ 1] = runtime[td->ddir]; if (td->error || td->terminate) break; @@ -637,28 +697,31 @@ static void *thread_main(void *data) continue; clear_io_state(td); - gettimeofday(&td->start, NULL); + fio_gettime(&td->start, NULL); do_verify(td); - td->runtime[DDIR_READ] += mtime_since_now(&td->start); + runtime[DDIR_READ] += utime_since_now(&td->start); if (td->error || td->terminate) break; } + update_rusage_stat(td); + fio_gettime(&td->end_time, NULL); + td->runtime[0] = runtime[0] / 1000; + td->runtime[1] = runtime[1] / 1000; + if (td->bw_log) finish_log(td, td->bw_log, "bw"); if (td->slat_log) finish_log(td, td->slat_log, "slat"); if (td->clat_log) finish_log(td, td->clat_log, "clat"); - if (td->write_iolog) + if (td->write_iolog_file) write_iolog_close(td); - if (td->exec_postrun) { + if (td->exec_postrun) system(td->exec_postrun); - free(td->exec_postrun); - } if (exitall_on_terminate) terminate_threads(td->groupid); @@ -699,12 +762,12 @@ static void *fork_main(int shmid, int offset) static void reap_threads(int *nr_running, int *t_rate, int *m_rate) { struct thread_data *td; - int i, cputhreads; + int i, cputhreads, pending; /* * reap exited threads (TD_EXITED -> TD_REAPED) */ - cputhreads = 0; + pending = cputhreads = 0; for_each_td(td, i) { /* * ->io_ops is NULL for a thread that has closed its @@ -713,8 +776,12 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) if (td->io_ops && td->io_ops->flags & FIO_CPUIO) cputhreads++; - if (td->runstate != TD_EXITED) + if (td->runstate != TD_EXITED) { + if (td->runstate < TD_RUNNING) + pending++; + continue; + } td_set_runstate(td, TD_REAPED); @@ -731,7 +798,7 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) (*t_rate) -= td->rate; } - if (*nr_running == cputhreads) + if (*nr_running == cputhreads && !pending) terminate_threads(TERMINATE_ALL); } @@ -779,8 +846,6 @@ static void run_threads(void) } } - time_init(); - while (todo) { struct thread_data *map[MAX_JOBS]; struct timeval this_start; @@ -840,7 +905,7 @@ static void run_threads(void) * Wait for the started threads to transition to * TD_INITIALIZED. */ - gettimeofday(&this_start, NULL); + fio_gettime(&this_start, NULL); left = this_jobs; while (left) { if (mtime_since_now(&this_start) > JOB_START_TIMEOUT)