Method loadLoop

bolt/common/caching/tests/AsyncDataCacheTest.cpp:526–586

}

void AsyncDataCacheTest::loadLoop(
    int64_t startOffset,
    int64_t loadBytes,
    int32_t errorEveryNBatches,
    int32_t largeEveryNBatches,
    int32_t largeAllocSize) {
  const int64_t maxOffset =
      std::max<int64_t>(100'000, (startOffset + loadBytes) / filenames_.size());
  int64_t skippedBytes = 0;
  int32_t errorCounter = 0;
  int32_t largeCounter = 0;
  std::vector<Request> batch;
  for (auto i = 0; i < filenames_.size(); ++i) {
    const auto fileNum = filenames_[i].id();
    for (uint64_t offset = 100; offset < maxOffset;
         offset += sizeAtOffset(offset)) {
      const auto size = sizeAtOffset(offset);
      if (skippedBytes < startOffset) {
        skippedBytes += size;
        continue;
      }

      batch.emplace_back(offset, size);
      if (batch.size() >= 8) {
        for (;;) {
          if (largeEveryNBatches > 0 &&
              largeCounter++ % largeEveryNBatches == 0) {
            // Many threads will allocate a single large chunk at the
            // same time. Some are expected to fail. All will
            // eventually succeed because whoever gets the allocation
            // frees it soon and without deadlocking with others..
            memory::ContiguousAllocation large;
            // Explicitly free 'large' on exit. Do not use MemoryPool for that
            // because we test the allocator's limits, not the pool/memory
            // manager  limits.
            auto guard =
                folly::makeGuard([&]() { allocator_->freeContiguous(large); });
            while (!allocator_->allocateContiguous(
                memory::AllocationTraits::numPages(largeAllocSize),
                nullptr,
                large)) {
              ++numLargeRetries_;
            }
            std::this_thread::sleep_for(
                std::chrono::microseconds(2000)); // NOLINT
          }
          const bool injectError = (errorEveryNBatches > 0) &&
              (++errorCounter % errorEveryNBatches == 0);
          loadBatch(fileNum, batch, injectError);
          try {
            checkBatch(fileNum, batch, injectError);
          } catch (std::exception& e) {
            continue;
          }
          batch.clear();
          break;
        }
      }