void testSequential()

in cachelib/benchmarks/SpeedUpExistenceCheckBenchmark.cpp [229:281]
47 lines of code
5 McCabe index (conditional complexity)

void testSequential(int numThreads,
                    int htBucketPower,
                    int htLockPower,
                    uint64_t numObjects,
                    const char* msg = "reg") {
  using HashTable = HashTableImpl<BucketT, LockT>;
  using Object = typename HashTable::Object;

  constexpr uint64_t kLoops = 10'000'000;

  std::vector<std::string> keys;
  std::vector<std::unique_ptr<Object>> objects;
  std::unique_ptr<HashTable> ht;
  BENCHMARK_SUSPEND {
    ht = std::make_unique<HashTable>(htBucketPower, htLockPower);
    for (uint64_t i = 0; i < numObjects; i++) {
      auto key = folly::sformat("k_{:<8}", i);
      keys.push_back(key);
      objects.push_back(std::make_unique<Object>(key));
      ht->insert(objects.back().get());
    }
  }

  navy::SeqPoints sp;
  auto readOps = [&] {
    sp.wait(0);

    std::mt19937 gen;
    std::uniform_int_distribution<uint64_t> dist(0, numObjects - 1);
    for (uint64_t loop = 0; loop < kLoops; loop++) {
      const auto& key = keys[dist(gen)];
      auto object = ht->lookup(key);
      folly::doNotOptimizeAway(object);
    }
  };

  std::vector<std::thread> rs;
  for (int i = 0; i < numThreads; i++) {
    rs.push_back(std::thread{readOps});
  }

  {
    Timer t{
        folly::sformat(
            "Sequential_{} - {: <2} T, {: <2} HB, {: <2} HL, {: <8} Objects",
            msg, numThreads, htBucketPower, htLockPower, numObjects),
        kLoops};
    sp.reached(0); // Start the operations
    for (auto& r : rs) {
      r.join();
    }
  }
}