Method checkConsistency

bolt/common/memory/HashStringAllocator.cpp:680–764

}

int64_t HashStringAllocator::checkConsistency() const {
  static const auto kHugePageSize = memory::AllocationTraits::kHugePageSize;

  uint64_t numFree = 0;
  uint64_t freeBytes = 0;
  int64_t allocatedBytes = 0;
  for (auto i = 0; i < pool_.numRanges(); ++i) {
    auto topRange = pool_.rangeAt(i);
    auto topRangeSize = topRange.size();
    if (topRangeSize >= kHugePageSize) {
      BOLT_CHECK_EQ(0, topRangeSize % kHugePageSize);
    }
    // Some ranges are short and contain one arena. Some are multiples of huge
    // page size and contain one arena per huge page.
    for (int64_t subRangeStart = 0; subRangeStart < topRangeSize;
         subRangeStart += kHugePageSize) {
      auto range = folly::Range<char*>(
          topRange.data() + subRangeStart,
          std::min<int64_t>(topRangeSize, kHugePageSize));
      auto size = range.size() - simd::kPadding;
      bool previousFree = false;
      auto end = reinterpret_cast<Header*>(range.data() + size);
      auto header = reinterpret_cast<Header*>(range.data());
      while (header != end) {
        BOLT_CHECK_GE(reinterpret_cast<char*>(header), range.data());
        BOLT_CHECK_LT(
            reinterpret_cast<char*>(header), reinterpret_cast<char*>(end));
        BOLT_CHECK_LE(
            reinterpret_cast<char*>(header->end()),
            reinterpret_cast<char*>(end));
        BOLT_CHECK_EQ(header->isPreviousFree(), previousFree);

        if (header->isFree()) {
          BOLT_CHECK(!previousFree);
          BOLT_CHECK(!header->isContinued());
          if (header->next()) {
            BOLT_CHECK_EQ(
                header->size(),
                *(reinterpret_cast<int32_t*>(header->end()) - 1));
          }
          ++numFree;
          freeBytes += sizeof(Header) + header->size();
        } else if (header->isContinued()) {
          // If the content of the header is continued, check the
          // continue header is readable and not free.
          auto continued = header->nextContinued();
          BOLT_CHECK(!continued->isFree());
          allocatedBytes += header->size() - Header::kContinuedPtrSize;
        } else {
          allocatedBytes += header->size();
        }
        previousFree = header->isFree();
        header = reinterpret_cast<Header*>(header->end());
      }
    }
  }

  BOLT_CHECK_EQ(numFree, numFree_);