path: root/chromium/third_party/blink/renderer/platform/heap/impl/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_IMPL_HEAP_STATS_COLLECTOR_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_HEAP_STATS_COLLECTOR_H_

#include <stddef.h>

#include "base/atomicops.h"
#include "third_party/blink/renderer/platform/heap/blink_gc.h"
#include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

namespace blink {

// Interface for observing changes to heap sizing.
class PLATFORM_EXPORT ThreadHeapStatsObserver {
 public:
  // Called upon allocating/releasing chunks of memory that contain objects.
  //
  // Must not trigger GC or allocate.
  virtual void IncreaseAllocatedSpace(size_t) = 0;
  virtual void DecreaseAllocatedSpace(size_t) = 0;

  // Called once per GC cycle with the accurate number of live |bytes|.
  //
  // Must not trigger GC or allocate.
  virtual void ResetAllocatedObjectSize(size_t bytes) = 0;

  // Called after observing at least
  // |ThreadHeapStatsCollector::kUpdateThreshold| changed bytes through
  // allocation or explicit free. Reports both, negative and positive
  // increments, to allow observer to decide whether absolute values or only the
  // deltas is interesting.
  //
  // May trigger GC but most not allocate.
  virtual void IncreaseAllocatedObjectSize(size_t) = 0;
  virtual void DecreaseAllocatedObjectSize(size_t) = 0;
};

#define FOR_ALL_SCOPES(V)                    \
  V(AtomicPauseCompaction)                   \
  V(AtomicPauseMarkEpilogue)                 \
  V(AtomicPauseMarkPrologue)                 \
  V(AtomicPauseMarkRoots)                    \
  V(AtomicPauseMarkTransitiveClosure)        \
  V(AtomicPauseSweepAndCompact)              \
  V(CompleteSweep)                           \
  V(IncrementalMarkingFinalize)              \
  V(IncrementalMarkingStartMarking)          \
  V(IncrementalMarkingStep)                  \
  V(IncrementalMarkingWithDeadline)          \
  V(InvokePreFinalizers)                     \
  V(LazySweepInIdle)                         \
  V(LazySweepOnAllocation)                   \
  V(MarkBailOutObjects)                      \
  V(MarkInvokeEphemeronCallbacks)            \
  V(MarkFlushV8References)                   \
  V(MarkFlushEphemeronPairs)                 \
  V(MarkProcessWorklists)                    \
  V(MarkProcessMarkingWorklist)              \
  V(MarkProcessWriteBarrierWorklist)         \
  V(MarkProcessNotFullyconstructeddWorklist) \
  V(MarkNotFullyConstructedObjects)          \
  V(MarkWeakProcessing)                      \
  V(UnifiedMarkingStep)                      \
  V(VisitCrossThreadPersistents)             \
  V(VisitPersistentRoots)                    \
  V(VisitPersistents)                        \
  V(VisitRoots)                              \
  V(VisitStackRoots)                         \
  V(VisitRememberedSets)

#define FOR_ALL_CONCURRENT_SCOPES(V)        \
  V(ConcurrentMarkInvokeEphemeronCallbacks) \
  V(ConcurrentMarkingStep)                  \
  V(ConcurrentSweepingStep)

// Manages counters and statistics across garbage collection cycles.
//
// Usage:
//   ThreadHeapStatsCollector stats_collector;
//   stats_collector.NotifyMarkingStarted(<BlinkGC::CollectionType>,
//                                        <BlinkGC::GCReason>);
//   // Use tracer.
//   stats_collector.NotifySweepingCompleted();
//   // Previous event is available using stats_collector.previous().
class PLATFORM_EXPORT ThreadHeapStatsCollector {
  USING_FAST_MALLOC(ThreadHeapStatsCollector);

 public:
  // These ids will form human readable names when used in Scopes.
  enum Id {
#define DECLARE_ENUM(name) k##name,
    FOR_ALL_SCOPES(DECLARE_ENUM)
#undef DECLARE_ENUM
        kNumScopeIds,
  };

  enum ConcurrentId {
#define DECLARE_ENUM(name) k##name,
    FOR_ALL_CONCURRENT_SCOPES(DECLARE_ENUM)
#undef DECLARE_ENUM
        kNumConcurrentScopeIds
  };

