[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

61

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

64

duplicate line.

[vitalybuka]

remove duplicate

[vitalybuka]

fixed size

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h

61

Probably not important but easy to fix.

[morehouse]

LGTM

[vitalybuka]

rebase

[vitalybuka]

fix rebase

clang/docs/tools/clang-formatted-files.txt

 compiler-rt/lib/sanitizer_common/sancov_flags.h
 compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.h
 compiler-rt/lib/sanitizer_common/sanitizer_chained_origin_depot.cpp
 compiler-rt/lib/sanitizer_common/sanitizer_chained_origin_depot.h
 compiler-rt/lib/sanitizer_common/sanitizer_errno.h
 compiler-rt/lib/sanitizer_common/sanitizer_errno_codes.h
 compiler-rt/lib/sanitizer_common/sanitizer_local_address_space_view.h
 compiler-rt/lib/sanitizer_common/sanitizer_openbsd.cpp
-compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.cpp
 compiler-rt/lib/sanitizer_common/sanitizer_placement_new.h
 compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h
 compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_openbsd.cpp
 compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_openbsd.h
 compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
 compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_fuchsia.h
 compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_fuchsia.h
 compiler-rt/lib/sanitizer_common/sanitizer_thread_safety.h

compiler-rt/lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_SOURCES_NOTERMINATION
   sanitizer_fuchsia.cpp
   sanitizer_libc.cpp
   sanitizer_libignore.cpp
   sanitizer_linux.cpp
   sanitizer_linux_s390.cpp
   sanitizer_mac.cpp
   sanitizer_mutex.cpp
   sanitizer_netbsd.cpp
-  sanitizer_persistent_allocator.cpp
   sanitizer_platform_limits_freebsd.cpp
   sanitizer_platform_limits_linux.cpp
   sanitizer_platform_limits_netbsd.cpp
   sanitizer_platform_limits_posix.cpp
   sanitizer_platform_limits_solaris.cpp
   sanitizer_posix.cpp
   sanitizer_printf.cpp
   sanitizer_procmaps_common.cpp

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.total_size();
+}
+
+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 total_size() const { return atomic_load_relaxed(&allocated_size); }
 
  private:
   void *tryAlloc(uptr size);
   StaticSpinMutex mtx;  // Protects alloc of new blocks for region allocator.
   atomic_uintptr_t region_pos;  // Region allocator for Node's.
   atomic_uintptr_t region_end;
+  atomic_uintptr_t allocated_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;
inline void *PersistentAllocator::alloc(uptr size) {
   SpinMutexLock l(&mtx);
   for (;;) {
     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(&allocated_size, allocsz, memory_order_relaxed);
     atomic_store(&region_end, mem + allocsz, memory_order_release);
     atomic_store(&region_pos, mem, memory_order_release);
+    atomic_store(&region_pos, mem, memory_order_release);
   }
 }
 
-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;
-
-}  // 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.total_size(); }
+  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();
 }
 

compiler-rt/lib/tsan/go/buildgo.sh

SRCS="
   ../../sanitizer_common/sanitizer_common.cpp
   ../../sanitizer_common/sanitizer_common_libcdep.cpp
   ../../sanitizer_common/sanitizer_deadlock_detector2.cpp
   ../../sanitizer_common/sanitizer_file.cpp
   ../../sanitizer_common/sanitizer_flag_parser.cpp
   ../../sanitizer_common/sanitizer_flags.cpp
   ../../sanitizer_common/sanitizer_libc.cpp
   ../../sanitizer_common/sanitizer_mutex.cpp
-  ../../sanitizer_common/sanitizer_persistent_allocator.cpp
   ../../sanitizer_common/sanitizer_printf.cpp
   ../../sanitizer_common/sanitizer_suppressions.cpp
   ../../sanitizer_common/sanitizer_thread_registry.cpp
   ../../sanitizer_common/sanitizer_stackdepot.cpp
   ../../sanitizer_common/sanitizer_stacktrace.cpp
   ../../sanitizer_common/sanitizer_symbolizer.cpp
   ../../sanitizer_common/sanitizer_symbolizer_report.cpp
   ../../sanitizer_common/sanitizer_termination.cpp

llvm/utils/gn/secondary/compiler-rt/lib/sanitizer_common/BUILD.gn

sources = [
     "sanitizer_list.h",
     "sanitizer_local_address_space_view.h",
     "sanitizer_mac.cpp",
     "sanitizer_mac.h",
     "sanitizer_mac_libcdep.cpp",
     "sanitizer_mutex.cpp",
     "sanitizer_mutex.h",
     "sanitizer_netbsd.cpp",
-    "sanitizer_persistent_allocator.cpp",
     "sanitizer_persistent_allocator.h",
     "sanitizer_placement_new.h",
     "sanitizer_platform.h",
     "sanitizer_platform_interceptors.h",
     "sanitizer_platform_limits_freebsd.cpp",
     "sanitizer_platform_limits_linux.cpp",
     "sanitizer_platform_limits_netbsd.cpp",
     "sanitizer_platform_limits_netbsd.h",