Leak reports collect information about the last uptrend

components/metrics/leak_detector/leak_detector_impl.cc

 // 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.
 
 #include "leak_detector_impl.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include <algorithm>  // For std::move
@@ skipping 155 matching lines @@
   if (call_stack) {
     if (entry->stack_table)
       entry->stack_table->Remove(call_stack);
   }
   ++num_frees_;
   free_size_ += alloc_info.size;
 
   address_map_.erase(iter);
 }
 
-void LeakDetectorImpl::TestForLeaks(InternalVector<LeakReport>* reports) {
+void LeakDetectorImpl::TestForLeaks(InternalVector<LeakReport>* reports,
+                                    size_t timestamp) {
   // Add net alloc counts for each size to a ranked list.
   RankedSet size_ranked_set(kRankedSetSize);
   for (size_t i = 0; i < size_entries_.size(); ++i) {
     const AllocSizeEntry& entry = size_entries_[i];
     ValueType size_value(IndexToSize(i));
     size_ranked_set.Add(size_value, entry.GetNetAllocs());
   }
   size_leak_analyzer_.AddSample(std::move(size_ranked_set));
 
-  RecordCurrentAllocationDataInHistory();
+  RecordCurrentAllocationDataInHistory(timestamp);
 
   UpdateLeakCooldowns();
 
   // Get suspected leaks by size.
   for (const ValueType& size_value : size_leak_analyzer_.suspected_leaks()) {
     uint32_t size = size_value.size();
     AllocSizeEntry* entry = &size_entries_[SizeToIndex(size)];
     if (entry->stack_table)
       continue;
     entry->stack_table = new (CustomAllocator::Allocate(sizeof(CallStackTable)))
@@ skipping 26 matching lines @@
 
       // Return reports by storing in |*reports|.
       reports->resize(reports->size() + 1);
       LeakReport* report = &reports->back();
       report->alloc_size_bytes_ = size;
       report->call_stack_.resize(call_stack->depth);
       for (size_t j = 0; j < call_stack->depth; ++j) {
         report->call_stack_[j] = GetOffset(call_stack->stack[j]);
       }
 
-      StoreHistoricalDataInReport(size, call_stack, report);
+      StoreHistoricalDataInReport(size, call_stack, report, timestamp);
       ResetLeakCooldown(size, call_stack);
     }
   }
 }
 
 LeakDetectorImpl::AllocSizeEntry::AllocSizeEntry() : num_allocs(0),
                                                      num_frees(0),
                                                      stack_table(nullptr) {}
 
 LeakDetectorImpl::AllocSizeEntry::~AllocSizeEntry() {}
 
 size_t LeakDetectorImpl::AddressHash::operator()(uintptr_t addr) const {
   return base::Hash(reinterpret_cast<const char*>(&addr), sizeof(addr));
 }
 
 uintptr_t LeakDetectorImpl::GetOffset(const void* ptr) const {
   uintptr_t ptr_value = reinterpret_cast<uintptr_t>(ptr);
   if (ptr_value >= mapping_addr_ && ptr_value < mapping_addr_ + mapping_size_)
     return ptr_value - mapping_addr_;
   return UINTPTR_MAX;
 }
 
-void LeakDetectorImpl::RecordCurrentAllocationDataInHistory() {
+void LeakDetectorImpl::RecordCurrentAllocationDataInHistory(size_t timestamp) {
   // Record a snapshot of the current size table.
   InternalVector<uint32_t> current_size_table_record;
   current_size_table_record.reserve(kNumSizeEntriesInHistory);
   for (const AllocSizeEntry& entry : size_entries_) {
     if (current_size_table_record.size() == kNumSizeEntriesInHistory)
       break;
     current_size_table_record.push_back(entry.GetNetAllocs());
   }
   size_breakdown_history_.emplace_back(std::move(current_size_table_record));
   if (size_breakdown_history_.size() > kMaxNumHistoryEntries)
     size_breakdown_history_.pop_front();
 
   // For each allocation size that has started profiling by call site, record a
   // snapshot of the top call sites by number of allocations.
   for (AllocSizeEntry& entry : size_entries_) {
     if (!entry.stack_table)
       continue;
     RankedSet top_call_stacks(kNumTopCallStacksInHistory);
     entry.stack_table->GetTopCallStacks(&top_call_stacks);
+    entry.stack_table->UpdateLastDropInfo(timestamp);
     entry.call_site_breakdown_history.push_back(std::move(top_call_stacks));
     if (entry.call_site_breakdown_history.size() > kMaxNumHistoryEntries)
       entry.call_site_breakdown_history.pop_front();
   }
 }
 
 void LeakDetectorImpl::StoreHistoricalDataInReport(size_t size,
                                                    const CallStack* call_site,
-                                                   LeakReport* report) {
+                                                   LeakReport* report,
+                                                   size_t timestamp) {
   using AllocationBreakdown = LeakReport::AllocationBreakdown;
   // Copy historical allocation data into the report.
   InternalVector<AllocationBreakdown>* dest = &report->alloc_breakdown_history_;
   dest->reserve(size_breakdown_history_.size());
 
   // Store each frame of the breakdown by size.
   for (const InternalVector<uint32_t>& breakdown : size_breakdown_history_) {
     dest->push_back(AllocationBreakdown());
     dest->back().counts_by_size = breakdown;
   }
@@ skipping 15 matching lines @@
     std::advance(dest_iter, dest->size() - src.size());
 
   while (src_iter != src.end() && dest_iter != dest->end()) {
     const RankedSet& ranked_call_sites = *src_iter;
     auto find_call_site_iter = ranked_call_sites.FindCallStack(call_site);
     if (find_call_site_iter != ranked_call_sites.end())
       dest_iter->count_for_call_stack = find_call_site_iter->count;
     ++src_iter;
     ++dest_iter;
   }
+
+  size_entries_[SizeToIndex(size)].stack_table->GetLastUptrendInfo(
+      call_site, timestamp, &(report->num_rising_intervals_),

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

Nit: don't need "&"

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

Oh, I meant don't need "()".

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

Done.

+      &(report->num_allocs_increase_));
 }
 
 bool LeakDetectorImpl::ReadyToGenerateReport(
     size_t size,
     const CallStack* call_stack) const {
   return cooldowns_per_leak_.find(std::make_pair(size, call_stack)) ==
          cooldowns_per_leak_.end();
 }
 
 void LeakDetectorImpl::ResetLeakCooldown(size_t size,
                                          const CallStack* call_stack) {
   cooldowns_per_leak_[std::make_pair(size, call_stack)] =
       kNumSizeEntriesInHistory;
 }
 
 void LeakDetectorImpl::UpdateLeakCooldowns() {
   for (auto iter = cooldowns_per_leak_.begin();
        iter != cooldowns_per_leak_.end();
        /* No iterating here */) {
     if (--iter->second > 0) {
       ++iter;
     } else {
       cooldowns_per_leak_.erase(iter++);
     }
   }
 }
 
 }  // namespace leak_detector
 }  // namespace metrics