glusterfs: update for new API
[fio.git] / profiles / act.c
1 #include "../fio.h"
2 #include "../profile.h"
3 #include "../parse.h"
4 #include "../optgroup.h"
5
6 /*
7  * 1x loads
8  */
9 #define R_LOAD          2000
10 #define W_LOAD          1000
11
12 #define SAMPLE_SEC      3600            /* 1h checks */
13
14 struct act_pass_criteria {
15         unsigned int max_usec;
16         unsigned int max_perm;
17 };
18 #define ACT_MAX_CRIT    3
19
20 static struct act_pass_criteria act_pass[ACT_MAX_CRIT] = {
21         {
22                 .max_usec =     1000,
23                 .max_perm =     50,
24         },
25         {
26                 .max_usec =     8000,
27                 .max_perm =     10,
28         },
29         {
30                 .max_usec =     64000,
31                 .max_perm =     1,
32         },
33 };
34
35 struct act_slice {
36         uint64_t lat_buckets[ACT_MAX_CRIT];
37         uint64_t total_ios;
38 };
39
40 struct act_run_data {
41         struct fio_sem *sem;
42         unsigned int pending;
43
44         struct act_slice *slices;
45         unsigned int nr_slices;
46 };
47 static struct act_run_data *act_run_data;
48
49 struct act_prof_data {
50         struct timespec sample_tv;
51         struct act_slice *slices;
52         unsigned int cur_slice;
53         unsigned int nr_slices;
54 };
55
56 #define ACT_MAX_OPTS    128
57 static const char *act_opts[ACT_MAX_OPTS] = {
58         "direct=1",
59         "ioengine=sync",
60         "random_generator=lfsr",
61         "group_reporting=1",
62         "thread",
63         NULL,
64 };
65 static unsigned int opt_idx = 5;
66 static unsigned int org_idx;
67
68 static int act_add_opt(const char *format, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
69
70 struct act_options {
71         unsigned int pad;
72         char *device_names;
73         unsigned int load;
74         unsigned int prep;
75         unsigned int threads_per_queue;
76         unsigned int num_read_blocks;
77         unsigned int write_size;
78         unsigned long long test_duration;
79 };
80
81 static struct act_options act_options;
82
83 static struct fio_option options[] = {
84         {
85                 .name   = "device-names",
86                 .lname  = "device-names",
87                 .type   = FIO_OPT_STR_STORE,
88                 .off1   = offsetof(struct act_options, device_names),
89                 .help   = "Devices to use",
90                 .category = FIO_OPT_C_PROFILE,
91                 .group  = FIO_OPT_G_ACT,
92                 .no_free = true,
93         },
94         {
95                 .name   = "load",
96                 .lname  = "Load multiplier",
97                 .type   = FIO_OPT_INT,
98                 .off1   = offsetof(struct act_options, load),
99                 .help   = "ACT load multipler (default 1x)",
100                 .def    = "1",
101                 .category = FIO_OPT_C_PROFILE,
102                 .group  = FIO_OPT_G_ACT,
103         },
104         {
105                 .name   = "test-duration",
106                 .lname  = "Test duration",
107                 .type   = FIO_OPT_STR_VAL_TIME,
108                 .off1   = offsetof(struct act_options, test_duration),
109                 .help   = "How long the entire test takes to run",
110                 .def    = "24h",
111                 .category = FIO_OPT_C_PROFILE,
112                 .group  = FIO_OPT_G_ACT,
113         },
114         {
115                 .name   = "threads-per-queue",
116                 .lname  = "Number of read IO threads per device",
117                 .type   = FIO_OPT_INT,
118                 .off1   = offsetof(struct act_options, threads_per_queue),
119                 .help   = "Number of read IO threads per device",
120                 .def    = "8",
121                 .category = FIO_OPT_C_PROFILE,
122                 .group  = FIO_OPT_G_ACT,
123         },
124         {
125                 .name   = "read-req-num-512-blocks",
126                 .lname  = "Number of 512B blocks to read",
127                 .type   = FIO_OPT_INT,
128                 .off1   = offsetof(struct act_options, num_read_blocks),
129                 .help   = "Number of 512B blocks to read at the time",
130                 .def    = "3",
131                 .category = FIO_OPT_C_PROFILE,
132                 .group  = FIO_OPT_G_ACT,
133         },
134         {
135                 .name   = "large-block-op-kbytes",
136                 .lname  = "Size of large block ops in KiB (writes)",
137                 .type   = FIO_OPT_INT,
138                 .off1   = offsetof(struct act_options, write_size),
139                 .help   = "Size of large block ops in KiB (writes)",
140                 .def    = "131072",
141                 .category = FIO_OPT_C_PROFILE,
142                 .group  = FIO_OPT_G_ACT,
143         },
144         {
145                 .name   = "prep",
146                 .lname  = "Run ACT prep phase",
147                 .type   = FIO_OPT_STR_SET,
148                 .off1   = offsetof(struct act_options, prep),
149                 .help   = "Set to run ACT prep phase",
150                 .category = FIO_OPT_C_PROFILE,
151                 .group  = FIO_OPT_G_ACT,
152         },
153         {
154                 .name   = NULL,
155         },
156 };
157
158 static int act_add_opt(const char *str, ...)
159 {
160         char buffer[512];
161         va_list args;
162         size_t len;
163
164         if (opt_idx == ACT_MAX_OPTS) {
165                 log_err("act: ACT_MAX_OPTS is too small\n");
166                 return 1;
167         }
168
169         va_start(args, str);
170         len = vsnprintf(buffer, sizeof(buffer), str, args);
171         va_end(args);
172
173         if (len)
174                 act_opts[opt_idx++] = strdup(buffer);
175
176         return 0;
177 }
178
179 static int act_add_rw(const char *dev, int reads)
180 {
181         struct act_options *ao = &act_options;
182
183         if (act_add_opt("name=act-%s-%s", reads ? "read" : "write", dev))
184                 return 1;
185         if (act_add_opt("filename=%s", dev))
186                 return 1;
187         if (act_add_opt("rw=%s", reads ? "randread" : "randwrite"))
188                 return 1;
189         if (reads) {
190                 int rload = ao->load * R_LOAD / ao->threads_per_queue;
191
192                 if (act_add_opt("numjobs=%u", ao->threads_per_queue))
193                         return 1;
194                 if (act_add_opt("rate_iops=%u", rload))
195                         return 1;
196                 if (act_add_opt("bs=%u", ao->num_read_blocks * 512))
197                         return 1;
198         } else {
199                 const int rsize = ao->write_size / (ao->num_read_blocks * 512);
200                 int wload = (ao->load * W_LOAD + rsize - 1) / rsize;
201
202                 if (act_add_opt("rate_iops=%u", wload))
203                         return 1;
204                 if (act_add_opt("bs=%u", ao->write_size))
205                         return 1;
206         }
207
208         return 0;
209 }
210
211 static int act_add_dev_prep(const char *dev)
212 {
213         /* Add sequential zero phase */
214         if (act_add_opt("name=act-prep-zeroes-%s", dev))
215                 return 1;
216         if (act_add_opt("filename=%s", dev))
217                 return 1;
218         if (act_add_opt("bs=1048576"))
219                 return 1;
220         if (act_add_opt("zero_buffers"))
221                 return 1;
222         if (act_add_opt("rw=write"))
223                 return 1;
224
225         /* Randomly overwrite device */
226         if (act_add_opt("name=act-prep-salt-%s", dev))
227                 return 1;
228         if (act_add_opt("stonewall"))
229                 return 1;
230         if (act_add_opt("filename=%s", dev))
231                 return 1;
232         if (act_add_opt("bs=4096"))
233                 return 1;
234         if (act_add_opt("ioengine=libaio"))
235                 return 1;
236         if (act_add_opt("iodepth=64"))
237                 return 1;
238         if (act_add_opt("rw=randwrite"))
239                 return 1;
240
241         return 0;
242 }
243
244 static int act_add_dev(const char *dev)
245 {
246         if (act_options.prep)
247                 return act_add_dev_prep(dev);
248
249         if (act_add_opt("runtime=%llus", act_options.test_duration))
250                 return 1;
251         if (act_add_opt("time_based=1"))
252                 return 1;
253
254         if (act_add_rw(dev, 1))
255                 return 1;
256         if (act_add_rw(dev, 0))
257                 return 1;
258
259         return 0;
260 }
261
262 /*
263  * Fill our private options into the command line
264  */
265 static int act_prep_cmdline(void)
266 {
267         if (!act_options.device_names) {
268                 log_err("act: you need to set IO target(s) with the "
269                         "device-names option.\n");
270                 return 1;
271         }
272
273         org_idx = opt_idx;
274
275         do {
276                 char *dev;
277
278                 dev = strsep(&act_options.device_names, ",");
279                 if (!dev)
280                         break;
281
282                 if (act_add_dev(dev)) {
283                         log_err("act: failed adding device to the mix\n");
284                         break;
285                 }
286         } while (1);
287
288         return 0;
289 }
290
291 static int act_io_u_lat(struct thread_data *td, uint64_t nsec)
292 {
293         struct act_prof_data *apd = td->prof_data;
294         struct act_slice *slice;
295         uint64_t usec = nsec / 1000ULL;
296         int i, ret = 0;
297         double perm;
298
299         if (act_options.prep)
300                 return 0;
301
302         /*
303          * Really should not happen, but lets not let jitter at the end
304          * ruin our day.
305          */
306         if (apd->cur_slice >= apd->nr_slices)
307                 return 0;
308
309         slice = &apd->slices[apd->cur_slice];
310         slice->total_ios++;
311
312         for (i = ACT_MAX_CRIT - 1; i >= 0; i--) {
313                 if (usec > act_pass[i].max_usec) {
314                         slice->lat_buckets[i]++;
315                         break;
316                 }
317         }
318
319         if (time_since_now(&apd->sample_tv) < SAMPLE_SEC)
320                 return 0;
321
322         /* SAMPLE_SEC has passed, check criteria for pass */
323         for (i = 0; i < ACT_MAX_CRIT; i++) {
324                 perm = (1000.0 * slice->lat_buckets[i]) / slice->total_ios;
325                 if (perm < act_pass[i].max_perm)
326                         continue;
327
328                 log_err("act: %f%% exceeds pass criteria of %f%%\n", perm / 10.0, (double) act_pass[i].max_perm / 10.0);
329                 ret = 1;
330                 break;
331         }
332
333         fio_gettime(&apd->sample_tv, NULL);
334         apd->cur_slice++;
335         return ret;
336 }
337
338 static void get_act_ref(void)
339 {
340         fio_sem_down(act_run_data->sem);
341         act_run_data->pending++;
342         fio_sem_up(act_run_data->sem);
343 }
344
345 static int show_slice(struct act_slice *slice, unsigned int slice_num)
346 {
347         unsigned int i, failed = 0;
348
349         log_info("   %2u", slice_num);
350
351         for (i = 0; i < ACT_MAX_CRIT; i++) {
352                 double perc = 0.0;
353
354                 if (slice->total_ios)
355                         perc = 100.0 * (double) slice->lat_buckets[i] / (double) slice->total_ios;
356                 if ((perc * 10.0) >= act_pass[i].max_perm)
357                         failed++;
358                 log_info("\t%2.2f", perc);
359         }
360         for (i = 0; i < ACT_MAX_CRIT; i++) {
361                 double perc = 0.0;
362
363                 if (slice->total_ios)
364                         perc = 100.0 * (double) slice->lat_buckets[i] / (double) slice->total_ios;
365                 log_info("\t%2.2f", perc);
366         }
367         log_info("\n");
368
369         return failed;
370 }
371
372 static void act_show_all_stats(void)
373 {
374         unsigned int i, fails = 0;
375
376         log_info("        trans                   device\n");
377         log_info("        %%>(ms)                  %%>(ms)\n");
378         log_info(" slice");
379
380         for (i = 0; i < ACT_MAX_CRIT; i++)
381                 log_info("\t %2u", act_pass[i].max_usec / 1000);
382         for (i = 0; i < ACT_MAX_CRIT; i++)
383                 log_info("\t %2u", act_pass[i].max_usec / 1000);
384
385         log_info("\n");
386         log_info(" -----  -----   -----  ------   -----   -----  ------\n");
387
388         for (i = 0; i < act_run_data->nr_slices; i++)
389                 fails += show_slice(&act_run_data->slices[i], i + 1);
390
391         log_info("\nact: test complete, device(s): %s\n", fails ? "FAILED" : "PASSED");
392 }
393
394 static void put_act_ref(struct thread_data *td)
395 {
396         struct act_prof_data *apd = td->prof_data;
397         unsigned int i, slice;
398
399         fio_sem_down(act_run_data->sem);
400
401         if (!act_run_data->slices) {
402                 act_run_data->slices = calloc(apd->nr_slices, sizeof(struct act_slice));
403                 act_run_data->nr_slices = apd->nr_slices;
404         }
405
406         for (slice = 0; slice < apd->nr_slices; slice++) {
407                 struct act_slice *dst = &act_run_data->slices[slice];
408                 struct act_slice *src = &apd->slices[slice];
409
410                 dst->total_ios += src->total_ios;
411
412                 for (i = 0; i < ACT_MAX_CRIT; i++)
413                         dst->lat_buckets[i] += src->lat_buckets[i];
414         }
415
416         if (!--act_run_data->pending)
417                 act_show_all_stats();
418
419         fio_sem_up(act_run_data->sem);
420 }
421
422 static int act_td_init(struct thread_data *td)
423 {
424         struct act_prof_data *apd;
425         unsigned int nr_slices;
426
427         get_act_ref();
428
429         apd = calloc(1, sizeof(*apd));
430         nr_slices = (act_options.test_duration + SAMPLE_SEC - 1) / SAMPLE_SEC;
431         apd->slices = calloc(nr_slices, sizeof(struct act_slice));
432         apd->nr_slices = nr_slices;
433         fio_gettime(&apd->sample_tv, NULL);
434         td->prof_data = apd;
435         return 0;
436 }
437
438 static void act_td_exit(struct thread_data *td)
439 {
440         struct act_prof_data *apd = td->prof_data;
441
442         put_act_ref(td);
443         free(apd->slices);
444         free(apd);
445         td->prof_data = NULL;
446 }
447
448 static struct prof_io_ops act_io_ops = {
449         .td_init        = act_td_init,
450         .td_exit        = act_td_exit,
451         .io_u_lat       = act_io_u_lat,
452 };
453
454 static struct profile_ops act_profile = {
455         .name           = "act",
456         .desc           = "ACT Aerospike like benchmark",
457         .options        = options,
458         .opt_data       = &act_options,
459         .prep_cmd       = act_prep_cmdline,
460         .cmdline        = act_opts,
461         .io_ops         = &act_io_ops,
462 };
463
464 static void fio_init act_register(void)
465 {
466         act_run_data = calloc(1, sizeof(*act_run_data));
467         act_run_data->sem = fio_sem_init(FIO_SEM_UNLOCKED);
468
469         if (register_profile(&act_profile))
470                 log_err("fio: failed to register profile 'act'\n");
471 }
472
473 static void fio_exit act_unregister(void)
474 {
475         while (org_idx && org_idx < opt_idx)
476                 free((void *) act_opts[++org_idx]);
477
478         unregister_profile(&act_profile);
479         fio_sem_remove(act_run_data->sem);
480         free(act_run_data->slices);
481         free(act_run_data);
482         act_run_data = NULL;
483 }