  constexpr static const char* ToString(Id id, BlinkGC::CollectionType type) {
    switch (id) {
#define CASE(name)                                                    \
  case k##name:                                                       \
    return type == BlinkGC::CollectionType::kMajor ? "BlinkGC." #name \
                                                   : "BlinkGC." #name \
                                                     ".Minor";
      FOR_ALL_SCOPES(CASE)
#undef CASE
      default:
        NOTREACHED();
    }
    return nullptr;
  }

  constexpr static const char* ToString(ConcurrentId id,
                                        BlinkGC::CollectionType type) {
    switch (id) {
#define CASE(name)                                                    \
  case k##name:                                                       \
    return type == BlinkGC::CollectionType::kMajor ? "BlinkGC." #name \
                                                   : "BlinkGC." #name \
                                                     ".Minor";
      FOR_ALL_CONCURRENT_SCOPES(CASE)
#undef CASE
      default:
        NOTREACHED();
    }
    return nullptr;
  }

  enum TraceCategory { kEnabled, kDisabled };
  enum ScopeContext { kMutatorThread, kConcurrentThread };

  // Trace a particular scope. Will emit a trace event and record the time in
  // the corresponding ThreadHeapStatsCollector.
  template <TraceCategory trace_category = kDisabled,
            ScopeContext scope_category = kMutatorThread>
  class PLATFORM_EXPORT InternalScope {
    DISALLOW_NEW();

    using IdType =
        std::conditional_t<scope_category == kMutatorThread, Id, ConcurrentId>;

   public:
    template <typename... Args>
    InternalScope(ThreadHeapStatsCollector* tracer, IdType id, Args... args)
        : tracer_(tracer), start_time_(base::TimeTicks::Now()), id_(id) {
      StartTrace(args...);
    }
    InternalScope(const InternalScope&) = delete;
    InternalScope& operator=(const InternalScope&) = delete;

    ~InternalScope() {
      StopTrace();
      IncreaseScopeTime(id_);
    }

   private:
    inline constexpr static const char* TraceCategory();

    inline void StartTrace();
    template <typename Value1>
    inline void StartTrace(const char* k1, Value1 v1);
    template <typename Value1, typename Value2>
    inline void StartTrace(const char* k1,
                           Value1 v1,
                           const char* k2,
                           Value2 v2);
    inline void StopTrace();

    inline void IncreaseScopeTime(Id);
    inline void IncreaseScopeTime(ConcurrentId);

    ThreadHeapStatsCollector* const tracer_;
    const base::TimeTicks start_time_;
    const IdType id_;
  };

  using Scope = InternalScope<kDisabled>;
  using EnabledScope = InternalScope<kEnabled>;
  using ConcurrentScope = InternalScope<kDisabled, kConcurrentThread>;
  using EnabledConcurrentScope = InternalScope<kEnabled, kConcurrentThread>;

  // BlinkGCInV8Scope keeps track of time spent in Blink's GC when called by V8.
  // This is necessary to avoid double-accounting of Blink's time when computing
  // the overall time (V8 + Blink) spent in GC on the main thread.
  class PLATFORM_EXPORT BlinkGCInV8Scope {
    DISALLOW_NEW();

   public:
    template <typename... Args>
    BlinkGCInV8Scope(ThreadHeapStatsCollector* tracer)
        : tracer_(tracer), start_time_(base::TimeTicks::Now()) {}
    BlinkGCInV8Scope(const BlinkGCInV8Scope&) = delete;
    BlinkGCInV8Scope& operator=(const BlinkGCInV8Scope&) = delete;

    ~BlinkGCInV8Scope() {
      if (tracer_)
        tracer_->gc_nested_in_v8_ += base::TimeTicks::Now() - start_time_;
    }

   private:
    ThreadHeapStatsCollector* const tracer_;
    const base::TimeTicks start_time_;
  };

  // POD to hold interesting data accumulated during a garbage collection cycle.
  // The event is always fully populated when looking at previous events but
  // is only be partially populated when looking at the current event. See
  // members on when they are available.
  //
  // Note that all getters include time for stand-alone as well as unified heap
  // GCs. E.g., |atomic_marking_time()| report the marking time of the atomic
  // phase, independent of whether the GC was a stand-alone or unified heap GC.
  struct PLATFORM_EXPORT Event {
    Event();

    // Overall time spent in the GC cycle. This includes marking time as well as
    // sweeping time.
    base::TimeDelta gc_cycle_time() const;

    // Time spent in the final atomic pause of a GC cycle.
    base::TimeDelta atomic_pause_time() const;

    // Time spent in the final atomic pause for marking the heap.
    base::TimeDelta atomic_marking_time() const;

