Leak reports collect information about the last uptrend

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 49 matching lines @@
     ~LeakReport();
 
     size_t alloc_size_bytes() const { return alloc_size_bytes_; }
 
     const InternalVector<uintptr_t>& call_stack() const { return call_stack_; }
 
     const InternalVector<AllocationBreakdown>& alloc_breakdown_history() const {
       return alloc_breakdown_history_;
     }
 
+    size_t num_rising_intervals() const { return num_rising_intervals_; }
+
+    uint32_t num_allocs_increase() const { return num_allocs_increase_; }
+
+    // Transform number of allocation events into number of analysis intervals.
+    void normalize_num_rising_intervals(size_t timeslot_size) {

[Simon Que, 2016/10/11 01:11:06]

This is a bad design pattern because you could call this multiple times and it
will make this division multiple times.

I suggest using accessor/mutator for |num_rising_intervals|.

[mwlodar, 2016/10/11 07:13:24]

Done.

+      num_rising_intervals_ /= timeslot_size;
+    }
+
     // 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_;
 
+    // Number of intervals in the last uptrend.
+    size_t num_rising_intervals_;
+
+    // Net number of bytes allocated in the last uptrend.
+    uint32_t num_allocs_increase_;
+
     // Unlike the CallStack struct, which consists of addresses, this call stack
     // will contain offsets in the executable binary.
     InternalVector<uintptr_t> call_stack_;
 
     // 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.
   bool ShouldGetStackTraceForSize(size_t size) const;
 
   // Record allocs and frees.
   void RecordAlloc(const void* ptr,
                    size_t size,
                    int stack_depth,
                    const void* const call_stack[]);
   void RecordFree(const void* ptr);
 
   // Run check for possible leaks based on the current profiling data.
-  void TestForLeaks(InternalVector<LeakReport>* reports);
+  void TestForLeaks(InternalVector<LeakReport>* reports, size_t timestamp);

[Simon Que, 2016/10/11 01:11:06]

Explain the role of |timestamp| in the comments.

[mwlodar, 2016/10/11 07:13:24]

I have added comments below.

 
  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;
@@ skipping 38 matching lines @@
   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();
+  void RecordCurrentAllocationDataInHistory(size_t timestamp);
 
   // 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);
+                                   LeakReport* report, size_t timestamp);
 
   // Decrements the cooldown counter (value) for each entry in
   // |cooldowns_per_leak_|. If the cooldown counter reaches 0, the entry is
   // removed. Thus, all extantentries in |cooldowns_per_leak_| maintain a
   // positive count.
   void UpdateLeakCooldowns();
 
   // Returns true if a particular leak signature (alloc size + call site) does
   // not have an active cooldown counter (i.e. does not have an entry in
   // |cooldowns_per_leak_|.
@@ skipping 51 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_