git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/tests.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #ifdef CONFIG_BCACHEFS_TESTS
   3
   4 #include "bcachefs.h"
   5 #include "btree_update.h"
   6 #include "journal_reclaim.h"
   7 #include "tests.h"
   8
   9 #include "linux/kthread.h"
  10 #include "linux/random.h"
  11
  12 static void delete_test_keys(struct bch_fs *c)
  13 {
  14         int ret;
  15
  16         ret = bch2_btree_delete_range(c, BTREE_ID_extents,
  17                                       POS(0, 0), POS(0, U64_MAX),
  18                                       NULL);
  19         BUG_ON(ret);
  20
  21         ret = bch2_btree_delete_range(c, BTREE_ID_xattrs,
  22                                       POS(0, 0), POS(0, U64_MAX),
  23                                       NULL);
  24         BUG_ON(ret);
  25 }
  26
  27 /* unit tests */
  28
  29 static int test_delete(struct bch_fs *c, u64 nr)
  30 {
  31         struct btree_trans trans;
  32         struct btree_iter *iter;
  33         struct bkey_i_cookie k;
  34         int ret;
  35
  36         bkey_cookie_init(&k.k_i);
  37
  38         bch2_trans_init(&trans, c, 0, 0);
  39
  40         iter = bch2_trans_get_iter(&trans, BTREE_ID_xattrs, k.k.p,
  41                                    BTREE_ITER_INTENT);
  42
  43         ret = bch2_btree_iter_traverse(iter);
  44         if (ret) {
  45                 bch_err(c, "lookup error in test_delete: %i", ret);
  46                 goto err;
  47         }
  48
  49         ret = __bch2_trans_do(&trans, NULL, NULL, 0,
  50                 bch2_trans_update(&trans, iter, &k.k_i, 0));
  51         if (ret) {
  52                 bch_err(c, "update error in test_delete: %i", ret);
  53                 goto err;
  54         }
  55
  56         pr_info("deleting once");
  57         ret = bch2_btree_delete_at(&trans, iter, 0);
  58         if (ret) {
  59                 bch_err(c, "delete error (first) in test_delete: %i", ret);
  60                 goto err;
  61         }
  62
  63         pr_info("deleting twice");
  64         ret = bch2_btree_delete_at(&trans, iter, 0);
  65         if (ret) {
  66                 bch_err(c, "delete error (second) in test_delete: %i", ret);
  67                 goto err;
  68         }
  69 err:
  70         bch2_trans_exit(&trans);
  71         return ret;
  72 }
  73
  74 static int test_delete_written(struct bch_fs *c, u64 nr)
  75 {
  76         struct btree_trans trans;
  77         struct btree_iter *iter;
  78         struct bkey_i_cookie k;
  79         int ret;
  80
  81         bkey_cookie_init(&k.k_i);
  82
  83         bch2_trans_init(&trans, c, 0, 0);
  84
  85         iter = bch2_trans_get_iter(&trans, BTREE_ID_xattrs, k.k.p,
  86                                    BTREE_ITER_INTENT);
  87
  88         ret = bch2_btree_iter_traverse(iter);
  89         if (ret) {
  90                 bch_err(c, "lookup error in test_delete_written: %i", ret);
  91                 goto err;
  92         }
  93
  94         ret = __bch2_trans_do(&trans, NULL, NULL, 0,
  95                 bch2_trans_update(&trans, iter, &k.k_i, 0));
  96         if (ret) {
  97                 bch_err(c, "update error in test_delete_written: %i", ret);
  98                 goto err;
  99         }
 100
 101         bch2_journal_flush_all_pins(&c->journal);
 102
 103         ret = bch2_btree_delete_at(&trans, iter, 0);
 104         if (ret) {
 105                 bch_err(c, "delete error in test_delete_written: %i", ret);
 106                 goto err;
 107         }
 108 err:
 109         bch2_trans_exit(&trans);
 110         return ret;
 111 }
 112
 113 static int test_iterate(struct bch_fs *c, u64 nr)
 114 {
 115         struct btree_trans trans;
 116         struct btree_iter *iter;
 117         struct bkey_s_c k;
 118         u64 i;
 119         int ret = 0;
 120
 121         bch2_trans_init(&trans, c, 0, 0);
 122
 123         delete_test_keys(c);
 124
 125         pr_info("inserting test keys");
 126
 127         for (i = 0; i < nr; i++) {
 128                 struct bkey_i_cookie k;
 129
 130                 bkey_cookie_init(&k.k_i);
 131                 k.k.p.offset = i;
 132
 133                 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &k.k_i,
 134                                         NULL, NULL, 0);
 135                 if (ret) {
 136                         bch_err(c, "insert error in test_iterate: %i", ret);
 137                         goto err;
 138                 }
 139         }
 140
 141         pr_info("iterating forwards");
 142
 143         i = 0;
 144
 145         for_each_btree_key(&trans, iter, BTREE_ID_xattrs,
 146                            POS_MIN, 0, k, ret) {
 147                 if (k.k->p.inode)
 148                         break;
 149
 150                 BUG_ON(k.k->p.offset != i++);
 151         }
 152
 153         BUG_ON(i != nr);
 154
 155         pr_info("iterating backwards");
 156
 157         while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(iter)).k))
 158                 BUG_ON(k.k->p.offset != --i);
 159
 160         BUG_ON(i);
 161 err:
 162         bch2_trans_exit(&trans);
 163         return ret;
 164 }
 165
 166 static int test_iterate_extents(struct bch_fs *c, u64 nr)
 167 {
 168         struct btree_trans trans;
 169         struct btree_iter *iter;
 170         struct bkey_s_c k;
 171         u64 i;
 172         int ret = 0;
 173
 174         bch2_trans_init(&trans, c, 0, 0);
 175
 176         delete_test_keys(c);
 177
 178         pr_info("inserting test extents");
 179
 180         for (i = 0; i < nr; i += 8) {
 181                 struct bkey_i_cookie k;
 182
 183                 bkey_cookie_init(&k.k_i);
 184                 k.k.p.offset = i + 8;
 185                 k.k.size = 8;
 186
 187                 ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i,
 188                                         NULL, NULL, 0);
 189                 if (ret) {
 190                         bch_err(c, "insert error in test_iterate_extents: %i", ret);
 191                         goto err;
 192                 }
 193         }
 194
 195         pr_info("iterating forwards");
 196
 197         i = 0;
 198
 199         for_each_btree_key(&trans, iter, BTREE_ID_extents,
 200                            POS_MIN, 0, k, ret) {
 201                 BUG_ON(bkey_start_offset(k.k) != i);
 202                 i = k.k->p.offset;
 203         }
 204
 205         BUG_ON(i != nr);
 206
 207         pr_info("iterating backwards");
 208
 209         while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(iter)).k)) {
 210                 BUG_ON(k.k->p.offset != i);
 211                 i = bkey_start_offset(k.k);
 212         }
 213
 214         BUG_ON(i);
 215 err:
 216         bch2_trans_exit(&trans);
 217         return ret;
 218 }
 219
 220 static int test_iterate_slots(struct bch_fs *c, u64 nr)
 221 {
 222         struct btree_trans trans;
 223         struct btree_iter *iter;
 224         struct bkey_s_c k;
 225         u64 i;
 226         int ret = 0;
 227
 228         bch2_trans_init(&trans, c, 0, 0);
 229
 230         delete_test_keys(c);
 231
 232         pr_info("inserting test keys");
 233
 234         for (i = 0; i < nr; i++) {
 235                 struct bkey_i_cookie k;
 236
 237                 bkey_cookie_init(&k.k_i);
 238                 k.k.p.offset = i * 2;
 239
 240                 ret = bch2_btree_insert(c, BTREE_ID_xattrs, &k.k_i,
 241                                         NULL, NULL, 0);
 242                 if (ret) {
 243                         bch_err(c, "insert error in test_iterate_slots: %i", ret);
 244                         goto err;
 245                 }
 246         }
 247
 248         pr_info("iterating forwards");
 249
 250         i = 0;
 251
 252         for_each_btree_key(&trans, iter, BTREE_ID_xattrs, POS_MIN,
 253                            0, k, ret) {
 254                 if (k.k->p.inode)
 255                         break;
 256
 257                 BUG_ON(k.k->p.offset != i);
 258                 i += 2;
 259         }
 260         bch2_trans_iter_free(&trans, iter);
 261
 262         BUG_ON(i != nr * 2);
 263
 264         pr_info("iterating forwards by slots");
 265
 266         i = 0;
 267
 268         for_each_btree_key(&trans, iter, BTREE_ID_xattrs, POS_MIN,
 269                            BTREE_ITER_SLOTS, k, ret) {
 270                 BUG_ON(k.k->p.offset != i);
 271                 BUG_ON(bkey_deleted(k.k) != (i & 1));
 272
 273                 i++;
 274                 if (i == nr * 2)
 275                         break;
 276         }
 277 err:
 278         bch2_trans_exit(&trans);
 279         return ret;
 280 }
 281
 282 static int test_iterate_slots_extents(struct bch_fs *c, u64 nr)
 283 {
 284         struct btree_trans trans;
 285         struct btree_iter *iter;
 286         struct bkey_s_c k;
 287         u64 i;
 288         int ret = 0;
 289
 290         bch2_trans_init(&trans, c, 0, 0);
 291
 292         delete_test_keys(c);
 293
 294         pr_info("inserting test keys");
 295
 296         for (i = 0; i < nr; i += 16) {
 297                 struct bkey_i_cookie k;
 298
 299                 bkey_cookie_init(&k.k_i);
 300                 k.k.p.offset = i + 16;
 301                 k.k.size = 8;
 302
 303                 ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i,
 304                                         NULL, NULL, 0);
 305                 if (ret) {
 306                         bch_err(c, "insert error in test_iterate_slots_extents: %i", ret);
 307                         goto err;
 308                 }
 309         }
 310
 311         pr_info("iterating forwards");
 312
 313         i = 0;
 314
 315         for_each_btree_key(&trans, iter, BTREE_ID_extents, POS_MIN,
 316                            0, k, ret) {
 317                 BUG_ON(bkey_start_offset(k.k) != i + 8);
 318                 BUG_ON(k.k->size != 8);
 319                 i += 16;
 320         }
 321         bch2_trans_iter_free(&trans, iter);
 322
 323         BUG_ON(i != nr);
 324
 325         pr_info("iterating forwards by slots");
 326
 327         i = 0;
 328
 329         for_each_btree_key(&trans, iter, BTREE_ID_extents, POS_MIN,
 330                            BTREE_ITER_SLOTS, k, ret) {
 331                 BUG_ON(bkey_deleted(k.k) != !(i % 16));
 332
 333                 BUG_ON(bkey_start_offset(k.k) != i);
 334                 BUG_ON(k.k->size != 8);
 335                 i = k.k->p.offset;
 336
 337                 if (i == nr)
 338                         break;
 339         }
 340 err:
 341         bch2_trans_exit(&trans);
 342         return 0;
 343 }
 344
 345 /*
 346  * XXX: we really want to make sure we've got a btree with depth > 0 for these
 347  * tests
 348  */
 349 static int test_peek_end(struct bch_fs *c, u64 nr)
 350 {
 351         struct btree_trans trans;
 352         struct btree_iter *iter;
 353         struct bkey_s_c k;
 354
 355         bch2_trans_init(&trans, c, 0, 0);
 356
 357         iter = bch2_trans_get_iter(&trans, BTREE_ID_xattrs, POS_MIN, 0);
 358
 359         k = bch2_btree_iter_peek(iter);
 360         BUG_ON(k.k);
 361
 362         k = bch2_btree_iter_peek(iter);
 363         BUG_ON(k.k);
 364
 365         bch2_trans_exit(&trans);
 366         return 0;
 367 }
 368
 369 static int test_peek_end_extents(struct bch_fs *c, u64 nr)
 370 {
 371         struct btree_trans trans;
 372         struct btree_iter *iter;
 373         struct bkey_s_c k;
 374
 375         bch2_trans_init(&trans, c, 0, 0);
 376
 377         iter = bch2_trans_get_iter(&trans, BTREE_ID_extents, POS_MIN, 0);
 378
 379         k = bch2_btree_iter_peek(iter);
 380         BUG_ON(k.k);
 381
 382         k = bch2_btree_iter_peek(iter);
 383         BUG_ON(k.k);
 384
 385         bch2_trans_exit(&trans);
 386         return 0;
 387 }
 388
 389 /* extent unit tests */
 390
 391 u64 test_version;
 392
 393 static int insert_test_extent(struct bch_fs *c,
 394                               u64 start, u64 end)
 395 {
 396         struct bkey_i_cookie k;
 397         int ret;
 398
 399         //pr_info("inserting %llu-%llu v %llu", start, end, test_version);
 400
 401         bkey_cookie_init(&k.k_i);
 402         k.k_i.k.p.offset = end;
 403         k.k_i.k.size = end - start;
 404         k.k_i.k.version.lo = test_version++;
 405
 406         ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i,
 407                                 NULL, NULL, 0);
 408         if (ret)
 409                 bch_err(c, "insert error in insert_test_extent: %i", ret);
 410         return ret;
 411 }
 412
 413 static int __test_extent_overwrite(struct bch_fs *c,
 414                                     u64 e1_start, u64 e1_end,
 415                                     u64 e2_start, u64 e2_end)
 416 {
 417         int ret;
 418
 419         ret   = insert_test_extent(c, e1_start, e1_end) ?:
 420                 insert_test_extent(c, e2_start, e2_end);
 421
 422         delete_test_keys(c);
 423         return ret;
 424 }
 425
 426 static int test_extent_overwrite_front(struct bch_fs *c, u64 nr)
 427 {
 428         return  __test_extent_overwrite(c, 0, 64, 0, 32) ?:
 429                 __test_extent_overwrite(c, 8, 64, 0, 32);
 430 }
 431
 432 static int test_extent_overwrite_back(struct bch_fs *c, u64 nr)
 433 {
 434         return  __test_extent_overwrite(c, 0, 64, 32, 64) ?:
 435                 __test_extent_overwrite(c, 0, 64, 32, 72);
 436 }
 437
 438 static int test_extent_overwrite_middle(struct bch_fs *c, u64 nr)
 439 {
 440         return __test_extent_overwrite(c, 0, 64, 32, 40);
 441 }
 442
 443 static int test_extent_overwrite_all(struct bch_fs *c, u64 nr)
 444 {
 445         return  __test_extent_overwrite(c, 32, 64,  0,  64) ?:
 446                 __test_extent_overwrite(c, 32, 64,  0, 128) ?:
 447                 __test_extent_overwrite(c, 32, 64, 32,  64) ?:
 448                 __test_extent_overwrite(c, 32, 64, 32, 128);
 449 }
 450
 451 /* perf tests */
 452
 453 static u64 test_rand(void)
 454 {
 455         u64 v;
 456 #if 0
 457         v = prandom_u32();
 458 #else
 459         prandom_bytes(&v, sizeof(v));
 460 #endif
 461         return v;
 462 }
 463
 464 static int rand_insert(struct bch_fs *c, u64 nr)
 465 {
 466         struct btree_trans trans;
 467         struct bkey_i_cookie k;
 468         int ret = 0;
 469         u64 i;
 470
 471         bch2_trans_init(&trans, c, 0, 0);
 472
 473         for (i = 0; i < nr; i++) {
 474                 bkey_cookie_init(&k.k_i);
 475                 k.k.p.offset = test_rand();
 476
 477                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 478                         __bch2_btree_insert(&trans, BTREE_ID_xattrs, &k.k_i));
 479                 if (ret) {
 480                         bch_err(c, "error in rand_insert: %i", ret);
 481                         break;
 482                 }
 483         }
 484
 485         bch2_trans_exit(&trans);
 486         return ret;
 487 }
 488
 489 static int rand_lookup(struct bch_fs *c, u64 nr)
 490 {
 491         struct btree_trans trans;
 492         struct btree_iter *iter;
 493         struct bkey_s_c k;
 494         int ret = 0;
 495         u64 i;
 496
 497         bch2_trans_init(&trans, c, 0, 0);
 498         iter = bch2_trans_get_iter(&trans, BTREE_ID_xattrs, POS_MIN, 0);
 499
 500         for (i = 0; i < nr; i++) {
 501                 bch2_btree_iter_set_pos(iter, POS(0, test_rand()));
 502
 503                 k = bch2_btree_iter_peek(iter);
 504                 ret = bkey_err(k);
 505                 if (ret) {
 506                         bch_err(c, "error in rand_lookup: %i", ret);
 507                         break;
 508                 }
 509         }
 510
 511         bch2_trans_iter_free(&trans, iter);
 512         bch2_trans_exit(&trans);
 513         return ret;
 514 }
 515
 516 static int rand_mixed(struct bch_fs *c, u64 nr)
 517 {
 518         struct btree_trans trans;
 519         struct btree_iter *iter;
 520         struct bkey_s_c k;
 521         int ret = 0;
 522         u64 i;
 523
 524         bch2_trans_init(&trans, c, 0, 0);
 525         iter = bch2_trans_get_iter(&trans, BTREE_ID_xattrs, POS_MIN, 0);
 526
 527         for (i = 0; i < nr; i++) {
 528                 bch2_btree_iter_set_pos(iter, POS(0, test_rand()));
 529
 530                 k = bch2_btree_iter_peek(iter);
 531                 ret = bkey_err(k);
 532                 if (ret) {
 533                         bch_err(c, "lookup error in rand_mixed: %i", ret);
 534                         break;
 535                 }
 536
 537                 if (!(i & 3) && k.k) {
 538                         struct bkey_i_cookie k;
 539
 540                         bkey_cookie_init(&k.k_i);
 541                         k.k.p = iter->pos;
 542
 543                         ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 544                                 bch2_trans_update(&trans, iter, &k.k_i, 0));
 545                         if (ret) {
 546                                 bch_err(c, "update error in rand_mixed: %i", ret);
 547                                 break;
 548                         }
 549                 }
 550         }
 551
 552         bch2_trans_iter_free(&trans, iter);
 553         bch2_trans_exit(&trans);
 554         return ret;
 555 }
 556
 557 static int __do_delete(struct btree_trans *trans, struct bpos pos)
 558 {
 559         struct btree_iter *iter;
 560         struct bkey_i delete;
 561         struct bkey_s_c k;
 562         int ret = 0;
 563
 564         iter = bch2_trans_get_iter(trans, BTREE_ID_xattrs, pos,
 565                                    BTREE_ITER_INTENT);
 566         k = bch2_btree_iter_peek(iter);
 567         ret = bkey_err(k);
 568         if (ret)
 569                 goto err;
 570
 571         if (!k.k)
 572                 goto err;
 573
 574         bkey_init(&delete.k);
 575         delete.k.p = k.k->p;
 576
 577         bch2_trans_update(trans, iter, &delete, 0);
 578 err:
 579         bch2_trans_iter_put(trans, iter);
 580         return ret;
 581 }
 582
 583 static int rand_delete(struct bch_fs *c, u64 nr)
 584 {
 585         struct btree_trans trans;
 586         int ret = 0;
 587         u64 i;
 588
 589         bch2_trans_init(&trans, c, 0, 0);
 590
 591         for (i = 0; i < nr; i++) {
 592                 struct bpos pos = POS(0, test_rand());
 593
 594                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 595                         __do_delete(&trans, pos));
 596                 if (ret) {
 597                         bch_err(c, "error in rand_delete: %i", ret);
 598                         break;
 599                 }
 600         }
 601
 602         bch2_trans_exit(&trans);
 603         return ret;
 604 }
 605
 606 static int seq_insert(struct bch_fs *c, u64 nr)
 607 {
 608         struct btree_trans trans;
 609         struct btree_iter *iter;
 610         struct bkey_s_c k;
 611         struct bkey_i_cookie insert;
 612         int ret = 0;
 613         u64 i = 0;
 614
 615         bkey_cookie_init(&insert.k_i);
 616
 617         bch2_trans_init(&trans, c, 0, 0);
 618
 619         for_each_btree_key(&trans, iter, BTREE_ID_xattrs, POS_MIN,
 620                            BTREE_ITER_SLOTS|BTREE_ITER_INTENT, k, ret) {
 621                 insert.k.p = iter->pos;
 622
 623                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 624                         bch2_trans_update(&trans, iter, &insert.k_i, 0));
 625                 if (ret) {
 626                         bch_err(c, "error in seq_insert: %i", ret);
 627                         break;
 628                 }
 629
 630                 if (++i == nr)
 631                         break;
 632         }
 633         bch2_trans_exit(&trans);
 634         return ret;
 635 }
 636
 637 static int seq_lookup(struct bch_fs *c, u64 nr)
 638 {
 639         struct btree_trans trans;
 640         struct btree_iter *iter;
 641         struct bkey_s_c k;
 642         int ret = 0;
 643
 644         bch2_trans_init(&trans, c, 0, 0);
 645
 646         for_each_btree_key(&trans, iter, BTREE_ID_xattrs, POS_MIN, 0, k, ret)
 647                 ;
 648         bch2_trans_exit(&trans);
 649         return ret;
 650 }
 651
 652 static int seq_overwrite(struct bch_fs *c, u64 nr)
 653 {
 654         struct btree_trans trans;
 655         struct btree_iter *iter;
 656         struct bkey_s_c k;
 657         int ret = 0;
 658
 659         bch2_trans_init(&trans, c, 0, 0);
 660
 661         for_each_btree_key(&trans, iter, BTREE_ID_xattrs, POS_MIN,
 662                            BTREE_ITER_INTENT, k, ret) {
 663                 struct bkey_i_cookie u;
 664
 665                 bkey_reassemble(&u.k_i, k);
 666
 667                 ret = __bch2_trans_do(&trans, NULL, NULL, 0,
 668                         bch2_trans_update(&trans, iter, &u.k_i, 0));
 669                 if (ret) {
 670                         bch_err(c, "error in seq_overwrite: %i", ret);
 671                         break;
 672                 }
 673         }
 674         bch2_trans_exit(&trans);
 675         return ret;
 676 }
 677
 678 static int seq_delete(struct bch_fs *c, u64 nr)
 679 {
 680         int ret;
 681
 682         ret = bch2_btree_delete_range(c, BTREE_ID_xattrs,
 683                                       POS(0, 0), POS(0, U64_MAX),
 684                                       NULL);
 685         if (ret)
 686                 bch_err(c, "error in seq_delete: %i", ret);
 687         return ret;
 688 }
 689
 690 typedef int (*perf_test_fn)(struct bch_fs *, u64);
 691
 692 struct test_job {
 693         struct bch_fs                   *c;
 694         u64                             nr;
 695         unsigned                        nr_threads;
 696         perf_test_fn                    fn;
 697
 698         atomic_t                        ready;
 699         wait_queue_head_t               ready_wait;
 700
 701         atomic_t                        done;
 702         struct completion               done_completion;
 703
 704         u64                             start;
 705         u64                             finish;
 706         int                             ret;
 707 };
 708
 709 static int btree_perf_test_thread(void *data)
 710 {
 711         struct test_job *j = data;
 712         int ret;
 713
 714         if (atomic_dec_and_test(&j->ready)) {
 715                 wake_up(&j->ready_wait);
 716                 j->start = sched_clock();
 717         } else {
 718                 wait_event(j->ready_wait, !atomic_read(&j->ready));
 719         }
 720
 721         ret = j->fn(j->c, j->nr / j->nr_threads);
 722         if (ret)
 723                 j->ret = ret;
 724
 725         if (atomic_dec_and_test(&j->done)) {
 726                 j->finish = sched_clock();
 727                 complete(&j->done_completion);
 728         }
 729
 730         return 0;
 731 }
 732
 733 int bch2_btree_perf_test(struct bch_fs *c, const char *testname,
 734                          u64 nr, unsigned nr_threads)
 735 {
 736         struct test_job j = { .c = c, .nr = nr, .nr_threads = nr_threads };
 737         char name_buf[20], nr_buf[20], per_sec_buf[20];
 738         unsigned i;
 739         u64 time;
 740
 741         atomic_set(&j.ready, nr_threads);
 742         init_waitqueue_head(&j.ready_wait);
 743
 744         atomic_set(&j.done, nr_threads);
 745         init_completion(&j.done_completion);
 746
 747 #define perf_test(_test)                                \
 748         if (!strcmp(testname, #_test)) j.fn = _test
 749
 750         perf_test(rand_insert);
 751         perf_test(rand_lookup);
 752         perf_test(rand_mixed);
 753         perf_test(rand_delete);
 754
 755         perf_test(seq_insert);
 756         perf_test(seq_lookup);
 757         perf_test(seq_overwrite);
 758         perf_test(seq_delete);
 759
 760         /* a unit test, not a perf test: */
 761         perf_test(test_delete);
 762         perf_test(test_delete_written);
 763         perf_test(test_iterate);
 764         perf_test(test_iterate_extents);
 765         perf_test(test_iterate_slots);
 766         perf_test(test_iterate_slots_extents);
 767         perf_test(test_peek_end);
 768         perf_test(test_peek_end_extents);
 769
 770         perf_test(test_extent_overwrite_front);
 771         perf_test(test_extent_overwrite_back);
 772         perf_test(test_extent_overwrite_middle);
 773         perf_test(test_extent_overwrite_all);
 774
 775         if (!j.fn) {
 776                 pr_err("unknown test %s", testname);
 777                 return -EINVAL;
 778         }
 779
 780         //pr_info("running test %s:", testname);
 781
 782         if (nr_threads == 1)
 783                 btree_perf_test_thread(&j);
 784         else
 785                 for (i = 0; i < nr_threads; i++)
 786                         kthread_run(btree_perf_test_thread, &j,
 787                                     "bcachefs perf test[%u]", i);
 788
 789         while (wait_for_completion_interruptible(&j.done_completion))
 790                 ;
 791
 792         time = j.finish - j.start;
 793
 794         scnprintf(name_buf, sizeof(name_buf), "%s:", testname);
 795         bch2_hprint(&PBUF(nr_buf), nr);
 796         bch2_hprint(&PBUF(per_sec_buf), nr * NSEC_PER_SEC / time);
 797         printk(KERN_INFO "%-12s %s with %u threads in %5llu sec, %5llu nsec per iter, %5s per sec\n",
 798                 name_buf, nr_buf, nr_threads,
 799                 time / NSEC_PER_SEC,
 800                 time * nr_threads / nr,
 801                 per_sec_buf);
 802         return j.ret;
 803 }
 804
 805 #endif /* CONFIG_BCACHEFS_TESTS */