Method readCheckpoint

bolt/common/caching/SsdFile.cpp:843–907

void SsdFile::readCheckpoint(std::ifstream& state) {
  char magic[4];
  state.read(magic, sizeof(magic));
  BOLT_CHECK_EQ(strncmp(magic, kCheckpointMagic, 4), 0);
  const auto maxRegions = readNumber<int32_t>(state);
  BOLT_CHECK_EQ(
      maxRegions,
      maxRegions_,
      "Trying to start from checkpoint with a different capacity");
  numRegions_ = readNumber<int32_t>(state);
  std::vector<int64_t> scores(maxRegions);
  state.read(asChar(scores.data()), maxRegions_ * sizeof(uint64_t));
  std::unordered_map<uint64_t, StringIdLease> idMap;
  for (;;) {
    auto id = readNumber<uint64_t>(state);
    if (id == kCheckpointMapMarker) {
      break;
    }
    std::string name;
    name.resize(readNumber<int32_t>(state));
    state.read(name.data(), name.size());
    auto lease = StringIdLease(fileIds(), name);
    idMap[id] = std::move(lease);
  }

  const auto logSize = ::lseek(evictLogFd_, 0, SEEK_END);
  std::vector<uint32_t> evicted(logSize / sizeof(uint32_t));
  const auto rc = ::pread(evictLogFd_, evicted.data(), logSize, 0);
  BOLT_CHECK_EQ(logSize, rc, "Failed to read eviction log");
  std::unordered_set<uint32_t> evictedMap;
  for (auto region : evicted) {
    evictedMap.insert(region);
  }
  for (;;) {
    const uint64_t fileNum = readNumber<uint64_t>(state);
    if (fileNum == kCheckpointEndMarker) {
      break;
    }
    const uint64_t offset = readNumber<uint64_t>(state);
    const auto run = SsdRun(readNumber<uint64_t>(state));
    // Check that the recovered entry does not fall in an evicted region.
    if (evictedMap.find(regionIndex(run.offset())) == evictedMap.end()) {
      // The file may have a different id on restore.
      auto it = idMap.find(fileNum);
      BOLT_CHECK(it != idMap.end());
      FileCacheKey key{it->second, offset};
      entries_[std::move(key)] = run;
    }
  }
  // The state is successfully read. Install the access frequency scores and
  // evicted regions.
  BOLT_CHECK_EQ(scores.size(), tracker_.regionScores().size());
  // Set the writable regions by deduplicated evicted regions.
  writableRegions_.clear();
  for (auto region : evictedMap) {
    writableRegions_.push_back(region);
  }
  tracker_.setRegionScores(scores);
  BOLT_SSD_CACHE_LOG(INFO) << fmt::format(
      "Starting shard {} from checkpoint with {} entries, {} regions with {} free.",