profiles/act.c

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