[NFC][sanitizer] Remove global PersistentAllocator

[vitalybuka]

Summary

This way is easier to track memory usage and do other
incremental refactorings.

[vitalybuka]

update a test

[morehouse]

compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h

57

This changes the meaning of stats.allocated to "mmapped memory" instead of "returned memory"

57

duplicate line.

[vitalybuka]

remove duplicate

[vitalybuka]

fixed size

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h

57

Probably not important but easy to fix.

[morehouse]

LGTM

[vitalybuka]

rebase

[vitalybuka]

fix rebase

compiler-rt/lib/sanitizer_common/sanitizer_chained_origin_depot.h

struct ChainedOriginDepotNode {
     u32 id;
     u32 here_id;
     u32 prev_id;
 
     typedef ChainedOriginDepotDesc args_type;
 
     bool eq(hash_type hash, const args_type &args) const;
 
-    static uptr storage_size(const args_type &args);
+    static uptr allocated();
+
+    static ChainedOriginDepotNode *allocate(const args_type &args);
 
     static hash_type hash(const args_type &args);
 
     static bool is_valid(const args_type &args);
 
     void store(const args_type &args, hash_type other_hash);
 
     args_type load() const;

compiler-rt/lib/sanitizer_common/sanitizer_chained_origin_depot.cpp

 //===-- sanitizer_chained_origin_depot.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // A storage for chained origins.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_chained_origin_depot.h"
 