    // Time spent in the final atomic pause in sweeping and compacting the heap.
    base::TimeDelta atomic_sweep_and_compact_time() const;

    // Time spent marking the roots.
    base::TimeDelta roots_marking_time() const;

    // Time spent incrementally marking the heap.
    base::TimeDelta incremental_marking_time() const;

    // Time spent processing worklist in the foreground thread.
    base::TimeDelta worklist_processing_time_foreground() const;

    // Time spent flushing v8 references (this is done only in the foreground)
    base::TimeDelta flushing_v8_references_time() const;

    // Time spent in foreground tasks marking the heap.
    base::TimeDelta foreground_marking_time() const;

    // Time spent in background tasks marking the heap.
    base::TimeDelta background_marking_time() const;

    // Overall time spent marking the heap.
    base::TimeDelta marking_time() const;

    // Time spent in foreground tasks sweeping the heap.
    base::TimeDelta foreground_sweeping_time() const;

    // Time spent in background tasks sweeping the heap.
    base::TimeDelta background_sweeping_time() const;

    // Overall time spent sweeping the heap.
    base::TimeDelta sweeping_time() const;

    // Marked bytes collected during sweeping.
    size_t unique_id = -1;
    size_t marked_bytes = 0;
    size_t compaction_freed_bytes = 0;
    size_t compaction_freed_pages = 0;
    bool compaction_recorded_events = false;
    base::TimeDelta scope_data[kNumScopeIds];
    base::subtle::Atomic32 concurrent_scope_data[kNumConcurrentScopeIds]{0};
    BlinkGC::GCReason reason = static_cast<BlinkGC::GCReason>(0);
    BlinkGC::CollectionType collection_type = BlinkGC::CollectionType::kMajor;
    size_t object_size_in_bytes_before_sweeping = 0;
    size_t allocated_space_in_bytes_before_sweeping = 0;
    size_t partition_alloc_bytes_before_sweeping = 0;
    double live_object_rate = 0;
    base::TimeDelta gc_nested_in_v8;
    bool is_forced_gc = true;
  };

  // Indicates a new garbage collection cycle.
  void NotifyMarkingStarted(BlinkGC::CollectionType,
                            BlinkGC::GCReason,
                            bool is_forced_gc);

  // Indicates that marking of the current garbage collection cycle is
  // completed.
  void NotifyMarkingCompleted(size_t marked_bytes);

  // Indicates the end of a garbage collection cycle. This means that sweeping
  // is finished at this point.
  void NotifySweepingCompleted();

  void IncreaseScopeTime(Id id, base::TimeDelta time) {
    DCHECK(is_started_);
    current_.scope_data[id] += time;
  }

  void IncreaseConcurrentScopeTime(ConcurrentId id, base::TimeDelta time) {
    using Atomic32 = base::subtle::Atomic32;
    DCHECK(is_started_);
    const int64_t ms = time.InMicroseconds();
    DCHECK(ms <= std::numeric_limits<Atomic32>::max());
    base::subtle::NoBarrier_AtomicIncrement(&current_.concurrent_scope_data[id],
                                            static_cast<Atomic32>(ms));
  }

  void UpdateReason(BlinkGC::GCReason);
  void IncreaseCompactionFreedSize(size_t);
  void IncreaseCompactionFreedPages(size_t);
  void IncreaseAllocatedObjectSize(size_t);
  void DecreaseAllocatedObjectSize(size_t);
  void IncreaseAllocatedSpace(size_t);
  void DecreaseAllocatedSpace(size_t);
  void IncreaseWrapperCount(size_t);
  void DecreaseWrapperCount(size_t);
  void IncreaseCollectedWrapperCount(size_t);

  // Called by the GC when it hits a point where allocated memory may be
  // reported and garbage collection is possible. This is necessary, as
  // increments and decrements are reported as close to their actual
  // allocation/reclamation as possible.
  void AllocatedObjectSizeSafepoint();

  // Size of objects on the heap. Based on marked bytes in the previous cycle
  // and newly allocated bytes since the previous cycle.
  size_t object_size_in_bytes() const;

  size_t marked_bytes() const;
  base::TimeDelta marking_time_so_far() const;

  base::TimeDelta worklist_processing_time_foreground() const;

  base::TimeDelta flushing_v8_references_time() const;

  int64_t allocated_bytes_since_prev_gc() const;

  size_t allocated_space_bytes() const;

  size_t wrapper_count() const;
  size_t collected_wrapper_count() const;

