[PATCH] Various little fixes and lots of commenting

[fio.git] / fio.c

diff --git a/fio.c b/fio.c
index 5bced2469ceaa217fbb67af80e9e29fc532f7582..412f00295b27f6aff1e190d8b2e0bd37d502133b 100644 (file)
--- a/fio.c
+++ b/fio.c
@@ -103,6 +103,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);
 static int random_map_free(struct thread_data *td, unsigned long long block)
 {
        unsigned int idx = RAND_MAP_IDX(td, block);


@@ -111,6 +115,9 @@ static int random_map_free(struct thread_data *td, unsigned long long block)
        return (td->file_map[idx] & (1UL << bit)) == 0;
 }
 
        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;
 static int get_next_free_block(struct thread_data *td, unsigned long long *b)
 {
        int i;


@@ -130,6 +137,9 @@ static int get_next_free_block(struct thread_data *td, unsigned long long *b)
        return 1;
 }
 
        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;
 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 +165,11 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u)
                io_u->buflen = blocks * td->min_bs;
 }
 
                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;
 static int get_next_offset(struct thread_data *td, unsigned long long *offset)
 {
        unsigned long long b, rb;


@@ -204,6 +219,9 @@ static unsigned int get_next_buflen(struct thread_data *td)
        return buflen;
 }
 
        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;
 static int check_min_rate(struct thread_data *td, struct timeval *now)
 {
        unsigned long spent;


@@ -352,6 +370,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));
 }
 
        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)) {
 static int get_rw_ddir(struct thread_data *td)
 {
        if (td_rw(td)) {


@@ -472,6 +495,10 @@ struct io_u *__get_io_u(struct thread_data *td)
        return io_u;
 }
 
        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;
 static struct io_u *get_io_u(struct thread_data *td)
 {
        struct io_u *io_u;


@@ -608,6 +635,10 @@ static void ios_completed(struct thread_data *td,struct io_completion_data *icd)
        }
 }
 
        }
 }
 

+/*
+ * 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};
 static void cleanup_pending_aio(struct thread_data *td)
 {
        struct timespec ts = { .tv_sec = 0, .tv_nsec = 0};


@@ -661,6 +692,10 @@ static int do_io_u_verify(struct thread_data *td, struct io_u **io_u)
        return ret;
 }
 
        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;
 static void do_verify(struct thread_data *td)
 {
        struct timeval t;


@@ -742,7 +777,7 @@ static void do_verify(struct thread_data *td)
 }
 
 /*
 }
 
 /*

- * Main IO worker functions. It retrieves io_u's to process and queues
+ * 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)
  * and reaps them, checking for rate and errors along the way.
  */
 static void do_io(struct thread_data *td)


@@ -1281,6 +1316,10 @@ static void clear_io_state(struct thread_data *td)
                memset(td->file_map, 0, td->num_maps * sizeof(long));
 }
 
                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;
 static void *thread_main(void *data)
 {
        struct thread_data *td = data;


@@ -1403,6 +1442,10 @@ err:
 
 }
 
 
 }
 

+/*
+ * 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;
 static void *fork_main(int shmid, int offset)
 {
        struct thread_data *td;


@@ -1420,6 +1463,9 @@ static void *fork_main(int shmid, int offset)
        return NULL;
 }
 
        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];
 static void check_str_update(struct thread_data *td)
 {
        char c = run_str[td->thread_number - 1];


@@ -1471,6 +1517,9 @@ static void check_str_update(struct thread_data *td)
        run_str[td->thread_number - 1] = c;
 }
 
        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;
 static void eta_to_str(char *str, int eta_sec)
 {
        unsigned int d, h, m, s;


@@ -1499,6 +1548,9 @@ static void eta_to_str(char *str, int eta_sec)
        str += sprintf(str, "%02ds", s);
 }
 
        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;
 static int thread_eta(struct thread_data *td, unsigned long elapsed)
 {
        unsigned long long bytes_total, bytes_done;


@@ -1564,6 +1616,10 @@ static int thread_eta(struct thread_data *td, unsigned long elapsed)
        return eta_sec;
 }
 
        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);
 static void print_thread_status(void)
 {
        unsigned long elapsed = time_since_now(&genesis);


@@ -1632,6 +1688,9 @@ static void print_thread_status(void)
        free(eta_secs);
 }
 
        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;
 static void reap_threads(int *nr_running, int *t_rate, int *m_rate)
 {
        int i;


@@ -1703,6 +1762,9 @@ static void *fio_pin_memory(void)
        return ptr;
 }
 
        return ptr;
 }
 

+/*
+ * Main function for kicking off and reaping jobs, as needed.
+ */

 static void run_threads(void)
 {
        struct thread_data *td;
 static void run_threads(void)
 {
        struct thread_data *td;