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 }