  bool is_started() const { return is_started_; }

  // Statistics for the previously running garbage collection.
  const Event& previous() const { return previous_; }

  void RegisterObserver(ThreadHeapStatsObserver* observer);
  void UnregisterObserver(ThreadHeapStatsObserver* observer);

  void IncreaseAllocatedObjectSizeForTesting(size_t);
  void DecreaseAllocatedObjectSizeForTesting(size_t);

 private:
  // Observers are implemented using virtual calls. Avoid notifications below
  // reasonably interesting sizes.
  static constexpr int64_t kUpdateThreshold = 1024;

  // Invokes |callback| for all registered observers.
  template <typename Callback>
  void ForAllObservers(Callback callback);

  void AllocatedObjectSizeSafepointImpl();

  // Statistics for the currently running garbage collection. Note that the
  // Event may not be fully populated yet as some phase may not have been run.
  const Event& current() const { return current_; }

  Event current_;
  Event previous_;

  // Allocated bytes since the last garbage collection. These bytes are reset
  // after marking as they are accounted in marked_bytes then.
  int64_t allocated_bytes_since_prev_gc_ = 0;
  int64_t pos_delta_allocated_bytes_since_prev_gc_ = 0;
  int64_t neg_delta_allocated_bytes_since_prev_gc_ = 0;

  // Allocated space in bytes for all arenas.
  size_t allocated_space_bytes_ = 0;

  bool is_started_ = false;
  bool is_sweeping_ = false;

  // base::TimeDelta for RawScope. These don't need to be nested within a
  // garbage collection cycle to make them easier to use.
  base::TimeDelta gc_nested_in_v8_;

  Vector<ThreadHeapStatsObserver*> observers_;

  FRIEND_TEST_ALL_PREFIXES(ThreadHeapStatsCollectorTest, InitialEmpty);
  FRIEND_TEST_ALL_PREFIXES(ThreadHeapStatsCollectorTest, IncreaseScopeTime);
  FRIEND_TEST_ALL_PREFIXES(ThreadHeapStatsCollectorTest, StopResetsCurrent);
};

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
constexpr const char*
ThreadHeapStatsCollector::InternalScope<trace_category,
                                        scope_category>::TraceCategory() {
  switch (trace_category) {
    case kEnabled:
      return "blink_gc,devtools.timeline";
    case kDisabled:
      return TRACE_DISABLED_BY_DEFAULT("blink_gc");
  }
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
void ThreadHeapStatsCollector::InternalScope<trace_category,
                                             scope_category>::StartTrace() {
  TRACE_EVENT_BEGIN0(TraceCategory(),
                     ToString(id_, tracer_->current_.collection_type));
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
template <typename Value1>
void ThreadHeapStatsCollector::InternalScope<trace_category, scope_category>::
    StartTrace(const char* k1, Value1 v1) {
  TRACE_EVENT_BEGIN1(TraceCategory(),
                     ToString(id_, tracer_->current_.collection_type), k1, v1);
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
template <typename Value1, typename Value2>
void ThreadHeapStatsCollector::InternalScope<trace_category, scope_category>::
    StartTrace(const char* k1, Value1 v1, const char* k2, Value2 v2) {
  TRACE_EVENT_BEGIN2(TraceCategory(),
                     ToString(id_, tracer_->current_.collection_type), k1, v1,
                     k2, v2);
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
void ThreadHeapStatsCollector::InternalScope<trace_category,
                                             scope_category>::StopTrace() {
  TRACE_EVENT_END2(TraceCategory(),
                   ToString(id_, tracer_->current_.collection_type), "epoch",
                   tracer_->current_.unique_id, "forced",
                   tracer_->current_.is_forced_gc);
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
void ThreadHeapStatsCollector::InternalScope<trace_category, scope_category>::
    IncreaseScopeTime(Id) {
  tracer_->IncreaseScopeTime(id_, base::TimeTicks::Now() - start_time_);
}

template <ThreadHeapStatsCollector::TraceCategory trace_category,
          ThreadHeapStatsCollector::ScopeContext scope_category>
void ThreadHeapStatsCollector::InternalScope<trace_category, scope_category>::
    IncreaseScopeTime(ConcurrentId) {
  tracer_->IncreaseConcurrentScopeTime(id_,
                                       base::TimeTicks::Now() - start_time_);
}

#undef FOR_ALL_SCOPES
#undef FOR_ALL_CONCURRENT_SCOPES

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_HEAP_STATS_COLLECTOR_H_