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