1 //===-- stats.h -------------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef SCUDO_STATS_H_ 10 #define SCUDO_STATS_H_ 11 12 #include "atomic_helpers.h" 13 #include "list.h" 14 #include "mutex.h" 15 16 #include <string.h> 17 18 namespace scudo { 19 20 // Memory allocator statistics 21 enum StatType { StatAllocated, StatFree, StatMapped, StatCount }; 22 23 typedef uptr StatCounters[StatCount]; 24 25 // Per-thread stats, live in per-thread cache. We use atomics so that the 26 // numbers themselves are consistent. But we don't use atomic_{add|sub} or a 27 // lock, because those are expensive operations , and we only care for the stats 28 // to be "somewhat" correct: eg. if we call GlobalStats::get while a thread is 29 // LocalStats::add'ing, this is OK, we will still get a meaningful number. 30 class LocalStats { 31 public: initLinkerInitialized()32 void initLinkerInitialized() {} init()33 void init() { memset(this, 0, sizeof(*this)); } 34 add(StatType I,uptr V)35 void add(StatType I, uptr V) { 36 V += atomic_load_relaxed(&StatsArray[I]); 37 atomic_store_relaxed(&StatsArray[I], V); 38 } 39 sub(StatType I,uptr V)40 void sub(StatType I, uptr V) { 41 V = atomic_load_relaxed(&StatsArray[I]) - V; 42 atomic_store_relaxed(&StatsArray[I], V); 43 } 44 set(StatType I,uptr V)45 void set(StatType I, uptr V) { atomic_store_relaxed(&StatsArray[I], V); } 46 get(StatType I)47 uptr get(StatType I) const { return atomic_load_relaxed(&StatsArray[I]); } 48 49 LocalStats *Next; 50 LocalStats *Prev; 51 52 private: 53 atomic_uptr StatsArray[StatCount]; 54 }; 55 56 // Global stats, used for aggregation and querying. 57 class GlobalStats : public LocalStats { 58 public: initLinkerInitialized()59 void initLinkerInitialized() {} init()60 void init() { 61 memset(this, 0, sizeof(*this)); 62 initLinkerInitialized(); 63 } 64 link(LocalStats * S)65 void link(LocalStats *S) { 66 ScopedLock L(Mutex); 67 StatsList.push_back(S); 68 } 69 unlink(LocalStats * S)70 void unlink(LocalStats *S) { 71 ScopedLock L(Mutex); 72 StatsList.remove(S); 73 for (uptr I = 0; I < StatCount; I++) 74 add(static_cast<StatType>(I), S->get(static_cast<StatType>(I))); 75 } 76 get(uptr * S)77 void get(uptr *S) const { 78 ScopedLock L(Mutex); 79 for (uptr I = 0; I < StatCount; I++) 80 S[I] = LocalStats::get(static_cast<StatType>(I)); 81 for (const auto &Stats : StatsList) { 82 for (uptr I = 0; I < StatCount; I++) 83 S[I] += Stats.get(static_cast<StatType>(I)); 84 } 85 // All stats must be non-negative. 86 for (uptr I = 0; I < StatCount; I++) 87 S[I] = static_cast<sptr>(S[I]) >= 0 ? S[I] : 0; 88 } 89 disable()90 void disable() { Mutex.lock(); } enable()91 void enable() { Mutex.unlock(); } 92 93 private: 94 mutable HybridMutex Mutex; 95 DoublyLinkedList<LocalStats> StatsList; 96 }; 97 98 } // namespace scudo 99 100 #endif // SCUDO_STATS_H_ 101