[scudo] Secondary Cache Dump

[frs513]

Summary

Dumped some basic info about what is being cached and about the cache
itself. Output of test below:

...
Stats: MapAllocatorCache: EntriesCount: 33, MaxEntriesCount: 64, MaxEntrySize: 1048576
StartBlockAddress: 0x6d342c1000, EndBlockAddress: 0x6d342d2000, BlockSize: 69632
StartBlockAddress: 0x6fc45ff000, EndBlockAddress: 0x6fc462f000, BlockSize: 196608
...

[Chia-hungDuan]

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

144

Can we use %d here? If we do need casting, static_cast is preferred.

Same comment as the following casting.

147

I think having the end of address will be useful too. Like we can get the idea of whether two cached blocks is adjacent.

338

Can you try to rebase? I think this should be included in other CLs.

[frs513]

[scudo] Secondary Cache Dump Revision

Changed casting method to static_cast<> and type of appended values.
Included ending block address so we could see if cache blocks are adjacent.

[Chia-hungDuan]

Have you updated the commit message to include the EndBlockAddress? You may also want to update the description in the summary here in Phabricator

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

144

Once we use %d here, I think we don't need the casting here? Sorry I may not make it clear.

Use the proper placeholders (%d, %zu, .etc) if possible, otherwise, casting with static_cast.

Like this, https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/scudo/standalone/report.cpp#L60-L61

[frs513]

Expanded cache dump

added the ending address of each cache block and fixed the formatting of
str->append(...) so that the correct types were being used and so that
we could avoid casting as much as possible.

[Chia-hungDuan]

LGTM! One last thing, you may want to update the commit message to include the EndBlockAddress as well

[frs513]

ran the clang formatter

[Chia-hungDuan]

Thanks!

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

public:
   void unmapTestOnly() {}
   bool setOption(Option O, UNUSED sptr Value) {
     if (O == Option::ReleaseInterval || O == Option::MaxCacheEntriesCount ||
         O == Option::MaxCacheEntrySize)
       return false;
     // Not supported by the Secondary Cache, but not an error either.
     return true;
   }
+
+  void getStats(UNUSED ScopedString *Str) {
+    Str->append("Secondary Cache Disabled\n");
+  }
 };
 
 static const uptr MaxUnusedCachePages = 4U;
 
 template <typename Config>
 void mapSecondary(Options Options, uptr CommitBase, uptr CommitSize,
                   uptr AllocPos, uptr Flags, MemMapT &MemMap) {
   const uptr MaxUnusedCacheBytes = MaxUnusedCachePages * getPageSizeCached();

 template <typename T> class NonZeroLengthArray<T, 0> {
 public:
   T &operator[](uptr UNUSED Idx) { UNREACHABLE("Unsupported!"); }
 };
 
 template <typename Config> class MapAllocatorCache {
 public:
   using CacheConfig = typename Config::Secondary::Cache;
+
+  void getStats(ScopedString *Str) {
+    ScopedLock L(Mutex);
+    Str->append("Stats: MapAllocatorCache: EntriesCount: %d, "
+                "MaxEntriesCount: %u, MaxEntrySize: %zu\n",
+                EntriesCount, atomic_load_relaxed(&MaxEntriesCount),
+                atomic_load_relaxed(&MaxEntrySize));
+    for (CachedBlock Entry : Entries) {
+      Str->append("StartBlockAddress: 0x%zx, EndBlockAddress: 0x%zx, "
+                  "BlockSize: %zu\n",
+                  Entry.CommitBase, (Entry.CommitBase + Entry.CommitSize),
+                  Entry.CommitSize);
+    }
+  }
+
   // Ensure the default maximum specified fits the array.
   static_assert(CacheConfig::DefaultMaxEntriesCount <=
                     CacheConfig::EntriesArraySize,
                 "");
 
   void init(s32 ReleaseToOsInterval) NO_THREAD_SAFETY_ANALYSIS {
     DCHECK_EQ(EntriesCount, 0U);
     setOption(Option::MaxCacheEntriesCount,
bool setOption(Option O, sptr Value) {
     // Not supported by the Secondary Cache, but not an error either.
     return true;
   }
 
   void releaseToOS() { releaseOlderThan(UINT64_MAX); }
 
   void disableMemoryTagging() EXCLUDES(Mutex) {
     ScopedLock L(Mutex);
     for (u32 I = 0; I != CacheConfig::QuarantineSize; ++I) {
       if (Quarantine[I].CommitBase) {
         MemMapT &MemMap = Quarantine[I].MemMap;
         MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
         Quarantine[I].CommitBase = 0;
       }
     }
     const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
     for (u32 I = 0; I < MaxCount; I++) {
static uptr getBlockEnd(void *Ptr) {
     auto *B = LargeBlock::getHeader<Config>(Ptr);
     return B->CommitBase + B->CommitSize;
   }
 
   static uptr getBlockSize(void *Ptr) {
     return getBlockEnd(Ptr) - reinterpret_cast<uptr>(Ptr);
   }
 
-  void getStats(ScopedString *Str);
-
   void disable() NO_THREAD_SAFETY_ANALYSIS {
     Mutex.lock();
     Cache.disable();
   }
 
   void enable() NO_THREAD_SAFETY_ANALYSIS {
     Cache.enable();
     Mutex.unlock();
public:
   bool setOption(Option O, sptr Value) { return Cache.setOption(O, Value); }
 
   void releaseToOS() { Cache.releaseToOS(); }
 
   void disableMemoryTagging() { Cache.disableMemoryTagging(); }
 
   void unmapTestOnly() { Cache.unmapTestOnly(); }
 
+  void getStats(ScopedString *Str);
+
 private:
   typename Config::Secondary::template CacheT<Config> Cache;
 
   mutable HybridMutex Mutex;
   DoublyLinkedList<LargeBlock::Header> InUseBlocks GUARDED_BY(Mutex);
   uptr AllocatedBytes GUARDED_BY(Mutex) = 0;
   uptr FreedBytes GUARDED_BY(Mutex) = 0;
   uptr LargestSize GUARDED_BY(Mutex) = 0;

 template <typename Config>
 void MapAllocator<Config>::getStats(ScopedString *Str) EXCLUDES(Mutex) {
   ScopedLock L(Mutex);
   Str->append("Stats: MapAllocator: allocated %u times (%zuK), freed %u times "
               "(%zuK), remains %u (%zuK) max %zuM\n",
               NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees,
               FreedBytes >> 10, NumberOfAllocs - NumberOfFrees,
               (AllocatedBytes - FreedBytes) >> 10, LargestSize >> 20);
+  Cache.getStats(Str);
 }
 
 } // namespace scudo
 
 #endif // SCUDO_SECONDARY_H_