[oilpan] Add heap stats collection mechanism

This CL introduces HeapTracer which a single concept to track interesting
garbage collection numbers across garbage collections.

This allows for unit testing measurements and unifying the histogram
logic into a single place.

Bug: chromium:840789
Change-Id: Ie36d6f9cc973f0dec28a3305b2d0def59bafe135
Reviewed-on: https://chromium-review.googlesource.com/1046647
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Keishi Hattori <keishi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556885}

third_party/blink/renderer/platform/heap/BUILD.gn

@@ -51,6 +51,8 @@ blink_platform_sources("heap") {
     "heap_linked_stack.h",
     "heap_page.cc",
     "heap_page.h",
+    "heap_stats_collector.cc",
+    "heap_stats_collector.h",
     "heap_terminated_array.h",
     "heap_terminated_array_builder.h",
     "heap_traits.h",
@@ -111,6 +113,7 @@ jumbo_source_set("blink_heap_unittests_sources") {
     "address_cache_test.cc",
     "blink_gc_memory_dump_provider_test.cc",
     "heap_compact_test.cc",
+    "heap_stats_collector_test.cc",
     "heap_test.cc",
     "heap_test_utilities.cc",
     "heap_test_utilities.h",

third_party/blink/renderer/platform/heap/blink_gc.h

@@ -97,14 +97,15 @@ class PLATFORM_EXPORT BlinkGC final {
   };
 
   enum GCReason {
-    kIdleGC,
-    kPreciseGC,
-    kConservativeGC,
-    kForcedGC,
-    kMemoryPressureGC,
-    kPageNavigationGC,
-    kThreadTerminationGC,
-    kLastGCReason = kThreadTerminationGC,
+    kIdleGC = 0,
+    kPreciseGC = 1,
+    kConservativeGC = 2,
+    kForcedGC = 3,
+    kMemoryPressureGC = 4,
+    kPageNavigationGC = 5,
+    kThreadTerminationGC = 6,
+    kTesting = 7,
+    kLastGCReason = kTesting,
   };
 
   enum ArenaIndices {

third_party/blink/renderer/platform/heap/heap.cc

@@ -40,6 +40,7 @@
 #include "third_party/blink/renderer/platform/heap/address_cache.h"
 #include "third_party/blink/renderer/platform/heap/blink_gc_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/heap/heap_compact.h"
+#include "third_party/blink/renderer/platform/heap/heap_stats_collector.h"
 #include "third_party/blink/renderer/platform/heap/marking_visitor.h"
 #include "third_party/blink/renderer/platform/heap/page_memory.h"
 #include "third_party/blink/renderer/platform/heap/page_pool.h"
@@ -128,6 +129,7 @@ double ThreadHeapStats::LiveObjectRateSinceLastGC() const {
 
 ThreadHeap::ThreadHeap(ThreadState* thread_state)
     : thread_state_(thread_state),
+      heap_stats_collector_(std::make_unique<ThreadHeapStatsCollector>()),
       region_tree_(std::make_unique<RegionTree>()),
       address_cache_(std::make_unique<AddressCache>()),
       free_page_pool_(std::make_unique<PagePool>()),

third_party/blink/renderer/platform/heap/heap.h

@@ -56,6 +56,7 @@ class IncrementalMarkingScopeBase;
 }  // namespace incremental_marking_test
 
 class AddressCache;
+class ThreadHeapStatsCollector;
 class PagePool;
 class RegionTree;
 
@@ -463,6 +464,10 @@ class PLATFORM_EXPORT ThreadHeap {
   enum SnapshotType { kHeapSnapshot, kFreelistSnapshot };
   void TakeSnapshot(SnapshotType);
 
+  ThreadHeapStatsCollector* stats_collector() const {
+    return heap_stats_collector_.get();
+  }
+
 #if defined(ADDRESS_SANITIZER)
   void PoisonEagerArena();
   void PoisonAllHeaps();
@@ -496,6 +501,7 @@ class PLATFORM_EXPORT ThreadHeap {
 
   ThreadState* thread_state_;
   ThreadHeapStats stats_;
+  std::unique_ptr<ThreadHeapStatsCollector> heap_stats_collector_;
   std::unique_ptr<RegionTree> region_tree_;
   std::unique_ptr<AddressCache> address_cache_;
   std::unique_ptr<PagePool> free_page_pool_;

third_party/blink/renderer/platform/heap/heap_page.cc

@@ -36,6 +36,7 @@
 #include "third_party/blink/renderer/platform/heap/address_cache.h"
 #include "third_party/blink/renderer/platform/heap/blink_gc_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/heap/heap_compact.h"
+#include "third_party/blink/renderer/platform/heap/heap_stats_collector.h"
 #include "third_party/blink/renderer/platform/heap/marking_verifier.h"
 #include "third_party/blink/renderer/platform/heap/page_memory.h"
 #include "third_party/blink/renderer/platform/heap/page_pool.h"
@@ -265,16 +266,16 @@ Address BaseArena::LazySweep(size_t allocation_size, size_t gc_info_index) {
   if (GetThreadState()->SweepForbidden())
     return nullptr;
 
-  TRACE_EVENT0("blink_gc", "BaseArena::lazySweepPages");
-  ThreadState::SweepForbiddenScope sweep_forbidden(GetThreadState());
-  ScriptForbiddenScope script_forbidden;
-
-  double start_time = WTF::CurrentTimeTicksInMilliseconds();
-  Address result = LazySweepPages(allocation_size, gc_info_index);
-  GetThreadState()->AccumulateSweepingTime(
-      WTF::CurrentTimeTicksInMilliseconds() - start_time);
+  Address result = nullptr;
+  {
+    ThreadHeapStatsCollector::Scope stats_scope(
+        GetThreadState()->Heap().stats_collector(),
+        ThreadHeapStatsCollector::Scope::kLazySweepOnAllocation);
+    ThreadState::SweepForbiddenScope sweep_forbidden(GetThreadState());
+    ScriptForbiddenScope script_forbidden;
+    result = LazySweepPages(allocation_size, gc_info_index);
+  }
   ThreadHeap::ReportMemoryUsageForTracing();
-
   return result;
 }
 

third_party/blink/renderer/platform/heap/heap_stats_collector.cc

+// Copyright 2018 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 "third_party/blink/renderer/platform/heap/heap_stats_collector.h"
+
+#include "base/logging.h"
+#include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
+#include "third_party/blink/renderer/platform/wtf/time.h"
+
+namespace blink {
+
+ThreadHeapStatsCollector::Scope::Scope(ThreadHeapStatsCollector* tracer,
+                                       ThreadHeapStatsCollector::Scope::Id id)
+    : tracer_(tracer),
+      start_time_(WTF::CurrentTimeTicksInMilliseconds()),
+      id_(id) {
+  TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("blink_gc"),
+                     ThreadHeapStatsCollector::Scope::ToString(id_));
+}
+
+ThreadHeapStatsCollector::Scope::~Scope() {
+  TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("blink_gc"),
+                   ThreadHeapStatsCollector::Scope::ToString(id_));
+  tracer_->IncreaseScopeTime(
+      id_, WTF::CurrentTimeTicksInMilliseconds() - start_time_);
+}
+
+const char* ThreadHeapStatsCollector::Scope::ToString(
+    ThreadHeapStatsCollector::Scope::Id id) {
+  switch (id) {
+    case Scope::kCompleteSweep:
+      return "BlinkGC.CompleteSweep";
+    case Scope::kEagerSweep:
+      return "BlinkGC.EagerSweep";
+    case Scope::kIncrementalMarkingStartMarking:
+      return "BlinkGC.IncrementalMarkingStartMarking";
+    case Scope::kIncrementalMarkingStep:
+      return "BlinkGC.IncrementalMarkingStep";
+    case Scope::kIncrementalMarkingFinalize:
+      return "BlinkGC.IncrementalMarkingFinalize";
+    case Scope::kIncrementalMarkingFinalizeMarking:
+      return "BlinkGC.IncrementalMarkingFinalizeMarking";
+    case Scope::kLazySweepInIdle:
+      return "BlinkGC.LazySweepInIdle";
+    case Scope::kLazySweepOnAllocation:
+      return "BlinkGC.LazySweepOnAllocation";
+    case Scope::kFullGCMarking:
+      return "BlinkGC.FullGCMarking";
+    case Scope::kNumIds:
+      break;
+  }
+  CHECK(false);
+  return nullptr;
+}
+
+void ThreadHeapStatsCollector::IncreaseScopeTime(
+    ThreadHeapStatsCollector::Scope::Id id,
+    double time) {
+  DCHECK(is_started_);
+  current_.scope_data[id] += time;
+}
+
+void ThreadHeapStatsCollector::IncreaseMarkedObjectSize(size_t size) {
+  DCHECK(is_started_);
+  current_.marked_object_size += size;
+}
+
+void ThreadHeapStatsCollector::Start(BlinkGC::GCReason reason) {
+  DCHECK(!is_started_);
+  is_started_ = true;
+  current_.reason = reason;
+}
+
+void ThreadHeapStatsCollector::Stop() {
+  is_started_ = false;
+  previous_ = std::move(current_);
+  current_.reset();
+}
+
+void ThreadHeapStatsCollector::Event::reset() {
+  marked_object_size = 0;
+  memset(scope_data, 0, sizeof(scope_data));
+  reason = BlinkGC::kTesting;
+}
+
+double ThreadHeapStatsCollector::Event::marking_time_in_ms() const {
+  return scope_data[Scope::kIncrementalMarkingStartMarking] +
+         scope_data[Scope::kIncrementalMarkingStep] +
+         scope_data[Scope::kIncrementalMarkingFinalizeMarking] +
+         scope_data[Scope::kFullGCMarking];
+}
+
+double ThreadHeapStatsCollector::Event::marking_time_per_byte_in_s() const {
+  return marked_object_size ? marking_time_in_ms() / 1000 / marked_object_size
+                            : 0.0;
+}
+
+double ThreadHeapStatsCollector::Event::sweeping_time_in_ms() const {
+  return scope_data[Scope::kCompleteSweep] + scope_data[Scope::kEagerSweep] +
+         scope_data[Scope::kLazySweepInIdle] +
+         scope_data[Scope::kLazySweepOnAllocation];
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/heap/heap_stats_collector.h

+// Copyright 2018 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 THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_STATS_COLLECTOR_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_STATS_COLLECTOR_H_
+
+#include <stddef.h>
+
+#include "third_party/blink/renderer/platform/heap/blink_gc.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+
+namespace blink {
+
+// Manages counters and statistics across garbage collection cycles.
+//
+// Usage:
+//   ThreadHeapStatsCollector stats_collector;
+//   stats_collector.Start(<BlinkGC::GCReason>);
+//   // Use tracer.
+//   // Current event is available using stats_collector.current().
+//   stats_collector.Stop();
+//   // Previous event is available using stats_collector.previous().
+class PLATFORM_EXPORT ThreadHeapStatsCollector {
+ public:
+  // Trace a particular scope. Will emit a trace event and record the time in
+  // the corresponding ThreadHeapStatsCollector.
+  class PLATFORM_EXPORT Scope {
+   public:
+    // These ids will form human readable names when used in Scopes.
+    enum Id {
+      kCompleteSweep,
+      kEagerSweep,
+      kIncrementalMarkingStartMarking,
+      kIncrementalMarkingStep,
+      kIncrementalMarkingFinalize,
+      kIncrementalMarkingFinalizeMarking,
+      kLazySweepInIdle,
+      kLazySweepOnAllocation,
+      kFullGCMarking,
+      kNumIds,
+    };
+
+    static const char* ToString(Id);
+
+    Scope(ThreadHeapStatsCollector*, Id);
+    ~Scope();
+
+   private:
+    ThreadHeapStatsCollector* const tracer_;
+    const double start_time_;
+    const Id id_;
+  };
+
+  struct PLATFORM_EXPORT Event {
+    void reset();
+
+    double marking_time_in_ms() const;
+    double marking_time_per_byte_in_s() const;
+    double sweeping_time_in_ms() const;
+
+    size_t marked_object_size = 0;
+    double scope_data[Scope::kNumIds] = {0};
+    BlinkGC::GCReason reason;
+  };
+
+  void Start(BlinkGC::GCReason);
+  void Stop();
+
+  void IncreaseScopeTime(Scope::Id, double);
+  void IncreaseMarkedObjectSize(size_t);
+
+  bool is_started() const { return is_started_; }
+  const Event& current() const { return current_; }
+  const Event& previous() const { return previous_; }
+
+ private:
+  Event current_;
+  Event previous_;
+  bool is_started_ = false;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_STATS_COLLECTOR_H_

third_party/blink/renderer/platform/heap/heap_stats_collector_test.cc

+// Copyright 2018 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 "third_party/blink/renderer/platform/heap/heap_stats_collector.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blink {
+
+// =============================================================================
+// ThreadHeapStatsCollector. ===================================================
+// =============================================================================
+
+TEST(ThreadHeapStatsCollectorTest, InitialEmpty) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  for (int i = 0; i < ThreadHeapStatsCollector::Scope::Id::kNumIds; i++) {
+    EXPECT_DOUBLE_EQ(0.0, stats_collector.current().scope_data[i]);
+  }
+  stats_collector.Stop();
+}
+
+TEST(ThreadHeapStatsCollectorTest, IncreaseScopeTime) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep, 1.0);
+  EXPECT_DOUBLE_EQ(
+      1.0, stats_collector.current().scope_data
+               [ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep]);
+}
+
+TEST(ThreadHeapStatsCollectorTest, StopMovesCurrentToPrevious) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep, 1.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(
+      1.0, stats_collector.previous().scope_data
+               [ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep]);
+}
+
+TEST(ThreadHeapStatsCollectorTest, StopResetsCurrent) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep, 1.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(
+      0.0, stats_collector.current().scope_data
+               [ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep]);
+}
+
+TEST(ThreadHeapStatsCollectorTest, StartStop) {
+  ThreadHeapStatsCollector stats_collector;
+  EXPECT_FALSE(stats_collector.is_started());
+  stats_collector.Start(BlinkGC::kTesting);
+  EXPECT_TRUE(stats_collector.is_started());
+  stats_collector.Stop();
+  EXPECT_FALSE(stats_collector.is_started());
+}
+
+// =============================================================================
+// ThreadHeapStatsCollector::Scope. ============================================
+// =============================================================================
+
+TEST(ThreadHeapStatsCollectorTest, ScopeToString) {
+  EXPECT_STREQ(
+      "BlinkGC.IncrementalMarkingStartMarking",
+      ThreadHeapStatsCollector::Scope::ToString(
+          ThreadHeapStatsCollector::Scope::kIncrementalMarkingStartMarking));
+}
+
+// =============================================================================
+// ThreadHeapStatsCollector::Event. ============================================
+// =============================================================================
+
+TEST(ThreadHeapStatsCollectorTest, EventMarkedObjectSize) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseMarkedObjectSize(1024);
+  stats_collector.Stop();
+  EXPECT_EQ(1024u, stats_collector.previous().marked_object_size);
+}
+
+TEST(ThreadHeapStatsCollectorTest, EventMarkingTimeInMsFromIncrementalGC) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingStartMarking, 7.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingStep, 2.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingFinalizeMarking, 1.0);
+  // Ignore the full finalization.
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kIncrementalMarkingFinalize, 3.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(10.0, stats_collector.previous().marking_time_in_ms());
+}
+
+TEST(ThreadHeapStatsCollectorTest, EventMarkingTimeInMsFromFullGC) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kFullGCMarking, 11.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(11.0, stats_collector.previous().marking_time_in_ms());
+}
+
+TEST(ThreadHeapStatsCollectorTest, EventMarkingTimePerByteInS) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseMarkedObjectSize(1000);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kFullGCMarking, 1000.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(.001,
+                   stats_collector.previous().marking_time_per_byte_in_s());
+}
+
+TEST(ThreadHeapStatsCollectorTest, SweepingTimeInMs) {
+  ThreadHeapStatsCollector stats_collector;
+  stats_collector.Start(BlinkGC::kTesting);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kLazySweepInIdle, 1.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kLazySweepInIdle, 2.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kLazySweepInIdle, 3.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kLazySweepOnAllocation, 4.0);
+  stats_collector.IncreaseScopeTime(
+      ThreadHeapStatsCollector::Scope::kCompleteSweep, 5.0);
+  stats_collector.Stop();
+  EXPECT_DOUBLE_EQ(15.0, stats_collector.previous().sweeping_time_in_ms());
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/heap/heap_test.cc

