Add cooldown to LeakDetectorImpl leak report generation

components/metrics/leak_detector/leak_detector_impl_unittest.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 "components/metrics/leak_detector/leak_detector_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <complex>
 #include <new>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/metrics/leak_detector/custom_allocator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace metrics {
 namespace leak_detector {
 
 namespace {
 
 // Makes working with complex numbers easier.
 using Complex = std::complex<double>;
 
+using InternalLeakReport = LeakDetectorImpl::LeakReport;
+using AllocationBreakdown = LeakDetectorImpl::LeakReport::AllocationBreakdown;
+
 // The mapping location in memory for a fictional executable.
 const uintptr_t kMappingAddr = 0x800000;
 const size_t kMappingSize = 0x200000;
 
 // Some call stacks within the fictional executable.
 // * - outside the mapping range, e.g. JIT code.
 const uintptr_t kRawStack0[] = {
     0x800100, 0x900000, 0x880080, 0x810000,
 };
 const uintptr_t kRawStack1[] = {
@@ skipping 36 matching lines @@
 
 // The interval between consecutive analyses (LeakDetectorImpl::TestForLeaks),
 // in number of bytes allocated. e.g. if |kAllocedSizeAnalysisInterval| = 1024
 // then call TestForLeaks() every 1024 bytes of allocation that occur.
 const size_t kAllocedSizeAnalysisInterval = 8192;
 
 // Suspicion thresholds used by LeakDetectorImpl for size and call stacks.
 const uint32_t kSizeSuspicionThreshold = 4;
 const uint32_t kCallStackSuspicionThreshold = 4;
 
+// Because it takes N+1 analyses to reach a suspicion threshold of N (the
+// suspicion score is only calculated based on deltas from the previous
+// analysis), the actual number of analyses it takes to generate a report for
+// the first time is:
+const uint32_t kMinNumAnalysesToGenerateReport =
+    kSizeSuspicionThreshold + 1 + kCallStackSuspicionThreshold + 1;
+
 // Returns the offset within [kMappingAddr, kMappingAddr + kMappingSize) if
 // |addr| falls in that range. Otherwise, returns |addr|.
 uintptr_t GetOffsetInMapping(uintptr_t addr) {
   if (addr >= kMappingAddr && addr < kMappingAddr + kMappingSize)
     return addr - kMappingAddr;
   return addr;
 }
 
 // Copied from leak_detector_impl.cc. Converts a size to a size class index.
 // Any size in the range [index * 4, index * 4 + 3] falls into that size class.
 uint32_t SizeToIndex(size_t size) {
   return size / sizeof(uint32_t);
 }
 
+// Returns true if the |alloc_breakdown_history_| field of the two LeakReports
+// |a| and |b| are the same.
+bool CompareReportAllocHistory(const InternalLeakReport& a,
+                               const InternalLeakReport& b) {
+  auto alloc_breakdown_compare_func = [](AllocationBreakdown a,
+                                         AllocationBreakdown b) -> bool {
+    return std::equal(a.counts_by_size.begin(), a.counts_by_size.end(),
+                      b.counts_by_size.begin()) &&
+           a.count_for_call_stack == b.count_for_call_stack;
+  };
+  return std::equal(
+      a.alloc_breakdown_history().begin(), a.alloc_breakdown_history().end(),
+      b.alloc_breakdown_history().begin(), alloc_breakdown_compare_func);
+}
+
 }  // namespace
 
 // This test suite will test the ability of LeakDetectorImpl to catch leaks in
 // a program. Individual tests can run leaky code locally.
 //
 // The leaky code must call Alloc() and Free() for heap memory management. It
 // should not call See comments on those
 // functions for more details.
 class LeakDetectorImplTest : public ::testing::Test {
  public:
   LeakDetectorImplTest()
       : total_num_allocs_(0),
         total_num_frees_(0),
         total_alloced_size_(0),
-        next_analysis_total_alloced_size_(kAllocedSizeAnalysisInterval) {}
+        next_analysis_total_alloced_size_(kAllocedSizeAnalysisInterval),
+        num_reports_generated_(0) {}
 
   void SetUp() override {
     CustomAllocator::Initialize();
 
     detector_.reset(new LeakDetectorImpl(kMappingAddr, kMappingSize,
                                          kSizeSuspicionThreshold,
                                          kCallStackSuspicionThreshold));
   }
 
   void TearDown() override {
     // Free any memory that was leaked by test cases. Do not use Free() because
     // that will try to modify |alloced_ptrs_|.
     for (void* ptr : alloced_ptrs_)
       delete[] reinterpret_cast<char*>(ptr);
     alloced_ptrs_.clear();
 
     // Must destroy all objects that use CustomAllocator before shutting down.
     detector_.reset();
     stored_reports_.clear();
 
     EXPECT_TRUE(CustomAllocator::Shutdown());
   }
 
  protected:
-  using InternalLeakReport = LeakDetectorImpl::LeakReport;
   template <typename T>
   using InternalVector = LeakDetectorImpl::InternalVector<T>;
-  using AllocationBreakdown = LeakDetectorImpl::LeakReport::AllocationBreakdown;
 
   // Alloc and free functions that allocate and free heap memory and
   // automatically pass alloc/free info to |detector_|. They emulate the
   // alloc/free hook functions that would call into LeakDetectorImpl in
   // real-life usage. They also keep track of individual allocations locally, so
   // any leaked memory could be cleaned up.
   //
   // |stack| is just a nominal call stack object to identify the call site. It
   // doesn't have to contain the stack trace of the actual call stack.
   void* Alloc(size_t size, const TestCallStack& stack) {
@@ skipping 15 matching lines @@
           stored_reports_.insert(report);
         } else {
           // InternalLeakReports are uniquely identified by |alloc_size_bytes_|
           // and |call_stack_|. See InternalLeakReport::operator<().
           // If a report with the same size and call stack already exists,
           // overwrite it with the new report, which has a newer history.
           stored_reports_.erase(iter);
           stored_reports_.insert(report);
         }
       }
+      num_reports_generated_ += reports.size();
 
       // Determine when the next leak analysis should occur.
       while (total_alloced_size_ >= next_analysis_total_alloced_size_)
         next_analysis_total_alloced_size_ += kAllocedSizeAnalysisInterval;
     }
     return ptr;
   }
 
   // See comment for Alloc().
   void Free(void* ptr) {
@@ skipping 32 matching lines @@
 
   // Stores all pointers to memory allocated by by Alloc() so we can manually
   // free the leaked pointers at the end. This also serves as redundant
   // bookkeepping: it stores all pointers that have been allocated but not yet
   // freed.
   std::set<void*> alloced_ptrs_;
 
   // Store leak reports here. Use a set so duplicate reports are not stored.
   std::set<InternalLeakReport> stored_reports_;
 
+  // Keeps track of the actual number of reports (duplicate or not) that were
+  // generated by |detector_|.
+  size_t num_reports_generated_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LeakDetectorImplTest);
 };
 
 void LeakDetectorImplTest::SimpleLeakyFunction(bool enable_leaks) {
   std::vector<uint32_t*> ptrs(7);
 
-  const int kNumOuterIterations = 20;
+  const int kNumOuterIterations = 32;
   for (int j = 0; j < kNumOuterIterations; ++j) {
     // The inner loop allocates 256 bytes. Run it 32 times so that 8192 bytes
     // (|kAllocedSizeAnalysisInterval|) are allocated for each iteration of the
     // outer loop.
     const int kNumInnerIterations = 32;
     static_assert(kNumInnerIterations * 256 == kAllocedSizeAnalysisInterval,
                   "Inner loop iterations do not allocate the correct number of "
                   "bytes.");
     for (int i = 0; i < kNumInnerIterations; ++i) {
       size_t alloc_size_at_beginning = total_alloced_size_;
@@ skipping 237 matching lines @@
   EXPECT_EQ(7U, total_num_frees_);
   EXPECT_EQ(0U, alloced_ptrs_.size());
 }
 
 TEST_F(LeakDetectorImplTest, SimpleLeakyFunctionNoLeak) {
   SimpleLeakyFunction(false /* enable_leaks */);
 
   // SimpleLeakyFunction() should have run cleanly without leaking.
   EXPECT_EQ(total_num_allocs_, total_num_frees_);
   EXPECT_EQ(0U, alloced_ptrs_.size());
-  ASSERT_EQ(0U, stored_reports_.size());
+  EXPECT_EQ(0U, num_reports_generated_);
+  EXPECT_EQ(0U, stored_reports_.size());
 }
 
 TEST_F(LeakDetectorImplTest, SimpleLeakyFunctionWithLeak) {
   SimpleLeakyFunction(true /* enable_leaks */);
 
   // SimpleLeakyFunction() should generated some leak reports.
   EXPECT_GT(total_num_allocs_, total_num_frees_);
   EXPECT_GT(alloced_ptrs_.size(), 0U);
+  EXPECT_EQ(2U, num_reports_generated_);
   ASSERT_EQ(2U, stored_reports_.size());
 
   // The reports should be stored in order of size.
 
   // |report1| comes from the call site marked with kStack1, with size=32.
   const InternalLeakReport& report1 = *stored_reports_.begin();
   EXPECT_EQ(32U, report1.alloc_size_bytes());
   ASSERT_EQ(kStack1.depth, report1.call_stack().size());
   for (size_t i = 0; i < kStack1.depth; ++i) {
     EXPECT_EQ(GetOffsetInMapping(kStack1.stack[i]),
@@ skipping 10 matching lines @@
   }
 
   // Check historical data recorded in the reports.
   // - Each inner loop iteration allocates a net of 1x 32 bytes and 1x 48 bytes.
   // - Each outer loop iteration allocates a net of 32x 32 bytes and 32x 48
   //   bytes.
   // - However, the leak analysis happens after the allocs but before the frees
   //   that come right after. So it should count the two extra allocs made at
   //   call sites |kStack3| and |kStack4|. The formula is |(i + 1) * 32 + 2|,
   //   where |i| is the iteration index.
-  // There should have been one leak analysis per outer loop iteration, for a
-  // total of 20 history records (|kNumOuterIterations|) per report.
+  // - It takes |kMinNumAnalysesToGenerateReport| analyses for the first report
+  //   to be generated. Subsequent analyises do not generate reports due to the
+  //   cooldown mechanism.
 
   const auto& report1_history = report1.alloc_breakdown_history();
-  EXPECT_EQ(20U, report1_history.size());
+  EXPECT_EQ(kMinNumAnalysesToGenerateReport, report1_history.size());
 
   for (size_t i = 0; i < report1_history.size(); ++i) {
     const AllocationBreakdown& entry = report1_history[i];
 
     const InternalVector<uint32_t>& counts_by_size = entry.counts_by_size;
     ASSERT_GT(counts_by_size.size(), SizeToIndex(48));
 
     // Check the two leaky sizes, 32 and 48.
     uint32_t expected_leaky_count = (i + 1) * 32 + 2;
     EXPECT_EQ(expected_leaky_count, counts_by_size[SizeToIndex(32)]);
@@ skipping 15 matching lines @@
   // increase by 32 each frame. See comments above.
   uint32_t expected_call_stack_count = 0;
   for (size_t i = kSizeSuspicionThreshold; i < report1_history.size(); ++i) {
     EXPECT_EQ(expected_call_stack_count,
               report1_history[i].count_for_call_stack);
     expected_call_stack_count += 32;
   }
 
   // |report2| should have the same size history and call stack history as
   // |report1|.
-  const auto& report2_history = report2.alloc_breakdown_history();
-  auto compare_history_func =
-      [](AllocationBreakdown a, AllocationBreakdown b) -> bool {
-        return std::equal(a.counts_by_size.begin(), a.counts_by_size.end(),
-                          b.counts_by_size.begin()) &&
-               a.count_for_call_stack == b.count_for_call_stack;
-      };
-  EXPECT_TRUE(std::equal(report1_history.begin(), report1_history.end(),
-                         report2_history.begin(), compare_history_func));
+  EXPECT_TRUE(CompareReportAllocHistory(report1, report2));
+}
+
+TEST_F(LeakDetectorImplTest, SimpleLeakyFunctionWithLeakThreeTimes) {
+  // Run three iterations of the leaky function.
+  SimpleLeakyFunction(true /* enable_leaks */);
+  SimpleLeakyFunction(true /* enable_leaks */);
+  SimpleLeakyFunction(true /* enable_leaks */);
+
+  // SimpleLeakyFunction() should have generated three times as many leak
+  // reports, because the number of iterations is the same as the cooldown of
+  // LeakDetectorImpl. But the number of unique reports stored is still two.
+  EXPECT_EQ(6U, num_reports_generated_);
+  ASSERT_EQ(2U, stored_reports_.size());
+
+  // The reports should be stored in order of size.
+
+  // |report1| comes from the call site marked with kStack1, with size=32.
+  const InternalLeakReport& report1 = *stored_reports_.begin();
+  EXPECT_EQ(32U, report1.alloc_size_bytes());
+  ASSERT_EQ(kStack1.depth, report1.call_stack().size());
+  for (size_t i = 0; i < kStack1.depth; ++i) {
+    EXPECT_EQ(GetOffsetInMapping(kStack1.stack[i]), report1.call_stack()[i])
+        << i;
+  }
+
+  // |report2| comes from the call site marked with kStack2, with size=48.
+  const InternalLeakReport& report2 = *(++stored_reports_.begin());
+  EXPECT_EQ(48U, report2.alloc_size_bytes());
+  ASSERT_EQ(kStack2.depth, report2.call_stack().size());
+  for (size_t i = 0; i < kStack2.depth; ++i) {
+    EXPECT_EQ(GetOffsetInMapping(kStack2.stack[i]), report2.call_stack()[i])
+        << i;
+  }
+
+  const auto& report1_history = report1.alloc_breakdown_history();
+  EXPECT_EQ(32U, report1_history.size());
+
+  for (size_t i = 1; i < report1_history.size(); ++i) {
+    const InternalVector<uint32_t>& counts_by_size =
+        report1_history[i].counts_by_size;
+    const InternalVector<uint32_t>& prev_counts_by_size =
+        report1_history[i - 1].counts_by_size;
+    ASSERT_GT(counts_by_size.size(), SizeToIndex(48));
+
+    // Check the two leaky sizes, 32 and 48. At this point, the exact counts
+    // could be computed but the computations are too complex for a unit test.
+    // Instead, check that the counts increase by 32 from the previous count.
+    // Same goes for checking call site counts later.
+    EXPECT_GT(counts_by_size[SizeToIndex(32)], 0U);
+    EXPECT_GT(counts_by_size[SizeToIndex(48)], 0U);
+    EXPECT_EQ(prev_counts_by_size[SizeToIndex(32)] + 32,
+              counts_by_size[SizeToIndex(32)]);
+    EXPECT_EQ(prev_counts_by_size[SizeToIndex(48)] + 32,
+              counts_by_size[SizeToIndex(48)]);
+
+    // Not related to the leaks, but there should be a dangling 16-byte
+    // allocation during each leak analysis, because it hasn't yet been freed.
+    EXPECT_EQ(1U, counts_by_size[SizeToIndex(16)]);
+  }
+
+  // Check call site count over time.
+  ASSERT_LT(kSizeSuspicionThreshold, report1_history.size());
+  // Sufficient time has passed since the first report was generated. The entire
+  // alloc history should contain call site counts.
+  for (size_t i = 1; i < report1_history.size(); ++i) {
+    EXPECT_GT(report1_history[i].count_for_call_stack, 0U);
+    EXPECT_EQ(report1_history[i - 1].count_for_call_stack + 32,
+              report1_history[i].count_for_call_stack);
+  }
+
+  // |report2| should have the same size history and call stack history as
+  // |report1|.
+  EXPECT_TRUE(CompareReportAllocHistory(report1, report2));
 }
 
 TEST_F(LeakDetectorImplTest, JuliaSetNoLeak) {
   JuliaSet(false /* enable_leaks */);
 
   // JuliaSet() should have run cleanly without leaking.
   EXPECT_EQ(total_num_allocs_, total_num_frees_);
   EXPECT_EQ(0U, alloced_ptrs_.size());
+  EXPECT_EQ(0U, num_reports_generated_);
   ASSERT_EQ(0U, stored_reports_.size());
 }
 
 TEST_F(LeakDetectorImplTest, JuliaSetWithLeak) {
   JuliaSet(true /* enable_leaks */);
 
   // JuliaSet() should have leaked some memory from two call sites.
   EXPECT_GT(total_num_allocs_, total_num_frees_);
   EXPECT_GT(alloced_ptrs_.size(), 0U);
+  EXPECT_GT(num_reports_generated_, 0U);
 
   // There should be one unique leak report generated for each leaky call site.
   ASSERT_EQ(2U, stored_reports_.size());
 
   // The reports should be stored in order of size.
 
   // |report1| comes from the call site in JuliaSet() corresponding to
   // |kStack3|.
   const InternalLeakReport& report1 = *stored_reports_.begin();
   EXPECT_EQ(sizeof(Complex) + 40, report1.alloc_size_bytes());
@@ skipping 28 matching lines @@
   uint32_t size_0_index = SizeToIndex(sizeof(Complex) + 24);
   uint32_t size_1_index = SizeToIndex(sizeof(Complex) + 40);
   uint32_t size_2_index = SizeToIndex(sizeof(Complex) + 52);
   ASSERT_LT(size_0_index, counts_by_size.size());
   ASSERT_LT(size_1_index, counts_by_size.size());
   ASSERT_LT(size_2_index, counts_by_size.size());
 
   EXPECT_GT(counts_by_size[size_1_index], counts_by_size[size_0_index] * 10);
   EXPECT_GT(counts_by_size[size_2_index], counts_by_size[size_0_index] * 10);
 
-  // |report2| should have the same size history as |report1|, but not the same
-  // call stack history.
-  const auto& report2_history = report2.alloc_breakdown_history();
-  auto compare_size_history_func =
-      [](AllocationBreakdown a, AllocationBreakdown b) -> bool {
-        return std::equal(a.counts_by_size.begin(), a.counts_by_size.end(),
-                          b.counts_by_size.begin());
-      };
-  EXPECT_TRUE(std::equal(report1_history.begin(), report1_history.end(),
-                         report2_history.begin(), compare_size_history_func));
+  // |report1| and |report2| do not necessarily have the same allocation history
+  // due to the different rates at which they were generated.

[Simon Que, 2016/04/21 00:33:08]

I forgot to remove this in the previous patch set. This is no longer applicable
now that we have a cooldown.

 }
 
 }  // namespace leak_detector
 }  // namespace metrics