Method checkpoint

bolt/common/caching/SsdFile.cpp:666–774

void SsdFile::checkpoint(bool force) {
  std::lock_guard<std::shared_mutex> l(mutex_);
  if (!force && (bytesAfterCheckpoint_ < checkpointIntervalBytes_)) {
    return;
  }

  BOLT_SSD_CACHE_LOG(INFO) << "Checkpointing shard " << shardId_
                           << ", force: " << force << " bytesAfterCheckpoint: "
                           << succinctBytes(bytesAfterCheckpoint_)
                           << " checkpointIntervalBytes: "
                           << succinctBytes(checkpointIntervalBytes_);

  checkpointDeleted_ = false;
  bytesAfterCheckpoint_ = 0;
  try {
    // We schedule the potentially long fsync of the cache file on another
    // thread of the cache write executor, if available. If there is none, we do
    // the sync on this thread at the end.
    auto fileSync = std::make_shared<AsyncSource<int>>(
        [fd = fd_]() { return std::make_unique<int>(::fsync(fd)); });
    if (executor_ != nullptr) {
      executor_->add([fileSync]() { fileSync->prepare(); });
    }

    const auto checkRc = [&](int32_t rc, const std::string& errMsg) {
      if (rc < 0) {
        BOLT_FAIL("{} with rc {} :{}", errMsg, rc, folly::errnoStr(errno));
      }
      return rc;
    };

    std::ofstream state;
    auto checkpointPath = fileName_ + kCheckpointExtension;
    state.exceptions(std::ofstream::failbit);
    state.open(checkpointPath, std::ios_base::out | std::ios_base::trunc);
    // The checkpoint state file contains:
    // int32_t The 4 bytes of kCheckpointMagic,
    // int32_t maxRegions,
    // int32_t numRegions,
    // regionScores from the 'tracker_',
    // {fileId, fileName} pairs,
    // kMapMarker,
    // {fileId, offset, SSdRun} triples,
    // kEndMarker.
    state.write(kCheckpointMagic, sizeof(int32_t));
    state.write(asChar(&maxRegions_), sizeof(maxRegions_));
    state.write(asChar(&numRegions_), sizeof(numRegions_));

    // Copy the region scores before writing out for tsan.
    const auto scoresCopy = tracker_.copyScores();
    state.write(asChar(scoresCopy.data()), maxRegions_ * sizeof(uint64_t));
    std::unordered_set<uint64_t> fileNums;
    for (const auto& entry : entries_) {
      const auto fileNum = entry.first.fileNum.id();
      if (fileNums.insert(fileNum).second) {
        state.write(asChar(&fileNum), sizeof(fileNum));
        const auto name = fileIds().string(fileNum);
        const int32_t length = name.size();
        state.write(asChar(&length), sizeof(length));
        state.write(name.data(), length);