Record call site history in LeakDetectorImpl

components/metrics/leak_detector/leak_detector_impl.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_IMPL_H_
 #define COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 20 matching lines @@
   // CustomAllocator to avoid recursive malloc hook invocation when analyzing
   // allocs and frees.
   template <typename T>
   using InternalList = std::list<T, STLAllocator<T, CustomAllocator>>;
   template <typename T>
   using InternalVector = std::vector<T, STLAllocator<T, CustomAllocator>>;
 
   // Leak report generated by LeakDetectorImpl.
   class LeakReport {
    public:
+    // Stores a record of the allocation bookkeeping taken at a single moment in
+    // time.
+    struct AllocationBreakdown {
+      AllocationBreakdown();
+      ~AllocationBreakdown();
+
+      // The contents of |LeakDetectorImpl::size_breakdown_history_| when this
+      // report was generated. See comment description of that variable.
+      InternalVector<uint32_t> counts_by_size;
+
+      // The net number of allocations with alloc size of
+      // |Leakreport::alloc_size_bytes_| allocated from |call_stack_|, at the
+      // time this record was generated.
+      uint32_t count_for_call_stack;
+    };
+
     LeakReport();
     ~LeakReport();
 
     size_t alloc_size_bytes() const { return alloc_size_bytes_; }
 
     const InternalVector<uintptr_t>& call_stack() const { return call_stack_; }
 
-    const InternalVector<InternalVector<uint32_t>>& size_breakdown_history()
-        const {
-      return size_breakdown_history_;
+    const InternalVector<AllocationBreakdown>& alloc_breakdown_history() const {
+      return alloc_breakdown_history_;
     }
 
     // Used to compare the contents of two leak reports.
     bool operator<(const LeakReport& other) const;
 
    private:
     // LeakDetectorImpl needs access to class members when creating a new leak
     // report.
     friend class LeakDetectorImpl;
 
     // Number of bytes allocated by the leak site during each allocation.
     size_t alloc_size_bytes_;
 
     // Unlike the CallStack struct, which consists of addresses, this call stack
     // will contain offsets in the executable binary.
     InternalVector<uintptr_t> call_stack_;
 
-    // A snapshot of LeakDetectorImpl::size_breakdown_history_ when this report
-    // was generated. See comment description of that variable.
-    InternalVector<InternalVector<uint32_t>> size_breakdown_history_;
+    // Records of allocation bookkeeping over time. The first element is the
+    // oldest entry and the last element is the newest.
+    InternalVector<AllocationBreakdown> alloc_breakdown_history_;
   };
 
   LeakDetectorImpl(uintptr_t mapping_addr,
                    size_t mapping_size,
                    int size_suspicion_threshold,
                    int call_stack_suspicion_threshold);
   ~LeakDetectorImpl();
 
   // Indicates whether the given allocation size has an associated call stack
   // table, and thus requires a stack unwind.
@@ skipping 12 matching lines @@
  private:
   // A record of allocations for a particular size.
   struct AllocSizeEntry {
     // Number of allocations and frees for this size.
     uint32_t num_allocs;
     uint32_t num_frees;
 
     // A stack table, if this size is being profiled for stack as well.
     CallStackTable* stack_table;
 
+    // Historical records of allocation breakdown by call site, for a particular
+    // allocation size. Each entry in the list is a RankedSet containing the top
+    // call sites ordered by most number of call sites, collected during a leak
+    // analysis. The oldest record is at the head and the newest record is at
+    // the tail.
+    InternalList<RankedSet> call_site_breakdown_history;
+
+    AllocSizeEntry();
+    ~AllocSizeEntry();
+
     // Returns net number of allocs.
     uint32_t GetNetAllocs() const { return num_allocs - num_frees; }
   };
 
   // Info for a single allocation.
   struct AllocInfo {
     AllocInfo() : call_stack(nullptr) {}
 
     // Number of bytes in this allocation.
     size_t size;
 
     // Points to a unique call stack.
     const CallStack* call_stack;
   };
 
   // Allocator class for allocation entry map. Maps allocated addresses to
   // AllocInfo objects.
   using AllocationEntryAllocator =
       STLAllocator<std::pair<const uintptr_t, AllocInfo>, CustomAllocator>;
 
   // Hash class for addresses.
   struct AddressHash {
     size_t operator()(uintptr_t addr) const;
   };
 
   // Returns the offset of |ptr| within the current binary. If it is not in the
   // current binary, just return |ptr| as an integer.
   uintptr_t GetOffset(const void* ptr) const;
 
+  // Record some of the current allocation bookkeeping. The net number of allocs
+  // per size is recorded in |size_breakdown_history_|. The net number of allocs
+  // per call site for each size is recorded in
+  // |AllocSizeEntry::call_site_breakdown_history|.
+  //
+  // Not all the net alloc counts are recorded. And the number of historical
+  // records kept is capped. If adding a new record exceeds that limit, the
+  // oldest record is discarded. See the function definition for more details.
+  void RecordCurrentAllocationDataInHistory();
+
+  // Store the data collected by RecordCurrentAllocationDataInHistory() in
+  // |*report|. Not all net alloc counts per call site will be stored, only the
+  // count for size=|size| and made from |call_site|.
+  void StoreHistoricalDataInReport(size_t size, const CallStack* call_site,
+                                   LeakReport* report);
+
   // Owns all unique call stack objects, which are allocated on the heap. Any
   // other class or function that references a call stack must get it from here,
   // but may not take ownership of the call stack object.
   CallStackManager call_stack_manager_;
 
   // Allocation stats.
   uint64_t num_allocs_;
   uint64_t num_frees_;
   uint64_t alloc_size_;
   uint64_t free_size_;
@@ skipping 33 matching lines @@
   // considered a leak suspect.
   int call_stack_suspicion_threshold_;
 
   DISALLOW_COPY_AND_ASSIGN(LeakDetectorImpl);
 };
 
 }  // namespace leak_detector
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_LEAK_DETECTOR_LEAK_DETECTOR_IMPL_H_