 namespace __sanitizer {
 
+static PersistentAllocator allocator;
+
 bool ChainedOriginDepot::ChainedOriginDepotNode::eq(
     hash_type hash, const args_type &args) const {
   return here_id == args.here_id && prev_id == args.prev_id;
 }
 
-uptr ChainedOriginDepot::ChainedOriginDepotNode::storage_size(
-    const args_type &args) {
-  return sizeof(ChainedOriginDepotNode);
+uptr ChainedOriginDepot::ChainedOriginDepotNode::allocated() {
+  return allocator.allocated();
+}
+
+ChainedOriginDepot::ChainedOriginDepotNode *
+ChainedOriginDepot::ChainedOriginDepotNode::allocate(const args_type &args) {
+  return static_cast<ChainedOriginDepot::ChainedOriginDepotNode *>(
+      allocator.alloc(sizeof(ChainedOriginDepotNode)));
 }
 
 /* This is murmur2 hash for the 64->32 bit case.
    It does not behave all that well because the keys have a very biased
    distribution (I've seen 7-element buckets with the table only 14% full).
 
    here_id is built of
    * (1 bits) Reserved, zero.

compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h

 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 
 namespace __sanitizer {
 
 class PersistentAllocator {
  public:
   void *alloc(uptr size);
+  uptr allocated() const {
+    SpinMutexLock l(&mtx);
+    return atomic_load_relaxed(&mapped_size) +
+           atomic_load_relaxed(&region_pos) - atomic_load_relaxed(&region_end);
+  }
 
  private:
   void *tryAlloc(uptr size);
   void *refillAndAlloc(uptr size);
-  StaticSpinMutex mtx;  // Protects alloc of new blocks for region allocator.
+  mutable StaticSpinMutex mtx;  // Protects alloc of new blocks.
   atomic_uintptr_t region_pos;  // Region allocator for Node's.
   atomic_uintptr_t region_end;
+  atomic_uintptr_t mapped_size;
 };
 
 inline void *PersistentAllocator::tryAlloc(uptr size) {
   // Optimisic lock-free allocation, essentially try to bump the region ptr.
   for (;;) {
     uptr cmp = atomic_load(&region_pos, memory_order_acquire);
     uptr end = atomic_load(&region_end, memory_order_acquire);
     if (cmp == 0 || cmp + size > end) return nullptr;
     if (atomic_compare_exchange_weak(&region_pos, &cmp, cmp + size,
                                      memory_order_acquire))
       return (void *)cmp;
   }
 }
 
 inline void *PersistentAllocator::alloc(uptr size) {
   // First, try to allocate optimisitically.
   void *s = tryAlloc(size);
   if (s) return s;
   return refillAndAlloc(size);
 }
 
-extern PersistentAllocator thePersistentAllocator;
-inline void *PersistentAlloc(uptr sz) {
-  return thePersistentAllocator.alloc(sz);
-}
-
 } // namespace __sanitizer
 
 #endif // SANITIZER_PERSISTENT_ALLOCATOR_H

compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.cpp

 //===-- sanitizer_persistent_allocator.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 #include "sanitizer_persistent_allocator.h"
 
 namespace __sanitizer {
 
-PersistentAllocator thePersistentAllocator;
-
 void *PersistentAllocator::refillAndAlloc(uptr size) {
   // If failed, lock, retry and alloc new superblock.
   SpinMutexLock l(&mtx);
   for (;;) {
     void *s = tryAlloc(size);
     if (s)
       return s;
     atomic_store(&region_pos, 0, memory_order_relaxed);
     uptr allocsz = 64 * 1024;
     if (allocsz < size)
       allocsz = size;
     uptr mem = (uptr)MmapOrDie(allocsz, "stack depot");
+    atomic_fetch_add(&mapped_size, allocsz, memory_order_relaxed);
     atomic_store(&region_end, mem + allocsz, memory_order_release);
     atomic_store(&region_pos, mem, memory_order_release);
   }
 }
 
 }  // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cpp

 //===-- sanitizer_stackdepot.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_stackdepot.h"
 
 #include "sanitizer_common.h"
 #include "sanitizer_hash.h"
+#include "sanitizer_persistent_allocator.h"
 #include "sanitizer_stackdepotbase.h"
 
 namespace __sanitizer {
 
+static PersistentAllocator allocator;
+
 struct StackDepotNode {
   using hash_type = u64;
   hash_type stack_hash;
   StackDepotNode *link;
   u32 id;
   u32 size;
   atomic_uint32_t tag_and_use_count;  // tag : 12 high bits; use_count : 20;
   uptr stack[1];  // [size]
 
   static const u32 kTabSizeLog = SANITIZER_ANDROID ? 16 : 20;
   static const u32 kUseCountBits = 20;
   static const u32 kMaxUseCount = 1 << kUseCountBits;
   static const u32 kUseCountMask = (1 << kUseCountBits) - 1;
 
   typedef StackTrace args_type;
   bool eq(hash_type hash, const args_type &args) const {
     return hash == stack_hash;
   }
-  static uptr storage_size(const args_type &args) {
-    return sizeof(StackDepotNode) + (args.size - 1) * sizeof(uptr);
+  static uptr allocated() { return allocator.allocated(); }
+  static StackDepotNode *allocate(const args_type &args) {
+    uptr alloc_size = sizeof(StackDepotNode) + (args.size - 1) * sizeof(uptr);
+    return (StackDepotNode *)allocator.alloc(alloc_size);
   }
   static hash_type hash(const args_type &args) {
     MurMur2Hash64Builder H(args.size * sizeof(uptr));
     for (uptr i = 0; i < args.size; i++) H.add(args.trace[i]);
     H.add(args.tag);
     return H.get();
   }
   static bool is_valid(const args_type &args) {

compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h

public:
   typedef typename Node::args_type args_type;
   typedef typename Node::handle_type handle_type;
   typedef typename Node::hash_type hash_type;
   // Maps stack trace to an unique id.
   handle_type Put(args_type args, bool *inserted = nullptr);
   // Retrieves a stored stack trace by the id.
   args_type Get(u32 id);
 
-  StackDepotStats GetStats() const { return stats; }
+  StackDepotStats GetStats() const { return {n_uniq_ids, Node::allocated()}; }
 
   void LockAll();
   void UnlockAll();
   void PrintAll();
 
  private:
   static Node *find(Node *s, args_type args, hash_type hash);
   static Node *lock(atomic_uintptr_t *p);
   static void unlock(atomic_uintptr_t *p, Node *s);
 
   static const int kTabSize = 1 << kTabSizeLog;  // Hash table size.
   static const int kPartBits = 8;
   static const int kPartShift = sizeof(u32) * 8 - kPartBits - kReservedBits;
   static const int kPartCount =
       1 << kPartBits;  // Number of subparts in the table.
   static const int kPartSize = kTabSize / kPartCount;
   static const int kMaxId = 1 << kPartShift;
 
   atomic_uintptr_t tab[kTabSize];   // Hash table of Node's.
   atomic_uint32_t seq[kPartCount];  // Unique id generators.
 
-  StackDepotStats stats;
+  uptr n_uniq_ids;
 
   friend class StackDepotReverseMap;
 };
 
 template <class Node, int kReservedBits, int kTabSizeLog>
 Node *StackDepotBase<Node, kReservedBits, kTabSizeLog>::find(Node *s,
                                                              args_type args,
                                                              hash_type hash) {
if (s2 != s) {
     node = find(s2, args, h);
     if (node) {
       unlock(p, s2);
       return node->get_handle();
     }
   }
   uptr part = (h % kTabSize) / kPartSize;
   u32 id = atomic_fetch_add(&seq[part], 1, memory_order_relaxed) + 1;
-  stats.n_uniq_ids++;
+  n_uniq_ids++;
   CHECK_LT(id, kMaxId);
   id |= part << kPartShift;
   CHECK_NE(id, 0);
   CHECK_EQ(id & (((u32)-1) >> kReservedBits), id);
-  uptr memsz = Node::storage_size(args);
-  s = (Node *)PersistentAlloc(memsz);
-  stats.allocated += memsz;
+  s = Node::allocate(args);
   s->id = id;
   s->store(args, h);
   s->link = s2;
   unlock(p, s);
   if (inserted) *inserted = true;
   return s->get_handle();
 }