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 } 487
