Yet another rate fixup
[fio.git] / fio.h
1 #ifndef FIO_H
2 #define FIO_H
3
4 #include <sched.h>
5 #include <limits.h>
6 #include <pthread.h>
7 #include <sys/time.h>
8 #include <sys/resource.h>
9 #include <errno.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <unistd.h>
13 #include <string.h>
14 #include <getopt.h>
15 #include <inttypes.h>
16 #include <assert.h>
17
18 #include "compiler/compiler.h"
19 #include "flist.h"
20 #include "fifo.h"
21 #include "rbtree.h"
22 #include "arch/arch.h"
23 #include "os/os.h"
24 #include "mutex.h"
25 #include "log.h"
26 #include "debug.h"
27 #include "file.h"
28 #include "io_ddir.h"
29 #include "ioengine.h"
30 #include "iolog.h"
31
32 #ifdef FIO_HAVE_GUASI
33 #include <guasi.h>
34 #endif
35
36 #ifdef FIO_HAVE_SOLARISAIO
37 #include <sys/asynch.h>
38 #endif
39
40 struct group_run_stats {
41         unsigned long long max_run[2], min_run[2];
42         unsigned long long max_bw[2], min_bw[2];
43         unsigned long long io_kb[2];
44         unsigned long long agg[2];
45 };
46
47 /*
48  * What type of allocation to use for io buffers
49  */
50 enum fio_memtype {
51         MEM_MALLOC = 0, /* ordinary malloc */
52         MEM_SHM,        /* use shared memory segments */
53         MEM_SHMHUGE,    /* use shared memory segments with huge pages */
54         MEM_MMAP,       /* use anonynomous mmap */
55         MEM_MMAPHUGE,   /* memory mapped huge file */
56 };
57
58 /*
59  * How many depth levels to log
60  */
61 #define FIO_IO_U_MAP_NR 8
62 #define FIO_IO_U_LAT_U_NR 10
63 #define FIO_IO_U_LAT_M_NR 12
64
65 struct thread_stat {
66         char *name;
67         char *verror;
68         int error;
69         int groupid;
70         pid_t pid;
71         char *description;
72         int members;
73
74         struct io_log *slat_log;
75         struct io_log *clat_log;
76         struct io_log *bw_log;
77
78         /*
79          * bandwidth and latency stats
80          */
81         struct io_stat clat_stat[2];            /* completion latency */
82         struct io_stat slat_stat[2];            /* submission latency */
83         struct io_stat bw_stat[2];              /* bandwidth stats */
84
85         unsigned long long stat_io_bytes[2];
86         struct timeval stat_sample_time[2];
87
88         /*
89          * fio system usage accounting
90          */
91         struct rusage ru_start;
92         struct rusage ru_end;
93         unsigned long usr_time;
94         unsigned long sys_time;
95         unsigned long ctx;
96         unsigned long minf, majf;
97
98         /*
99          * IO depth and latency stats
100          */
101         unsigned int io_u_map[FIO_IO_U_MAP_NR];
102         unsigned int io_u_submit[FIO_IO_U_MAP_NR];
103         unsigned int io_u_complete[FIO_IO_U_MAP_NR];
104         unsigned int io_u_lat_u[FIO_IO_U_LAT_U_NR];
105         unsigned int io_u_lat_m[FIO_IO_U_LAT_M_NR];
106         unsigned long total_io_u[2];
107         unsigned long short_io_u[2];
108         unsigned long total_submit;
109         unsigned long total_complete;
110
111         unsigned long long io_bytes[2];
112         unsigned long runtime[2];
113         unsigned long total_run_time;
114 };
115
116 struct bssplit {
117         unsigned int bs;
118         unsigned char perc;
119 };
120
121 struct thread_options {
122         int pad;
123         char *description;
124         char *name;
125         char *directory;
126         char *filename;
127         char *opendir;
128         char *ioengine;
129         enum td_ddir td_ddir;
130         unsigned int ddir_nr;
131         unsigned int iodepth;
132         unsigned int iodepth_low;
133         unsigned int iodepth_batch;
134         unsigned int iodepth_batch_complete;
135
136         unsigned long long size;
137         unsigned int fill_device;
138         unsigned long long file_size_low;
139         unsigned long long file_size_high;
140         unsigned long long start_offset;
141
142         unsigned int bs[2];
143         unsigned int ba[2];
144         unsigned int min_bs[2];
145         unsigned int max_bs[2];
146         struct bssplit *bssplit[2];
147         unsigned int bssplit_nr[2];
148
149         unsigned int nr_files;
150         unsigned int open_files;
151         enum file_lock_mode file_lock_mode;
152         unsigned int lockfile_batch;
153
154         unsigned int odirect;
155         unsigned int invalidate_cache;
156         unsigned int create_serialize;
157         unsigned int create_fsync;
158         unsigned int create_on_open;
159         unsigned int end_fsync;
160         unsigned int pre_read;
161         unsigned int sync_io;
162         unsigned int verify;
163         unsigned int do_verify;
164         unsigned int verifysort;
165         unsigned int verify_interval;
166         unsigned int verify_offset;
167         unsigned int verify_pattern;
168         unsigned int verify_pattern_bytes;
169         unsigned int verify_fatal;
170         unsigned int use_thread;
171         unsigned int unlink;
172         unsigned int do_disk_util;
173         unsigned int override_sync;
174         unsigned int rand_repeatable;
175         unsigned int write_lat_log;
176         unsigned int write_bw_log;
177         unsigned int norandommap;
178         unsigned int softrandommap;
179         unsigned int bs_unaligned;
180         unsigned int fsync_on_close;
181
182         unsigned int hugepage_size;
183         unsigned int rw_min_bs;
184         unsigned int thinktime;
185         unsigned int thinktime_spin;
186         unsigned int thinktime_blocks;
187         unsigned int fsync_blocks;
188         unsigned int start_delay;
189         unsigned long long timeout;
190         unsigned long long ramp_time;
191         unsigned int overwrite;
192         unsigned int bw_avg_time;
193         unsigned int loops;
194         unsigned long long zone_size;
195         unsigned long long zone_skip;
196         enum fio_memtype mem_type;
197
198         unsigned int stonewall;
199         unsigned int new_group;
200         unsigned int numjobs;
201         os_cpu_mask_t cpumask;
202         unsigned int cpumask_set;
203         unsigned int iolog;
204         unsigned int rwmixcycle;
205         unsigned int rwmix[2];
206         unsigned int nice;
207         unsigned int file_service_type;
208         unsigned int group_reporting;
209         unsigned int fadvise_hint;
210         unsigned int zero_buffers;
211         unsigned int refill_buffers;
212         unsigned int time_based;
213         unsigned int disable_clat;
214         unsigned int disable_slat;
215         unsigned int disable_bw;
216         unsigned int gtod_reduce;
217         unsigned int gtod_cpu;
218         unsigned int gtod_offload;
219
220         char *read_iolog_file;
221         char *write_iolog_file;
222         char *bw_log_file;
223         char *lat_log_file;
224
225         /*
226          * Pre-run and post-run shell
227          */
228         char *exec_prerun;
229         char *exec_postrun;
230
231         unsigned int rate[2];
232         unsigned int ratemin[2];
233         unsigned int ratecycle;
234         unsigned int rate_iops[2];
235         unsigned int rate_iops_min[2];
236
237         char *ioscheduler;
238
239         /*
240          * CPU "io" cycle burner
241          */
242         unsigned int cpuload;
243         unsigned int cpucycle;
244 };
245
246 #define FIO_VERROR_SIZE 128
247
248 /*
249  * This describes a single thread/process executing a fio job.
250  */
251 struct thread_data {
252         struct thread_options o;
253         char verror[FIO_VERROR_SIZE];
254         pthread_t thread;
255         int thread_number;
256         int groupid;
257         struct thread_stat ts;
258         struct fio_file **files;
259         unsigned int files_size;
260         unsigned int files_index;
261         unsigned int nr_open_files;
262         unsigned int nr_done_files;
263         unsigned int nr_normal_files;
264         union {
265                 unsigned int next_file;
266                 os_random_state_t next_file_state;
267         };
268         int error;
269         int done;
270         pid_t pid;
271         char *orig_buffer;
272         size_t orig_buffer_size;
273         volatile int terminate;
274         volatile int runstate;
275         unsigned int ioprio;
276         unsigned int ioprio_set;
277         unsigned int last_was_sync;
278
279         char *mmapfile;
280         int mmapfd;
281
282         void *iolog_buf;
283         FILE *iolog_f;
284
285         char *sysfs_root;
286
287         unsigned long rand_seeds[6];
288
289         os_random_state_t bsrange_state;
290         os_random_state_t verify_state;
291
292         int shm_id;
293
294         /*
295          * IO engine hooks, contains everything needed to submit an io_u
296          * to any of the available IO engines.
297          */
298         struct ioengine_ops *io_ops;
299
300         /*
301          * Current IO depth and list of free and busy io_u's.
302          */
303         unsigned int cur_depth;
304         unsigned int io_u_queued;
305         struct flist_head io_u_freelist;
306         struct flist_head io_u_busylist;
307         struct flist_head io_u_requeues;
308
309         /*
310          * Rate state
311          */
312         unsigned long rate_usec_cycle[2];
313         long rate_pending_usleep[2];
314         unsigned long rate_bytes[2];
315         unsigned long rate_blocks[2];
316         struct timeval lastrate[2];
317
318         unsigned long long total_io_size;
319
320         unsigned long io_issues[2];
321         unsigned long long io_blocks[2];
322         unsigned long long io_bytes[2];
323         unsigned long long io_skip_bytes;
324         unsigned long long this_io_bytes[2];
325         unsigned long long zone_bytes;
326         struct fio_mutex *mutex;
327
328         /*
329          * State for random io, a bitmap of blocks done vs not done
330          */
331         os_random_state_t random_state;
332
333         struct timeval start;   /* start of this loop */
334         struct timeval epoch;   /* time job was started */
335         struct timeval last_issue;
336         struct timeval tv_cache;
337         unsigned int tv_cache_nr;
338         unsigned int tv_cache_mask;
339         unsigned int ramp_time_over;
340
341         /*
342          * read/write mixed workload state
343          */
344         os_random_state_t rwmix_state;
345         unsigned long rwmix_issues;
346         enum fio_ddir rwmix_ddir;
347         unsigned int ddir_nr;
348
349         /*
350          * IO history logs for verification. We use a tree for sorting,
351          * if we are overwriting. Otherwise just use a fifo.
352          */
353         struct rb_root io_hist_tree;
354         struct flist_head io_hist_list;
355
356         /*
357          * For IO replaying
358          */
359         struct flist_head io_log_list;
360
361         /*
362          * for fileservice, how often to switch to a new file
363          */
364         unsigned int file_service_nr;
365         unsigned int file_service_left;
366         struct fio_file *file_service_file;
367
368         /*
369          * For generating file sizes
370          */
371         os_random_state_t file_size_state;
372 };
373
374 /*
375  * when should interactive ETA output be generated
376  */
377 enum {
378         FIO_ETA_AUTO,
379         FIO_ETA_ALWAYS,
380         FIO_ETA_NEVER,
381 };
382
383 #define __td_verror(td, err, msg, func)                                 \
384         do {                                                            \
385                 if ((td)->error)                                        \
386                         break;                                          \
387                 int e = (err);                                          \
388                 (td)->error = e;                                        \
389                 snprintf(td->verror, sizeof(td->verror) - 1, "file:%s:%d, func=%s, error=%s", __FILE__, __LINE__, (func), (msg));       \
390         } while (0)
391
392
393 #define td_verror(td, err, func)        \
394         __td_verror((td), (err), strerror((err)), (func))
395 #define td_vmsg(td, err, msg, func)     \
396         __td_verror((td), (err), (msg), (func))
397
398 extern int exitall_on_terminate;
399 extern int thread_number;
400 extern int nr_process, nr_thread;
401 extern int shm_id;
402 extern int groupid;
403 extern int terse_output;
404 extern int temp_stall_ts;
405 extern unsigned long long mlock_size;
406 extern unsigned long page_mask, page_size;
407 extern int read_only;
408 extern int eta_print;
409 extern unsigned long done_secs;
410 extern char *job_section;
411 extern int fio_gtod_offload;
412 extern int fio_gtod_cpu;
413
414 extern struct thread_data *threads;
415
416 static inline void fio_ro_check(struct thread_data *td, struct io_u *io_u)
417 {
418         assert(!(io_u->ddir == DDIR_WRITE && !td_write(td)));
419 }
420
421 #define BLOCKS_PER_MAP          (8 * sizeof(int))
422 #define TO_MAP_BLOCK(f, b)      (b)
423 #define RAND_MAP_IDX(f, b)      (TO_MAP_BLOCK(f, b) / BLOCKS_PER_MAP)
424 #define RAND_MAP_BIT(f, b)      (TO_MAP_BLOCK(f, b) & (BLOCKS_PER_MAP - 1))
425
426 #define MAX_JOBS        (1024)
427
428 static inline int should_fsync(struct thread_data *td)
429 {
430         if (td->last_was_sync)
431                 return 0;
432         if (td->o.odirect)
433                 return 0;
434         if (td_write(td) || td_rw(td) || td->o.override_sync)
435                 return 1;
436
437         return 0;
438 }
439
440 /*
441  * Time functions
442  */
443 extern unsigned long long utime_since(struct timeval *, struct timeval *);
444 extern unsigned long long utime_since_now(struct timeval *);
445 extern unsigned long mtime_since(struct timeval *, struct timeval *);
446 extern unsigned long mtime_since_now(struct timeval *);
447 extern unsigned long time_since_now(struct timeval *);
448 extern unsigned long mtime_since_genesis(void);
449 extern void usec_spin(unsigned int);
450 extern void usec_sleep(struct thread_data *, unsigned long);
451 extern void fill_start_time(struct timeval *);
452 extern void fio_gettime(struct timeval *, void *);
453 extern void fio_gtod_init(void);
454 extern void fio_gtod_update(void);
455 extern void set_genesis_time(void);
456 extern int ramp_time_over(struct thread_data *);
457 extern int in_ramp_time(struct thread_data *);
458
459 /*
460  * Init/option functions
461  */
462 extern int __must_check parse_options(int, char **);
463 extern int fio_options_parse(struct thread_data *, char **, int);
464 extern int fio_cmd_option_parse(struct thread_data *, const char *, char *);
465 extern void fio_fill_default_options(struct thread_data *);
466 extern int fio_show_option_help(const char *);
467 extern void fio_options_dup_and_init(struct option *);
468 extern void options_mem_dupe(struct thread_data *);
469 extern void options_mem_free(struct thread_data *);
470 extern void td_fill_rand_seeds(struct thread_data *);
471 #define FIO_GETOPT_JOB          0x89988998
472 #define FIO_NR_OPTIONS          128
473
474 /*
475  * ETA/status stuff
476  */
477 extern void print_thread_status(void);
478 extern void print_status_init(int);
479
480 /*
481  * Thread life cycle. Once a thread has a runstate beyond TD_INITIALIZED, it
482  * will never back again. It may cycle between running/verififying/fsyncing.
483  * Once the thread reaches TD_EXITED, it is just waiting for the core to
484  * reap it.
485  */
486 enum {
487         TD_NOT_CREATED = 0,
488         TD_CREATED,
489         TD_INITIALIZED,
490         TD_RAMP,
491         TD_RUNNING,
492         TD_PRE_READING,
493         TD_VERIFYING,
494         TD_FSYNCING,
495         TD_EXITED,
496         TD_REAPED,
497 };
498
499 extern void td_set_runstate(struct thread_data *, int);
500
501 /*
502  * Memory helpers
503  */
504 extern int __must_check fio_pin_memory(void);
505 extern void fio_unpin_memory(void);
506 extern int __must_check allocate_io_mem(struct thread_data *);
507 extern void free_io_mem(struct thread_data *);
508
509 /*
510  * Reset stats after ramp time completes
511  */
512 extern void reset_all_stats(struct thread_data *);
513
514 /*
515  * blktrace support
516  */
517 #ifdef FIO_HAVE_BLKTRACE
518 extern int is_blktrace(const char *);
519 extern int load_blktrace(struct thread_data *, const char *);
520 #endif
521
522 /*
523  * Mark unused variables passed to ops functions as unused, to silence gcc
524  */
525 #define fio_unused      __attribute((__unused__))
526 #define fio_init        __attribute__((constructor))
527 #define fio_exit        __attribute__((destructor))
528
529 #define for_each_td(td, i)      \
530         for ((i) = 0, (td) = &threads[0]; (i) < (int) thread_number; (i)++, (td)++)
531 #define for_each_file(td, f, i) \
532         if ((td)->files_index)                                          \
533                 for ((i) = 0, (f) = (td)->files[0];                     \
534                  (i) < (td)->o.nr_files && ((f) = (td)->files[i]) != NULL; \
535                  (i)++)
536
537 #define fio_assert(td, cond)    do {    \
538         if (!(cond)) {                  \
539                 int *__foo = NULL;      \
540                 fprintf(stderr, "file:%s:%d, assert %s failed\n", __FILE__, __LINE__, #cond);   \
541                 (td)->runstate = TD_EXITED;     \
542                 (td)->error = EFAULT;           \
543                 *__foo = 0;                     \
544         }       \
545 } while (0)
546
547 static inline int fio_fill_issue_time(struct thread_data *td)
548 {
549         if (td->o.read_iolog_file ||
550             !td->o.disable_clat || !td->o.disable_slat || !td->o.disable_bw)
551                 return 1;
552
553         return 0;
554 }
555
556 /*
557  * Cheesy number->string conversion, complete with carry rounding error.
558  */
559 static inline char *num2str(unsigned long num, int maxlen, int base, int pow2)
560 {
561         char postfix[] = { ' ', 'K', 'M', 'G', 'P', 'E' };
562         unsigned int thousand;
563         char *buf;
564         int i;
565
566         if (pow2)
567                 thousand = 1024;
568         else
569                 thousand = 1000;
570
571         buf = malloc(128);
572
573         for (i = 0; base > 1; i++)
574                 base /= thousand;
575
576         do {
577                 int len, carry = 0;
578
579                 len = sprintf(buf, "%'lu", num);
580                 if (len <= maxlen) {
581                         if (i >= 1) {
582                                 buf[len] = postfix[i];
583                                 buf[len + 1] = '\0';
584                         }
585                         return buf;
586                 }
587
588                 if ((num % thousand) >= (thousand / 2))
589                         carry = 1;
590
591                 num /= thousand;
592                 num += carry;
593                 i++;
594         } while (i <= 5);
595
596         return buf;
597 }
598
599 static inline int __should_check_rate(struct thread_data *td,
600                                       enum fio_ddir ddir)
601 {
602         struct thread_options *o = &td->o;
603
604         /*
605          * If some rate setting was given, we need to check it
606          */
607         if (o->rate[ddir] || o->ratemin[ddir] || o->rate_iops[ddir] ||
608             o->rate_iops_min[ddir])
609                 return 1;
610
611         return 0;
612 }
613
614 static inline int should_check_rate(struct thread_data *td,
615                                     unsigned long *bytes_done)
616 {
617         int ret = 0;
618
619         if (bytes_done[0])
620                 ret |= __should_check_rate(td, 0);
621         if (bytes_done[1])
622                 ret |= __should_check_rate(td, 1);
623
624         return ret;
625 }
626
627 #endif