@@ -42,6 +42,7 @@
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
 #include "third_party/blink/renderer/platform/heap/heap_linked_stack.h"
+#include "third_party/blink/renderer/platform/heap/heap_stats_collector.h"
 #include "third_party/blink/renderer/platform/heap/heap_terminated_array_builder.h"
 #include "third_party/blink/renderer/platform/heap/heap_test_utilities.h"
 #include "third_party/blink/renderer/platform/heap/marking_visitor.h"
@@ -365,6 +366,7 @@ class TestGCMarkingScope : public TestGCCollectGarbageScope {
       : TestGCCollectGarbageScope(state),
         atomic_pause_scope_(ThreadState::Current()),
         persistent_lock_(ProcessHeap::CrossThreadPersistentMutex()) {
+    ThreadState::Current()->Heap().stats_collector()->Start(BlinkGC::kTesting);
     ThreadState::Current()->MarkPhasePrologue(state, BlinkGC::kAtomicMarking,
                                               BlinkGC::kPreciseGC);
   }

third_party/blink/renderer/platform/heap/thread_state.h

@@ -530,10 +530,6 @@ class PLATFORM_EXPORT ThreadState {
     }
   }
 
-  void AccumulateSweepingTime(double time) {
-    accumulated_sweeping_time_ += time;
-  }
-
   void FreePersistentNode(PersistentRegion*, PersistentNode*);
 
   using PersistentClearCallback = void (*)(void*);
@@ -700,7 +696,6 @@ class PLATFORM_EXPORT ThreadState {
   size_t no_allocation_count_;
   size_t gc_forbidden_count_;
   size_t mixins_being_constructed_count_;
-  double accumulated_sweeping_time_;
   bool object_resurrection_forbidden_;
   bool in_atomic_pause_;