1//===-- asan_memory_profile.cc.cc -----------------------------------------===//
2//
3// This file is distributed under the University of Illinois Open Source
4// License. See LICENSE.TXT for details.
5//
6//===----------------------------------------------------------------------===//
7//
8// This file is a part of AddressSanitizer, an address sanity checker.
9//
10// This file implements __sanitizer_print_memory_profile.
11//===----------------------------------------------------------------------===//
12
13#include "sanitizer_common/sanitizer_common.h"
14#include "sanitizer_common/sanitizer_stackdepot.h"
15#include "sanitizer_common/sanitizer_stacktrace.h"
16#include "sanitizer_common/sanitizer_stoptheworld.h"
17#include "lsan/lsan_common.h"
18#include "asan/asan_allocator.h"
19
20#if CAN_SANITIZE_LEAKS
21
22namespace __asan {
23
24struct AllocationSite {
25  u32 id;
26  uptr total_size;
27  uptr count;
28};
29
30class HeapProfile {
31 public:
32  HeapProfile() { allocations_.reserve(1024); }
33
34  void ProcessChunk(const AsanChunkView &cv) {
35    if (cv.IsAllocated()) {
36      total_allocated_user_size_ += cv.UsedSize();
37      total_allocated_count_++;
38      u32 id = cv.GetAllocStackId();
39      if (id)
40        Insert(id, cv.UsedSize());
41    } else if (cv.IsQuarantined()) {
42      total_quarantined_user_size_ += cv.UsedSize();
43      total_quarantined_count_++;
44    } else {
45      total_other_count_++;
46    }
47  }
48
49  void Print(uptr top_percent, uptr max_number_of_contexts) {
50    Sort(allocations_.data(), allocations_.size(),
51         [](const AllocationSite &a, const AllocationSite &b) {
52           return a.total_size > b.total_size;
53         });
54    CHECK(total_allocated_user_size_);
55    uptr total_shown = 0;
56    Printf("Live Heap Allocations: %zd bytes in %zd chunks; quarantined: "
57           "%zd bytes in %zd chunks; %zd other chunks; total chunks: %zd; "
58           "showing top %zd%% (at most %zd unique contexts)\n",
59           total_allocated_user_size_, total_allocated_count_,
60           total_quarantined_user_size_, total_quarantined_count_,
61           total_other_count_, total_allocated_count_ +
62           total_quarantined_count_ + total_other_count_, top_percent,
63           max_number_of_contexts);
64    for (uptr i = 0; i < Min(allocations_.size(), max_number_of_contexts);
65         i++) {
66      auto &a = allocations_[i];
67      Printf("%zd byte(s) (%zd%%) in %zd allocation(s)\n", a.total_size,
68             a.total_size * 100 / total_allocated_user_size_, a.count);
69      StackDepotGet(a.id).Print();
70      total_shown += a.total_size;
71      if (total_shown * 100 / total_allocated_user_size_ > top_percent)
72        break;
73    }
74  }
75
76 private:
77  uptr total_allocated_user_size_ = 0;
78  uptr total_allocated_count_ = 0;
79  uptr total_quarantined_user_size_ = 0;
80  uptr total_quarantined_count_ = 0;
81  uptr total_other_count_ = 0;
82  InternalMmapVector<AllocationSite> allocations_;
83
84  void Insert(u32 id, uptr size) {
85    // Linear lookup will be good enough for most cases (although not all).
86    for (uptr i = 0; i < allocations_.size(); i++) {
87      if (allocations_[i].id == id) {
88        allocations_[i].total_size += size;
89        allocations_[i].count++;
90        return;
91      }
92    }
93    allocations_.push_back({id, size, 1});
94  }
95};
96
97static void ChunkCallback(uptr chunk, void *arg) {
98  reinterpret_cast<HeapProfile*>(arg)->ProcessChunk(
99      FindHeapChunkByAllocBeg(chunk));
100}
101
102static void MemoryProfileCB(const SuspendedThreadsList &suspended_threads_list,
103                            void *argument) {
104  HeapProfile hp;
105  __lsan::ForEachChunk(ChunkCallback, &hp);
106  uptr *Arg = reinterpret_cast<uptr*>(argument);
107  hp.Print(Arg[0], Arg[1]);
108
109  if (Verbosity())
110    __asan_print_accumulated_stats();
111}
112
113}  // namespace __asan
114
115#endif  // CAN_SANITIZE_LEAKS
116
117extern "C" {
118SANITIZER_INTERFACE_ATTRIBUTE
119void __sanitizer_print_memory_profile(uptr top_percent,
120                                      uptr max_number_of_contexts) {
121#if CAN_SANITIZE_LEAKS
122  uptr Arg[2];
123  Arg[0] = top_percent;
124  Arg[1] = max_number_of_contexts;
125  __sanitizer::StopTheWorld(__asan::MemoryProfileCB, Arg);
126#endif  // CAN_SANITIZE_LEAKS
127}
128}  // extern "C"
129