Method loadPosition

bolt/dwio/common/CacheInputStream.cpp:325–381

}

void CacheInputStream::loadPosition() {
  auto offset = region_.offset;
  if (pin_.empty()) {
    auto load = bufferedInput_->coalescedLoad(this);
    if (load) {
      folly::SemiFuture<bool> waitFuture(false);
      uint64_t usec = 0;
      {
        MicrosecondTimer timer(&usec);
        try {
          if (!load->loadOrFuture(&waitFuture)) {
            auto& exec = folly::QueuedImmediateExecutor::instance();
            std::move(waitFuture).via(&exec).wait();
          }
        } catch (const std::exception& e) {
          // Log the error and continue. The error, if it persists,  will be hit
          // again in looking up the specific entry and thrown from there.
          LOG(ERROR) << "IOERR: error in coalesced load " << e.what();
        }
      }
      ioStats_->queryThreadIoLatency().increment(usec);
    }
    auto loadRegion = region_;
    // Quantize position to previous multiple of 'loadQuantum_'.
    loadRegion.offset += (position_ / loadQuantum_) * loadQuantum_;
    // Set length to be the lesser of 'loadQuantum_' and distance to end of
    // 'region_'
    loadRegion.length = std::min<int32_t>(
        loadQuantum_, region_.length - (loadRegion.offset - region_.offset));
    loadSync(loadRegion);
  }
  auto* entry = pin_.checkedEntry();
  uint64_t positionInFile = offset + position_;
  if (entry->offset() <= positionInFile &&
      entry->offset() + entry->size() > positionInFile) {
    // The position is inside the range of 'entry'.
    auto offsetInEntry = positionInFile - entry->offset();
    if (entry->data().numPages() == 0) {
      run_ = reinterpret_cast<uint8_t*>(entry->tinyData());
      runSize_ = entry->size();
      offsetInRun_ = offsetInEntry;
      offsetOfRun_ = 0;
    } else {
      entry->data().findRun(offsetInEntry, &runIndex_, &offsetInRun_);
      offsetOfRun_ = offsetInEntry - offsetInRun_;
      auto run = entry->data().runAt(runIndex_);
      run_ = run.data();
      runSize_ = run.numPages() * memory::AllocationTraits::kPageSize;
      if (offsetOfRun_ + runSize_ > entry->size()) {
        runSize_ = entry->size() - offsetOfRun_;
      }
    }
  } else {
    pin_.clear();
    loadPosition();
  }
}
} // namespace bytedance::bolt::dwio::common