cppgc: Add UMA support

This CL introduces cppgc::HistogramRecorder api which is similar to the
v8::metrics::Recorder api and is used by cppgc to report histogram
samples to embedders. Embedders should implement the api if they want to
collect histograms and provide an instance of it on heap creation.

CppHeap uses an adaptor class that implements the HistogramRecorder api
and is used to forward the relevant info to the relevant
v8::metrics::Recorder.

The api used 3 data structures: 2 for incremental steps that need to be
reported as they come (marking and sweeping) and 1 for the end of a GC
cycle that aggregates statistics over the entire cycle.
The data structure only provide the "raw" samples (e.g. atomic mark
time, incremental mark time, etc...). The embedder is expected to
compute aggregate histogram on its own (e.g. overall marking time).

Bug: chromium:1056170
Change-Id: If63ef50a29a21594f654edb83084598980d221ce
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2642258
Commit-Queue: Omer Katz <[email protected]>
Reviewed-by: Michael Lippautz <[email protected]>
Reviewed-by: Ulan Degenbaev <[email protected]>
Cr-Commit-Position: refs/heads/master@{#72256}

Author: omerktz

BUILD.gn

@@ -4646,6 +4646,7 @@ v8_source_set("cppgc_base") {
     "src/heap/cppgc/marking-visitor.h",
     "src/heap/cppgc/marking-worklists.cc",
     "src/heap/cppgc/marking-worklists.h",
+    "src/heap/cppgc/metric-recorder.h",
     "src/heap/cppgc/name-trait.cc",
     "src/heap/cppgc/object-allocator.cc",
     "src/heap/cppgc/object-allocator.h",

src/heap/cppgc-js/cpp-heap.cc

@@ -169,11 +169,13 @@ void UnifiedHeapMarker::AddObject(void* object) {
 
 CppHeap::CppHeap(
     v8::Isolate* isolate,
-    const std::vector<std::unique_ptr<cppgc::CustomSpaceBase>>& custom_spaces)
+    const std::vector<std::unique_ptr<cppgc::CustomSpaceBase>>& custom_spaces,
+    std::unique_ptr<cppgc::internal::MetricRecorder> metric_recorder)
     : cppgc::internal::HeapBase(std::make_shared<CppgcPlatformAdapter>(isolate),
                                 custom_spaces,
                                 cppgc::internal::HeapBase::StackSupport::
-                                    kSupportsConservativeStackScan),
+                                    kSupportsConservativeStackScan,
+                                std::move(metric_recorder)),
       isolate_(*reinterpret_cast<Isolate*>(isolate)) {
   if (isolate_.heap_profiler()) {
     isolate_.heap_profiler()->AddBuildEmbedderGraphCallback(

src/heap/cppgc-js/cpp-heap.h

@@ -28,9 +28,11 @@ class V8_EXPORT_PRIVATE CppHeap final : public cppgc::internal::HeapBase,
     return static_cast<const CppHeap*>(heap);
   }
 
-  CppHeap(v8::Isolate* isolate,
-          const std::vector<std::unique_ptr<cppgc::CustomSpaceBase>>&
-              custom_spaces);
+  CppHeap(
+      v8::Isolate* isolate,
+      const std::vector<std::unique_ptr<cppgc::CustomSpaceBase>>& custom_spaces,
+      std::unique_ptr<cppgc::internal::MetricRecorder> metric_recorder =
+          nullptr);
   ~CppHeap() final;
 
   CppHeap(const CppHeap&) = delete;
@@ -56,8 +58,6 @@ class V8_EXPORT_PRIVATE CppHeap final : public cppgc::internal::HeapBase,
     // finalization is not needed) thus this method is left empty.
   }
 
-  void PostGarbageCollection() final {}
-
   Isolate& isolate_;
   bool marking_done_ = false;
   bool is_in_final_pause_ = false;

src/heap/cppgc/heap-base.cc

@@ -56,7 +56,8 @@ class ObjectSizeCounter : private HeapVisitor<ObjectSizeCounter> {
 HeapBase::HeapBase(
     std::shared_ptr<cppgc::Platform> platform,
     const std::vector<std::unique_ptr<CustomSpaceBase>>& custom_spaces,
-    StackSupport stack_support)
+    StackSupport stack_support,
+    std::unique_ptr<MetricRecorder> histogram_recorder)
     : raw_heap_(this, custom_spaces),
       platform_(std::move(platform)),
 #if defined(CPPGC_CAGED_HEAP)
@@ -66,7 +67,8 @@ HeapBase::HeapBase(
       page_backend_(
           std::make_unique<PageBackend>(platform_->GetPageAllocator())),
 #endif
-      stats_collector_(std::make_unique<StatsCollector>()),
+      stats_collector_(
+          std::make_unique<StatsCollector>(std::move(histogram_recorder))),
       stack_(std::make_unique<heap::base::Stack>(
           v8::base::Stack::GetStackStart())),
       prefinalizer_handler_(std::make_unique<PreFinalizerHandler>(*this)),

src/heap/cppgc/heap-base.h

@@ -14,6 +14,7 @@
 #include "src/base/macros.h"
 #include "src/heap/cppgc/compactor.h"
 #include "src/heap/cppgc/marker.h"
+#include "src/heap/cppgc/metric-recorder.h"
 #include "src/heap/cppgc/object-allocator.h"
 #include "src/heap/cppgc/raw-heap.h"
 #include "src/heap/cppgc/sweeper.h"
@@ -79,7 +80,8 @@ class V8_EXPORT_PRIVATE HeapBase : public cppgc::HeapHandle {
 
   HeapBase(std::shared_ptr<cppgc::Platform> platform,
            const std::vector<std::unique_ptr<CustomSpaceBase>>& custom_spaces,
-           StackSupport stack_support);
+           StackSupport stack_support,
+           std::unique_ptr<MetricRecorder> histogram_recorder);
   virtual ~HeapBase();
 
   HeapBase(const HeapBase&) = delete;
@@ -153,9 +155,6 @@ class V8_EXPORT_PRIVATE HeapBase : public cppgc::HeapHandle {
 
   void AdvanceIncrementalGarbageCollectionOnAllocationIfNeeded();
 
-  // Notifies the heap that a GC is done.
-  virtual void PostGarbageCollection() = 0;
-
   // Termination drops all roots (clears them out) and runs garbage collections
   // in a bounded fixed point loop  until no new objects are created in
   // destructors. Exceeding the loop bound results in a crash.

src/heap/cppgc/heap.cc

@@ -86,7 +86,8 @@ void CheckConfig(Heap::Config config, Heap::MarkingType marking_support,
 
 Heap::Heap(std::shared_ptr<cppgc::Platform> platform,
            cppgc::Heap::HeapOptions options)
-    : HeapBase(platform, options.custom_spaces, options.stack_support),
+    : HeapBase(platform, options.custom_spaces, options.stack_support,
+               nullptr /* metric_recorder */),
       gc_invoker_(this, platform_.get(), options.stack_support),
       growing_(&gc_invoker_, stats_collector_.get(),
                options.resource_constraints, options.marking_support,
@@ -196,8 +197,6 @@ void Heap::FinalizeGarbageCollection(Config::StackState stack_state) {
   sweeper_.NotifyDoneIfNeeded();
 }
 
-void Heap::PostGarbageCollection() {}
-
 void Heap::DisableHeapGrowingForTesting() { growing_.DisableForTesting(); }
 
 void Heap::FinalizeIncrementalGarbageCollectionIfNeeded(

src/heap/cppgc/heap.h

@@ -46,8 +46,6 @@ class V8_EXPORT_PRIVATE Heap final : public HeapBase,
 
   void FinalizeIncrementalGarbageCollectionIfNeeded(Config::StackState) final;
 
-  void PostGarbageCollection() final;
-
   Config config_;
   GCInvoker gc_invoker_;
   HeapGrowing growing_;

src/heap/cppgc/marker.cc

@@ -287,8 +287,8 @@ void MarkerBase::FinishMarking(MarkingConfig::StackState stack_state) {
 void MarkerBase::ProcessWeakness() {
   DCHECK_EQ(MarkingConfig::MarkingType::kAtomic, config_.marking_type);
 
-  StatsCollector::DisabledScope stats_scope(
-      heap(), StatsCollector::kWeakInvokeCallbacks);
+  StatsCollector::DisabledScope stats_scope(heap(),
+                                            StatsCollector::kAtomicWeak);
 
   heap().GetWeakPersistentRegion().Trace(&visitor());
   // Processing cross-thread handles requires taking the process lock.

src/heap/cppgc/metric-recorder.h

@@ -0,0 +1,54 @@
+// Copyright 2021 the V8 project 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 V8_HEAP_CPPGC_METRIC_RECORDER_H_
+#define V8_HEAP_CPPGC_METRIC_RECORDER_H_
+
+#include <cstdint>
+
+namespace cppgc {
+namespace internal {
+
+class StatsCollector;
+
+/**
+ * Base class used for reporting GC statistics histograms. Embedders interested
+ * in collecting histgorams should implement the virtual AddMainThreadEvent
+ * methods below and pass an instance of the implementation during Heap
+ * creation.
+ */
+class MetricRecorder {
+ public:
+  struct CppGCCycleEndMetricSamples {
+    int64_t atomic_mark_ms;
+    int64_t atomic_weak_ms;
+    int64_t atomic_compact_ms;
+    int64_t atomic_sweep_ms;
+    int64_t incremental_mark_ms;
+    int64_t incremental_sweep_ms;
+    int64_t concurrent_mark_ms;
+    int64_t concurrent_sweep_ms;
+  };
+
+  struct CppGCIncrementalMarkMetricSample {
+    int64_t duration_ms;
+  };
+
+  struct CppGCIncrementalSweepMetricSample {
+    int64_t duration_ms;
+  };
+
+  virtual ~MetricRecorder() = default;
+
+  virtual void AddMainThreadEvent(const CppGCCycleEndMetricSamples& event) {}
+  virtual void AddMainThreadEvent(
+      const CppGCIncrementalMarkMetricSample& event) {}
+  virtual void AddMainThreadEvent(
+      const CppGCIncrementalSweepMetricSample& event) {}
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // V8_HEAP_CPPGC_METRIC_RECORDER_H_

src/heap/cppgc/stats-collector.cc

@@ -8,13 +8,18 @@
 #include <cmath>
 
 #include "src/base/logging.h"
+#include "src/heap/cppgc/metric-recorder.h"
 
 namespace cppgc {
 namespace internal {
 
 // static
 constexpr size_t StatsCollector::kAllocationThresholdBytes;
 
+StatsCollector::StatsCollector(
+    std::unique_ptr<MetricRecorder> histogram_recorder)
+    : metric_recorder_(std::move(histogram_recorder)) {}
+
 void StatsCollector::RegisterObserver(AllocationObserver* observer) {
   DCHECK_EQ(allocation_observers_.end(),
             std::find(allocation_observers_.begin(),
@@ -114,6 +119,18 @@ void StatsCollector::NotifySweepingCompleted() {
   gc_state_ = GarbageCollectionState::kNotRunning;
   previous_ = std::move(current_);
   current_ = Event();
+  if (metric_recorder_) {
+    MetricRecorder::CppGCCycleEndMetricSamples event{
+        previous_.scope_data[kAtomicMark].InMilliseconds(),
+        previous_.scope_data[kAtomicWeak].InMilliseconds(),
+        previous_.scope_data[kAtomicCompact].InMilliseconds(),
+        previous_.scope_data[kAtomicSweep].InMilliseconds(),
+        previous_.scope_data[kIncrementalMark].InMilliseconds(),
+        previous_.scope_data[kIncrementalSweep].InMilliseconds(),
+        previous_.concurrent_scope_data[kConcurrentMark],
+        previous_.concurrent_scope_data[kConcurrentSweep]};
+    metric_recorder_->AddMainThreadEvent(event);
+  }
 }
 
 size_t StatsCollector::allocated_object_size() const {
@@ -129,5 +146,25 @@ size_t StatsCollector::allocated_object_size() const {
                              allocated_bytes_since_end_of_marking_);
 }
 
+void StatsCollector::RecordHistogramSample(ScopeId scope_id_,
+                                           v8::base::TimeDelta time) {
+  switch (scope_id_) {
+    case kIncrementalMark: {
+      MetricRecorder::CppGCIncrementalMarkMetricSample event{
+          time.InMilliseconds()};
+      metric_recorder_->AddMainThreadEvent(event);
+      break;
+    }
+    case kIncrementalSweep: {
+      MetricRecorder::CppGCIncrementalSweepMetricSample event{
+          time.InMilliseconds()};
+      metric_recorder_->AddMainThreadEvent(event);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
 }  // namespace internal
 }  // namespace cppgc