commit 68aade07c705f3938d2a9d7a204588fcc505124d
author Kostya Kortchinsky <kostyak@google.com> Thu Jan 30 11:06:49 2020 -0800
committer Copybara-Service <copybara-worker@google.com> Thu Aug 27 23:56:44 2020 -0700
tree d5376584f9ed22db6e26b563bb7c5d4ed49de15b
parent 48150a85004a8f6c50a0589d479e5c17c74be802

[scudo][standalone] Release secondary memory on purge

Summary:
The Secondary's cache needs to be released when the Combined's
`releaseToOS` function is called (via `M_PURGE`) for example,
which this CL adds.

Additionally, if doing a forced release, we'll release the
transfer batch class as well since now we can do that.

There is a couple of other house keeping changes as well:
- read the page size only once in the Secondary Cache `store`
- remove the interval check for `CanRelease`: we are going to
  make that configurable via `mallopt` so this needs not be
  set in stone there.

Reviewers: cferris, hctim, pcc, eugenis

Subscribers: #sanitizers, llvm-commits

Tags: #sanitizers, #llvm

Differential Revision: https://reviews.llvm.org/D73730

GitOrigin-RevId: 654f5d684561d784fa8927d3de31b7dab3f28087

combined.h

diff --git a/combined.h b/combined.h
index 6e3bd09..4ae398a 100644
--- a/combined.h
+++ b/combined.h
@@ -567,6 +567,7 @@
   void releaseToOS() {
     initThreadMaybe();
     Primary.releaseToOS();
+    Secondary.releaseToOS();
   }
 
   // Iterate over all chunks and call a callback for all busy chunks located

primary32.h

diff --git a/primary32.h b/primary32.h
index 62d7981..ab7a1f3 100644
--- a/primary32.h
+++ b/primary32.h
@@ -73,8 +73,7 @@
       SizeClassInfo *Sci = getSizeClassInfo(I);
       Sci->RandState = getRandomU32(&Seed);
       // See comment in the 64-bit primary about releasing smaller size classes.
-      Sci->CanRelease = (ReleaseToOsInterval >= 0) &&
-                        (I != SizeClassMap::BatchClassId) &&
+      Sci->CanRelease = (I != SizeClassMap::BatchClassId) &&
                         (getSizeByClassId(I) >= (PageSize / 32));
     }
     ReleaseToOsIntervalMs = ReleaseToOsInterval;
@@ -178,8 +177,6 @@
   uptr releaseToOS() {
     uptr TotalReleasedBytes = 0;
     for (uptr I = 0; I < NumClasses; I++) {
-      if (I == SizeClassMap::BatchClassId)
-        continue;
       SizeClassInfo *Sci = getSizeClassInfo(I);
       ScopedLock L(Sci->Mutex);
       TotalReleasedBytes += releaseToOSMaybe(Sci, I, /*Force=*/true);

primary64.h

diff --git a/primary64.h b/primary64.h
index 5b83f0c..02e8051 100644
--- a/primary64.h
+++ b/primary64.h
@@ -86,8 +86,7 @@
       // memory accesses which ends up being fairly costly. The current lower
       // limit is mostly arbitrary and based on empirical observations.
       // TODO(kostyak): make the lower limit a runtime option
-      Region->CanRelease = (ReleaseToOsInterval >= 0) &&
-                           (I != SizeClassMap::BatchClassId) &&
+      Region->CanRelease = (I != SizeClassMap::BatchClassId) &&
                            (getSizeByClassId(I) >= (PageSize / 32));
       Region->RandState = getRandomU32(&Seed);
     }
@@ -190,8 +189,6 @@
   uptr releaseToOS() {
     uptr TotalReleasedBytes = 0;
     for (uptr I = 0; I < NumClasses; I++) {
-      if (I == SizeClassMap::BatchClassId)
-        continue;
       RegionInfo *Region = getRegionInfo(I);
       ScopedLock L(Region->Mutex);
       TotalReleasedBytes += releaseToOSMaybe(Region, I, /*Force=*/true);

secondary.h

diff --git a/secondary.h b/secondary.h
index 0e6ce4c..feb43e7 100644
--- a/secondary.h
+++ b/secondary.h
@@ -59,6 +59,7 @@
   static bool canCache(UNUSED uptr Size) { return false; }
   void disable() {}
   void enable() {}
+  void releaseToOS() {}
 };
 
 template <uptr MaxEntriesCount = 32U, uptr MaxEntrySize = 1UL << 19>
@@ -112,6 +113,7 @@
   }
 
   bool retrieve(uptr Size, LargeBlock::Header **H) {
+    const uptr PageSize = getPageSizeCached();
     ScopedLock L(Mutex);
     if (EntriesCount == 0)
       return false;
@@ -121,7 +123,7 @@
       const uptr BlockSize = Entries[I].BlockEnd - Entries[I].Block;
       if (Size > BlockSize)
         continue;
-      if (Size < BlockSize - getPageSizeCached() * 4U)
+      if (Size < BlockSize - PageSize * 4U)
         continue;
       *H = reinterpret_cast<LargeBlock::Header *>(Entries[I].Block);
       Entries[I].Block = 0;
@@ -138,6 +140,8 @@
     return MaxEntriesCount != 0U && Size <= MaxEntrySize;
   }
 
+  void releaseToOS() { releaseOlderThan(UINT64_MAX); }
+
   void disable() { Mutex.lock(); }
 
   void enable() { Mutex.unlock(); }
@@ -259,6 +263,8 @@
 
   static uptr canCache(uptr Size) { return CacheT::canCache(Size); }
 
+  void releaseToOS() { Cache.releaseToOS(); }
+
 private:
   CacheT Cache;