[scudo][standalone] Add more stats to mallinfo

[cryptoad]

Summary

Android requires additional stats in mallinfo. While we can provide
right away the number of bytes mapped (Primary+Secondary), there was
no way to get the number of free bytes (only makes sense for the
Primary since the Secondary unmaps everything on deallocation).

An approximation could be StatMapped - StatAllocated, but since we
are mapping in 1<<17 increments for the 64-bit Primary, it's fairly
inaccurate.

So we introduce StatFree (note it's Free, not Freed!), which
keeps track of the amount of Primary blocks currently unallocated.

[cryptoad]

Adding usmblks as well.
Android uses it for getNativeHeapSize, so StatMapped will do.

[morehouse]

LGTM

compiler-rt/trunk/lib/scudo/standalone/local_cache.h

void *allocate(uptr ClassId) {
     // Count, while Chunks might be further off (depending on Count). That keeps
     // the memory accesses in close quarters.
     const uptr ClassSize = C->ClassSize;
     void *P = C->Chunks[--C->Count];
     // The jury is still out as to whether any kind of PREFETCH here increases
     // performance. It definitely decreases performance on Android though.
     // if (!SCUDO_ANDROID) PREFETCH(P);
     Stats.add(StatAllocated, ClassSize);
+    Stats.sub(StatFree, ClassSize);
     return P;
   }
 
   void deallocate(uptr ClassId, void *P) {
     CHECK_LT(ClassId, NumClasses);
     PerClass *C = &PerClassArray[ClassId];
     // We still have to initialize the cache in the event that the first heap
     // operation in a thread is a deallocation.
     initCacheMaybe(C);
     if (C->Count == C->MaxCount)
       drain(C, ClassId);
     // See comment in allocate() about memory accesses.
     const uptr ClassSize = C->ClassSize;
     C->Chunks[C->Count++] = P;
     Stats.sub(StatAllocated, ClassSize);
+    Stats.add(StatFree, ClassSize);
   }
 
   void drain() {
     for (uptr I = 0; I < NumClasses; I++) {
       PerClass *C = &PerClassArray[I];
       while (C->Count > 0)
         drain(C, I);
     }

compiler-rt/trunk/lib/scudo/standalone/mutex.h

 
 class HybridMutex {
 public:
   void init() { memset(this, 0, sizeof(*this)); }
   bool tryLock();
   NOINLINE void lock() {
     if (LIKELY(tryLock()))
       return;
       // The compiler may try to fully unroll the loop, ending up in a
       // NumberOfTries*NumberOfYields block of pauses mixed with tryLocks. This
       // is large, ugly and unneeded, a compact loop is better for our purpose
       // here. Use a pragma to tell the compiler not to unroll the loop.
 #ifdef __clang__
 #pragma nounroll
 #endif
     for (u8 I = 0U; I < NumberOfTries; I++) {
       yieldProcessor(NumberOfYields);
       if (tryLock())
         return;
     }

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

NOINLINE TransferBatch *populateFreeList(CacheT *C, uptr ClassId,
     }
     if (Count) {
       if (UNLIKELY(!populateBatches(C, Sci, ClassId, &B, MaxCount, ShuffleArray,
                                     Count)))
         return nullptr;
     }
     DCHECK(B);
     DCHECK_GT(B->getCount(), 0);
+
+    C->getStats().add(StatFree, AllocatedUser);
     Sci->AllocatedUser += AllocatedUser;
     if (Sci->CanRelease)
       Sci->ReleaseInfo.LastReleaseAtNs = getMonotonicTime();
     return B;
   }
 
   void printStats(uptr ClassId, uptr Rss) {
     SizeClassInfo *Sci = getSizeClassInfo(ClassId);

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

NOINLINE TransferBatch *populateFreeList(CacheT *C, uptr ClassId,
     if (Count) {
       if (UNLIKELY(!populateBatches(C, Region, ClassId, &B, MaxCount,
                                     ShuffleArray, Count)))
         return nullptr;
     }
     DCHECK(B);
     DCHECK_GT(B->getCount(), 0);
 
+    C->getStats().add(StatFree, AllocatedUser);
     Region->AllocatedUser += AllocatedUser;
     Region->Exhausted = false;
     if (Region->CanRelease)
       Region->ReleaseInfo.LastReleaseAtNs = getMonotonicTime();
 
     return B;
   }
 

compiler-rt/trunk/lib/scudo/standalone/stats.h

 #include "atomic_helpers.h"
 #include "mutex.h"
 
 #include <string.h>
 
 namespace scudo {
 
 // Memory allocator statistics
-enum StatType { StatAllocated, StatMapped, StatCount };
+enum StatType { StatAllocated, StatFree, StatMapped, StatCount };
 
 typedef uptr StatCounters[StatCount];
 
 // Per-thread stats, live in per-thread cache. We use atomics so that the
 // numbers themselves are consistent. But we don't use atomic_{add|sub} or a
 // lock, because those are expensive operations , and we only care for the stats
 // to be "somewhat" correct: eg. if we call GlobalStats::get while a thread is
 // LocalStats::add'ing, this is OK, we will still get a meaningful number.

compiler-rt/trunk/lib/scudo/standalone/tests/wrappers_c_test.cpp

 #ifndef M_DECAY_TIME
 #define M_DECAY_TIME -100
 #endif
 
 #ifndef M_PURGE
 #define M_PURGE -101
 #endif
 
-TEST(ScudoWrappersCTest, Mallopt) {
+TEST(ScudoWrappersCTest, MallOpt) {
   errno = 0;
   EXPECT_EQ(mallopt(-1000, 1), 0);
   // mallopt doesn't set errno.
   EXPECT_EQ(errno, 0);
 
   EXPECT_EQ(mallopt(M_PURGE, 0), 1);
 
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
TEST(ScudoWrappersCTest, OtherAlloc) {
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   free(P);
 
   EXPECT_EQ(valloc(SIZE_MAX), nullptr);
 }
+
+TEST(ScudoWrappersCTest, MallInfo) {
+  const size_t BypassQuarantineSize = 1024U;
+
+  struct mallinfo MI = mallinfo();
+  size_t Allocated = MI.uordblks;
+  void *P = malloc(BypassQuarantineSize);
+  EXPECT_NE(P, nullptr);
+  MI = mallinfo();
+  EXPECT_GE(static_cast<size_t>(MI.uordblks), Allocated + BypassQuarantineSize);
+  EXPECT_GT(static_cast<size_t>(MI.hblkhd), 0U);
+  size_t Free = MI.fordblks;
+  free(P);
+  MI = mallinfo();
+  EXPECT_GE(static_cast<size_t>(MI.fordblks), Free + BypassQuarantineSize);
+}

compiler-rt/trunk/lib/scudo/standalone/wrappers_c.inc

 INTERFACE WEAK void SCUDO_PREFIX(free)(void *ptr) {
   SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
 }
 
 INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) {
   struct SCUDO_MALLINFO Info = {};
   scudo::StatCounters Stats;
   SCUDO_ALLOCATOR.getStats(Stats);
+  // Space allocated in mmapped regions (bytes)
+  Info.hblkhd = static_cast<__scudo_mallinfo_data_t>(Stats[scudo::StatMapped]);
+  // Maximum total allocated space (bytes)
+  Info.usmblks = Info.hblkhd;
+  // Space in freed fastbin blocks (bytes)
+  Info.fsmblks = static_cast<__scudo_mallinfo_data_t>(Stats[scudo::StatFree]);
+  // Total allocated space (bytes)
   Info.uordblks =
       static_cast<__scudo_mallinfo_data_t>(Stats[scudo::StatAllocated]);
+  // Total free space (bytes)
+  Info.fordblks = Info.fsmblks;
   return Info;
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(malloc)(size_t size) {
   return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
       size, scudo::Chunk::Origin::Malloc, SCUDO_MALLOC_ALIGNMENT));
 }