[scudo] Lazy initialize the PageMap while page releasing

[Chia-hungDuan]

Summary

We allocate the page map before knowing if there're groups can be
released. This may result in many redundant map()/unmap() operations if
there's no page to release.

Make the page map be lazy initialized.

[cferris]

compiler-rt/lib/scudo/standalone/release.h

269–270

Is it always the case that the NumberOfRegions, PagesCount, FullPagesBlockCountMax are the same when this is called? In other words, would you ever make this call and the values in the PageMap would need to be changed?

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/release.h

269–270

For each use in releaseToOSMaybe, those three variables will be the same. In different releaseToOSMaybe calls the PagesCount will change. It depends on the allocated size.

[cferris]

LGTM

compiler-rt/lib/scudo/standalone/release.h

269–270

This looks good to me. I checked and the only place where PagesCount is modified, there is a reset call there so that this should never be out of sync.

compiler-rt/lib/scudo/standalone/primary32.h

for (BatchGroup &BG : Sci->FreeList) {
       }
 
       BG.PushedBlocksAtLastCheckpoint = BG.PushedBlocks;
       // Note that we don't always visit blocks in each BatchGroup so that we
       // may miss the chance of releasing certain pages that cross BatchGroups.
       Context.markFreeBlocks(BG.Batches, DecompactPtr, Base);
     }
 
+    if (!Context.hasBlockMarked())
+      return 0;
+
     auto SkipRegion = [this, First, ClassId](uptr RegionIndex) {
       return (PossibleRegions[First + RegionIndex] - 1U) != ClassId;
     };
     releaseFreeMemoryToOS(Context, Recorder, SkipRegion);
 
     if (Recorder.getReleasedRangesCount() > 0) {
       Sci->ReleaseInfo.PushedBlocksAtLastRelease = Sci->Stats.PushedBlocks;
       Sci->ReleaseInfo.RangesReleased += Recorder.getReleasedRangesCount();

compiler-rt/lib/scudo/standalone/primary64.h

for (BatchGroup &BG : Region->FreeList) {
       }
 
       BG.PushedBlocksAtLastCheckpoint = BG.PushedBlocks;
       // Note that we don't always visit blocks in each BatchGroup so that we
       // may miss the chance of releasing certain pages that cross BatchGroups.
       Context.markFreeBlocks(BG.Batches, DecompactPtr, Region->RegionBeg);
     }
 
+    if (!Context.hasBlockMarked())
+      return 0;
+
     auto SkipRegion = [](UNUSED uptr RegionIndex) { return false; };
     releaseFreeMemoryToOS(Context, Recorder, SkipRegion);
 
     if (Recorder.getReleasedRangesCount() > 0) {
       Region->ReleaseInfo.PushedBlocksAtLastRelease =
           Region->Stats.PushedBlocks;
       Region->ReleaseInfo.RangesReleased += Recorder.getReleasedRangesCount();
       Region->ReleaseInfo.LastReleasedBytes = Recorder.getReleasedBytes();

compiler-rt/lib/scudo/standalone/release.h

if (BlockSize <= PageSize) {
         SameBlockCountPerPage = false;
       }
     }
 
     PagesCount = roundUpTo(RegionSize, PageSize) / PageSize;
     PageSizeLog = getLog2(PageSize);
     RoundedRegionSize = PagesCount << PageSizeLog;
     RoundedSize = NumberOfRegions * RoundedRegionSize;
+  }
+
+  // PageMap is lazily allocated when markFreeBlocks() is invoked.
+  bool hasBlockMarked() const {
+    return PageMap.isAllocated();
+  }
 
+  void ensurePageMapAllocated() {
+    if (PageMap.isAllocated())
+      return;
     PageMap.reset(NumberOfRegions, PagesCount, FullPagesBlockCountMax);
     DCHECK(PageMap.isAllocated());
   }
 
   template<class TransferBatchT, typename DecompactPtrT>
   void markFreeBlocks(const IntrusiveList<TransferBatchT> &FreeList,
                       DecompactPtrT DecompactPtr, uptr Base) {
+    ensurePageMapAllocated();
+
     // Iterate over free chunks and count how many free chunks affect each
     // allocated page.
     if (BlockSize <= PageSize && PageSize % BlockSize == 0) {
       // Each chunk affects one page only.
       for (const auto &It : FreeList) {
         for (u16 I = 0; I < It.getCount(); I++) {
           const uptr P = DecompactPtr(It.get(I)) - Base;
           if (P >= RoundedSize)

compiler-rt/lib/scudo/standalone/tests/release_test.cpp

for (scudo::uptr I = 1; I <= SizeClassMap::LargestClassId; I++) {
 
     // Release the memory.
     auto SkipRegion = [](UNUSED scudo::uptr RegionIndex) { return false; };
     auto DecompactPtr = [](scudo::uptr P) { return P; };
     ReleasedPagesRecorder Recorder;
     scudo::PageReleaseContext Context(BlockSize,
                                       /*RegionSize=*/MaxBlocks * BlockSize,
                                       /*NumberOfRegions=*/1U);
+    ASSERT_FALSE(Context.hasBlockMarked());
     Context.markFreeBlocks(FreeList, DecompactPtr, Recorder.getBase());
+    ASSERT_TRUE(Context.hasBlockMarked());
     releaseFreeMemoryToOS(Context, Recorder, SkipRegion);
     scudo::RegionPageMap &PageMap = Context.PageMap;
 
     // Verify that there are no released pages touched by used chunks and all
     // ranges of free chunks big enough to contain the entire memory pages had
     // these pages released.
     scudo::uptr VerifiedReleasedPages = 0;
     std::set<scudo::uptr> FreeBlocks(FreeArray.begin(), FreeArray.end());