X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=a2651f0325490d780ee7a9352fa01d53b81350b5;hp=82f321bfee82ccb9ff46f48f7bd0aeed07f217d2;hb=b902ceb53977a12062c615ab529ca0c3422e3cff;hpb=a71e13bb81c7943d9524e26cbad9534519ca6e2e diff --git a/fio.c b/fio.c index 82f321bf..a2651f03 100644 --- a/fio.c +++ b/fio.c @@ -2,6 +2,7 @@ * fio - the flexible io tester * * Copyright (C) 2005 Jens Axboe + * Copyright (C) 2006 Jens Axboe * * 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 @@ -103,6 +104,10 @@ static void sig_handler(int sig) } } +/* + * The ->file_map[] contains a map of blocks we have or have not done io + * to yet. Used to make sure we cover the entire range in a fair fashion. + */ static int random_map_free(struct thread_data *td, unsigned long long block) { unsigned int idx = RAND_MAP_IDX(td, block); @@ -111,6 +116,9 @@ static int random_map_free(struct thread_data *td, unsigned long long block) return (td->file_map[idx] & (1UL << bit)) == 0; } +/* + * Return the next free block in the map. + */ static int get_next_free_block(struct thread_data *td, unsigned long long *b) { int i; @@ -130,6 +138,9 @@ static int get_next_free_block(struct thread_data *td, unsigned long long *b) return 1; } +/* + * Mark a given offset as used in the map. + */ static void mark_random_map(struct thread_data *td, struct io_u *io_u) { unsigned long long block = io_u->offset / (unsigned long long) td->min_bs; @@ -155,6 +166,11 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u) io_u->buflen = blocks * td->min_bs; } +/* + * For random io, generate a random new block and see if it's used. Repeat + * until we find a free one. For sequential io, just return the end of + * the last io issued. + */ static int get_next_offset(struct thread_data *td, unsigned long long *offset) { unsigned long long b, rb; @@ -204,6 +220,9 @@ static unsigned int get_next_buflen(struct thread_data *td) return buflen; } +/* + * Check if we are above the minimum rate given. + */ static int check_min_rate(struct thread_data *td, struct timeval *now) { unsigned long spent; @@ -352,6 +371,11 @@ static void fill_md5(struct verify_header *hdr, void *p, unsigned int len) memcpy(hdr->md5_digest, md5_ctx.hash, sizeof(md5_ctx.hash)); } +/* + * Return the data direction for the next io_u. If the job is a + * mixed read/write workload, check the rwmix cycle and switch if + * necessary. + */ static int get_rw_ddir(struct thread_data *td) { if (td_rw(td)) { @@ -410,7 +434,7 @@ static void populate_io_u(struct thread_data *td, struct io_u *io_u) static int td_io_prep(struct thread_data *td, struct io_u *io_u) { - if (td->io_prep && td->io_prep(td, io_u)) + if (td->io_ops->prep && td->io_ops->prep(td, io_u)) return 1; return 0; @@ -472,6 +496,10 @@ struct io_u *__get_io_u(struct thread_data *td) return io_u; } +/* + * Return an io_u to be processed. Gets a buflen and offset, sets direction, + * etc. The returned io_u is fully ready to be prepped and submitted. + */ static struct io_u *get_io_u(struct thread_data *td) { struct io_u *io_u; @@ -541,8 +569,8 @@ static int get_next_verify(struct thread_data *td, struct io_u *io_u) static int sync_td(struct thread_data *td) { - if (td->io_sync) - return td->io_sync(td); + if (td->io_ops->sync) + return td->io_ops->sync(td); return 0; } @@ -550,14 +578,14 @@ static int sync_td(struct thread_data *td) static int io_u_getevents(struct thread_data *td, int min, int max, struct timespec *t) { - return td->io_getevents(td, min, max, t); + return td->io_ops->getevents(td, min, max, t); } static int io_u_queue(struct thread_data *td, struct io_u *io_u) { gettimeofday(&io_u->issue_time, NULL); - return td->io_queue(td, io_u); + return td->io_ops->queue(td, io_u); } #define iocb_time(iocb) ((unsigned long) (iocb)->data) @@ -601,13 +629,17 @@ static void ios_completed(struct thread_data *td,struct io_completion_data *icd) icd->bytes_done[0] = icd->bytes_done[1] = 0; for (i = 0; i < icd->nr; i++) { - io_u = td->io_event(td, i); + io_u = td->io_ops->event(td, i); io_completed(td, io_u, icd); put_io_u(td, io_u); } } +/* + * When job exits, we can cancel the in-flight IO if we are using async + * io. Attempt to do so. + */ static void cleanup_pending_aio(struct thread_data *td) { struct timespec ts = { .tv_sec = 0, .tv_nsec = 0}; @@ -628,11 +660,11 @@ static void cleanup_pending_aio(struct thread_data *td) /* * now cancel remaining active events */ - if (td->io_cancel) { + if (td->io_ops->cancel) { list_for_each_safe(entry, n, &td->io_u_busylist) { io_u = list_entry(entry, struct io_u, list); - r = td->io_cancel(td, io_u); + r = td->io_ops->cancel(td, io_u); if (!r) put_io_u(td, io_u); } @@ -661,6 +693,10 @@ static int do_io_u_verify(struct thread_data *td, struct io_u **io_u) return ret; } +/* + * The main verify engine. Runs over the writes we previusly submitted, + * reads the blocks back in, and checks the crc/md5 of the data. + */ static void do_verify(struct thread_data *td) { struct timeval t; @@ -713,7 +749,7 @@ static void do_verify(struct thread_data *td) break; } - v_io_u = td->io_event(td, 0); + v_io_u = td->io_ops->event(td, 0); icd.nr = 1; icd.error = 0; io_completed(td, v_io_u, &icd); @@ -742,7 +778,32 @@ static void do_verify(struct thread_data *td) } /* - * Main IO worker functions. It retrieves io_u's to process and queues + * Not really an io thread, all it does is burn CPU cycles in the specified + * manner. + */ +static void do_cpuio(struct thread_data *td) +{ + struct timeval e; + int split = 100 / td->cpuload; + int i = 0; + + while (!td->terminate) { + gettimeofday(&e, NULL); + + if (runtime_exceeded(td, &e)) + break; + + if (!(i % split)) + __usec_sleep(10000); + else + usec_sleep(td, 10000); + + i++; + } +} + +/* + * Main IO worker function. It retrieves io_u's to process and queues * and reaps them, checking for rate and errors along the way. */ static void do_io(struct thread_data *td) @@ -834,30 +895,12 @@ static void do_io(struct thread_data *td) } } -static void cleanup_io(struct thread_data *td) -{ - if (td->io_cleanup) - td->io_cleanup(td); -} - static int init_io(struct thread_data *td) { - if (td->io_engine == FIO_SYNCIO) - return fio_syncio_init(td); - else if (td->io_engine == FIO_MMAPIO) - return fio_mmapio_init(td); - else if (td->io_engine == FIO_LIBAIO) - return fio_libaio_init(td); - else if (td->io_engine == FIO_POSIXAIO) - return fio_posixaio_init(td); - else if (td->io_engine == FIO_SGIO) - return fio_sgio_init(td); - else if (td->io_engine == FIO_SPLICEIO) - return fio_spliceio_init(td); - else { - log_err("bad io_engine %d\n", td->io_engine); - return 1; - } + if (td->io_ops->init) + return td->io_ops->init(td); + + return 0; } static void cleanup_io_u(struct thread_data *td) @@ -893,7 +936,10 @@ static int init_io_u(struct thread_data *td) int i, max_units; char *p; - if (td->io_engine & FIO_SYNCIO) + if (td->io_ops->flags & FIO_CPUIO) + return 0; + + if (td->io_ops->flags & FIO_SYNCIO) max_units = 1; else max_units = td->iodepth; @@ -941,18 +987,17 @@ static int init_io_u(struct thread_data *td) return 0; } -static int create_file(struct thread_data *td, unsigned long long size, - int extend) +static int create_file(struct thread_data *td, unsigned long long size) { unsigned long long left; unsigned int bs; - int r, oflags; char *b; + int r; /* * unless specifically asked for overwrite, let normal io extend it */ - if (td_write(td) && !td->overwrite) { + if (!td->overwrite) { td->real_file_size = size; return 0; } @@ -964,22 +1009,15 @@ static int create_file(struct thread_data *td, unsigned long long size, } temp_stall_ts = 1; + fprintf(f_out, "%s: Laying out IO file (%LuMiB)\n",td->name,size >> 20); - if (!extend) { - oflags = O_CREAT | O_TRUNC; - fprintf(f_out, "%s: Laying out IO file (%LuMiB)\n", td->name, size >> 20); - } else { - oflags = O_APPEND; - fprintf(f_out, "%s: Extending IO file (%Lu -> %LuMiB)\n", td->name, (td->file_size - size) >> 20, td->file_size >> 20); - } - - td->fd = open(td->file_name, O_WRONLY | oflags, 0644); + td->fd = open(td->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (td->fd < 0) { td_verror(td, errno); goto done_noclose; } - if (!extend && ftruncate(td->fd, td->file_size) == -1) { + if (ftruncate(td->fd, td->file_size) == -1) { td_verror(td, errno); goto done; } @@ -1171,6 +1209,9 @@ static int setup_file(struct thread_data *td) struct stat st; int flags = 0; + if (td->io_ops->flags & FIO_CPUIO) + return 0; + if (stat(td->file_name, &st) == -1) { if (errno != ENOENT) { td_verror(td, errno); @@ -1180,13 +1221,12 @@ static int setup_file(struct thread_data *td) td_verror(td, ENOENT); return 1; } - if (create_file(td, td->file_size, 0)) + if (create_file(td, td->file_size)) + return 1; + } else if (td->filetype == FIO_TYPE_FILE && + st.st_size < (off_t) td->file_size) { + if (create_file(td, td->file_size)) return 1; - } else if (td->filetype == FIO_TYPE_FILE) { - if (st.st_size < (off_t) td->file_size) { - if (create_file(td, td->file_size, 1)) - return 1; - } } if (td->odirect) @@ -1222,10 +1262,10 @@ static int setup_file(struct thread_data *td) if (get_file_size(td)) return 1; - if (td->io_engine != FIO_MMAPIO) - return setup_file_plain(td); - else + if (td->io_ops->flags & FIO_MMAPIO) return setup_file_mmap(td); + else + return setup_file_plain(td); } static int switch_ioscheduler(struct thread_data *td) @@ -1278,7 +1318,7 @@ static int switch_ioscheduler(struct thread_data *td) static void clear_io_state(struct thread_data *td) { - if (td->io_engine == FIO_SYNCIO) + if (td->io_ops->flags & FIO_SYNCIO) lseek(td->fd, SEEK_SET, 0); td->last_pos = 0; @@ -1290,6 +1330,10 @@ static void clear_io_state(struct thread_data *td) memset(td->file_map, 0, td->num_maps * sizeof(long)); } +/* + * Entry point for the thread based jobs. The process based jobs end up + * here as well, after a little setup. + */ static void *thread_main(void *data) { struct thread_data *td = data; @@ -1325,7 +1369,7 @@ static void *thread_main(void *data) } } - if (nice(td->nice) < 0) { + if (nice(td->nice) == -1) { td_verror(td, errno); goto err; } @@ -1359,7 +1403,10 @@ static void *thread_main(void *data) clear_io_state(td); prune_io_piece_log(td); - do_io(td); + if (td->io_ops->flags & FIO_CPUIO) + do_cpuio(td); + else + do_io(td); td->runtime[td->ddir] += mtime_since_now(&td->start); if (td_rw(td) && td->io_bytes[td->ddir ^ 1]) @@ -1405,13 +1452,17 @@ err: } if (td->mmap) munmap(td->mmap, td->file_size); - cleanup_io(td); + close_ioengine(td); cleanup_io_u(td); td_set_runstate(td, TD_EXITED); return NULL; } +/* + * We cannot pass the td data into a forked process, so attach the td and + * pass it to the thread worker. + */ static void *fork_main(int shmid, int offset) { struct thread_data *td; @@ -1429,6 +1480,9 @@ static void *fork_main(int shmid, int offset) return NULL; } +/* + * Sets the status of the 'td' in the printed status map. + */ static void check_str_update(struct thread_data *td) { char c = run_str[td->thread_number - 1]; @@ -1480,6 +1534,9 @@ static void check_str_update(struct thread_data *td) run_str[td->thread_number - 1] = c; } +/* + * Convert seconds to a printable string. + */ static void eta_to_str(char *str, int eta_sec) { unsigned int d, h, m, s; @@ -1508,6 +1565,9 @@ static void eta_to_str(char *str, int eta_sec) str += sprintf(str, "%02ds", s); } +/* + * Best effort calculation of the estimated pending runtime of a job. + */ static int thread_eta(struct thread_data *td, unsigned long elapsed) { unsigned long long bytes_total, bytes_done; @@ -1573,6 +1633,10 @@ static int thread_eta(struct thread_data *td, unsigned long elapsed) return eta_sec; } +/* + * Print status of the jobs we know about. This includes rate estimates, + * ETA, thread state, etc. + */ static void print_thread_status(void) { unsigned long elapsed = time_since_now(&genesis); @@ -1632,7 +1696,7 @@ static void print_thread_status(void) printf("Threads running: %d", nr_running); if (m_rate || t_rate) printf(", commitrate %d/%dKiB/sec", t_rate, m_rate); - if (eta_sec != INT_MAX) { + if (eta_sec != INT_MAX && nr_running) { perc *= 100.0; printf(": [%s] [%3.2f%% done] [eta %s]", run_str, perc,eta_str); } @@ -1641,16 +1705,22 @@ static void print_thread_status(void) free(eta_secs); } +/* + * Run over the job map and reap the threads that have exited, if any. + */ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) { - int i; + int i, cputhreads; /* * reap exited threads (TD_EXITED -> TD_REAPED) */ - for (i = 0; i < thread_number; i++) { + for (i = 0, cputhreads = 0; i < thread_number; i++) { struct thread_data *td = &threads[i]; + if (td->io_ops->flags & FIO_CPUIO) + cputhreads++; + if (td->runstate != TD_EXITED) continue; @@ -1668,6 +1738,9 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) (*m_rate) -= td->ratemin; (*t_rate) -= td->rate; } + + if (*nr_running == cputhreads) + terminate_threads(TERMINATE_ALL); } static void fio_unpin_memory(void *pinned) @@ -1712,6 +1785,9 @@ static void *fio_pin_memory(void) return ptr; } +/* + * Main function for kicking off and reaping jobs, as needed. + */ static void run_threads(void) { struct thread_data *td;