Merge branch 'asmfix' of https://github.com/oohal/fio
[fio.git] / iolog.h
1 #ifndef FIO_IOLOG_H
2 #define FIO_IOLOG_H
3
4 #include "lib/rbtree.h"
5 #include "lib/ieee754.h"
6 #include "flist.h"
7 #include "ioengines.h"
8
9 /*
10  * Use for maintaining statistics
11  */
12 struct io_stat {
13         uint64_t max_val;
14         uint64_t min_val;
15         uint64_t samples;
16
17         fio_fp64_t mean;
18         fio_fp64_t S;
19 };
20
21 struct io_hist {
22         uint64_t samples;
23         unsigned long hist_last;
24         struct flist_head list;
25 };
26
27
28 union io_sample_data {
29         uint64_t val;
30         struct io_u_plat_entry *plat_entry;
31 };
32
33 #define sample_val(value) ((union io_sample_data) { .val = value })
34 #define sample_plat(plat) ((union io_sample_data) { .plat_entry = plat })
35
36 /*
37  * A single data sample
38  */
39 struct io_sample {
40         uint64_t time;
41         union io_sample_data data;
42         uint32_t __ddir;
43         uint32_t bs;
44 };
45
46 struct io_sample_offset {
47         struct io_sample s;
48         uint64_t offset;
49 };
50
51 enum {
52         IO_LOG_TYPE_LAT = 1,
53         IO_LOG_TYPE_CLAT,
54         IO_LOG_TYPE_SLAT,
55         IO_LOG_TYPE_BW,
56         IO_LOG_TYPE_IOPS,
57         IO_LOG_TYPE_HIST,
58 };
59
60 #define DEF_LOG_ENTRIES         1024
61 #define MAX_LOG_ENTRIES         (1024 * DEF_LOG_ENTRIES)
62
63 struct io_logs {
64         struct flist_head list;
65         uint64_t nr_samples;
66         uint64_t max_samples;
67         void *log;
68 };
69
70 /*
71  * Dynamically growing data sample log
72  */
73 struct io_log {
74         /*
75          * Entries already logged
76          */
77         struct flist_head io_logs;
78         uint32_t cur_log_max;
79
80         /*
81          * When the current log runs out of space, store events here until
82          * we have a chance to regrow
83          */
84         struct io_logs *pending;
85
86         unsigned int log_ddir_mask;
87
88         char *filename;
89
90         struct thread_data *td;
91
92         unsigned int log_type;
93
94         /*
95          * If we fail extending the log, stop collecting more entries.
96          */
97         bool disabled;
98
99         /*
100          * Log offsets
101          */
102         unsigned int log_offset;
103
104         /*
105          * Max size of log entries before a chunk is compressed
106          */
107         unsigned int log_gz;
108
109         /*
110          * Don't deflate for storing, just store the compressed bits
111          */
112         unsigned int log_gz_store;
113
114         /*
115          * Windowed average, for logging single entries average over some
116          * period of time.
117          */
118         struct io_stat avg_window[DDIR_RWDIR_CNT];
119         unsigned long avg_msec;
120         unsigned long avg_last;
121
122         /*
123          * Windowed latency histograms, for keeping track of when we need to
124          * save a copy of the histogram every approximately hist_msec
125          * milliseconds.
126          */
127         struct io_hist hist_window[DDIR_RWDIR_CNT];
128         unsigned long hist_msec;
129         unsigned int hist_coarseness;
130
131         pthread_mutex_t chunk_lock;
132         unsigned int chunk_seq;
133         struct flist_head chunk_list;
134
135         pthread_mutex_t deferred_free_lock;
136 #define IOLOG_MAX_DEFER 8
137         void *deferred_items[IOLOG_MAX_DEFER];
138         unsigned int deferred;
139 };
140
141 /*
142  * If the upper bit is set, then we have the offset as well
143  */
144 #define LOG_OFFSET_SAMPLE_BIT   0x80000000U
145 #define io_sample_ddir(io)      ((io)->__ddir & ~LOG_OFFSET_SAMPLE_BIT)
146
147 static inline void io_sample_set_ddir(struct io_log *log,
148                                       struct io_sample *io,
149                                       enum fio_ddir ddir)
150 {
151         io->__ddir = ddir | log->log_ddir_mask;
152 }
153
154 static inline size_t __log_entry_sz(int log_offset)
155 {
156         if (log_offset)
157                 return sizeof(struct io_sample_offset);
158         else
159                 return sizeof(struct io_sample);
160 }
161
162 static inline size_t log_entry_sz(struct io_log *log)
163 {
164         return __log_entry_sz(log->log_offset);
165 }
166
167 static inline size_t log_sample_sz(struct io_log *log, struct io_logs *cur_log)
168 {
169         return cur_log->nr_samples * log_entry_sz(log);
170 }
171
172 static inline struct io_sample *__get_sample(void *samples, int log_offset,
173                                              uint64_t sample)
174 {
175         uint64_t sample_offset = sample * __log_entry_sz(log_offset);
176         return (struct io_sample *) ((char *) samples + sample_offset);
177 }
178
179 struct io_logs *iolog_cur_log(struct io_log *);
180 uint64_t iolog_nr_samples(struct io_log *);
181 void regrow_logs(struct thread_data *);
182
183 static inline struct io_sample *get_sample(struct io_log *iolog,
184                                            struct io_logs *cur_log,
185                                            uint64_t sample)
186 {
187         return __get_sample(cur_log->log, iolog->log_offset, sample);
188 }
189
190 enum {
191         IP_F_ONRB       = 1,
192         IP_F_ONLIST     = 2,
193         IP_F_TRIMMED    = 4,
194         IP_F_IN_FLIGHT  = 8,
195 };
196
197 /*
198  * When logging io actions, this matches a single sent io_u
199  */
200 struct io_piece {
201         union {
202                 struct rb_node rb_node;
203                 struct flist_head list;
204         };
205         struct flist_head trim_list;
206         union {
207                 int fileno;
208                 struct fio_file *file;
209         };
210         unsigned long long offset;
211         unsigned short numberio;
212         unsigned long len;
213         unsigned int flags;
214         enum fio_ddir ddir;
215         union {
216                 unsigned long delay;
217                 unsigned int file_action;
218         };
219 };
220
221 /*
222  * Log exports
223  */
224 enum file_log_act {
225         FIO_LOG_ADD_FILE,
226         FIO_LOG_OPEN_FILE,
227         FIO_LOG_CLOSE_FILE,
228         FIO_LOG_UNLINK_FILE,
229 };
230
231 struct io_u;
232 extern int __must_check read_iolog_get(struct thread_data *, struct io_u *);
233 extern void log_io_u(const struct thread_data *, const struct io_u *);
234 extern void log_file(struct thread_data *, struct fio_file *, enum file_log_act);
235 extern int __must_check init_iolog(struct thread_data *td);
236 extern void log_io_piece(struct thread_data *, struct io_u *);
237 extern void unlog_io_piece(struct thread_data *, struct io_u *);
238 extern void trim_io_piece(struct thread_data *, const struct io_u *);
239 extern void queue_io_piece(struct thread_data *, struct io_piece *);
240 extern void prune_io_piece_log(struct thread_data *);
241 extern void write_iolog_close(struct thread_data *);
242 extern int iolog_compress_init(struct thread_data *, struct sk_out *);
243 extern void iolog_compress_exit(struct thread_data *);
244 extern size_t log_chunk_sizes(struct io_log *);
245
246 #ifdef CONFIG_ZLIB
247 extern int iolog_file_inflate(const char *);
248 #endif
249
250 /*
251  * Logging
252  */
253 struct log_params {
254         struct thread_data *td;
255         unsigned long avg_msec;
256         unsigned long hist_msec;
257         int hist_coarseness;
258         int log_type;
259         int log_offset;
260         int log_gz;
261         int log_gz_store;
262         int log_compress;
263 };
264
265 static inline bool per_unit_log(struct io_log *log)
266 {
267         return log && (!log->avg_msec || log->log_gz || log->log_gz_store);
268 }
269
270 static inline bool inline_log(struct io_log *log)
271 {
272         return log->log_type == IO_LOG_TYPE_LAT ||
273                 log->log_type == IO_LOG_TYPE_CLAT ||
274                 log->log_type == IO_LOG_TYPE_SLAT;
275 }
276
277 static inline void ipo_bytes_align(unsigned int replay_align, struct io_piece *ipo)
278 {
279         if (!replay_align)
280                 return;
281
282         ipo->offset &= ~(replay_align - (uint64_t)1);
283 }
284
285 extern void finalize_logs(struct thread_data *td, bool);
286 extern void setup_log(struct io_log **, struct log_params *, const char *);
287 extern void flush_log(struct io_log *, bool);
288 extern void flush_samples(FILE *, void *, uint64_t);
289 extern unsigned long hist_sum(int, int, unsigned int *, unsigned int *);
290 extern void free_log(struct io_log *);
291 extern void fio_writeout_logs(bool);
292 extern void td_writeout_logs(struct thread_data *, bool);
293 extern int iolog_cur_flush(struct io_log *, struct io_logs *);
294
295 static inline void init_ipo(struct io_piece *ipo)
296 {
297         memset(ipo, 0, sizeof(*ipo));
298         INIT_FLIST_HEAD(&ipo->trim_list);
299 }
300
301 struct iolog_compress {
302         struct flist_head list;
303         void *buf;
304         size_t len;
305         unsigned int seq;
306 };
307
308 #endif