// Copyright 2012 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_LOGGING_COUNTERS_H_
#define V8_LOGGING_COUNTERS_H_

#include <memory>
#include <variant>

#include "include/v8-callbacks.h"
#include "src/base/atomic-utils.h"
#include "src/base/platform/elapsed-timer.h"
#include "src/base/platform/time.h"
#include "src/common/globals.h"
#include "src/logging/counters-definitions.h"
#include "src/logging/runtime-call-stats.h"
#include "src/objects/code-kind.h"
#include "src/objects/objects.h"
#include "src/utils/allocation.h"

namespace v8::internal {

// StatsCounters is an interface for plugging into external
// counters for monitoring.  Counters can be looked up and
// manipulated by name.

class Counters;
class Isolate;

class StatsTable {
 public:
  StatsTable(const StatsTable&) = delete;
  StatsTable& operator=(const StatsTable&) = delete;

  // Register an application-defined function for recording
  // subsequent counter statistics.
  void SetCounterFunction(CounterLookupCallback f);

  // Register an application-defined function to create histograms for
  // recording subsequent histogram samples.
  void SetCreateHistogramFunction(CreateHistogramCallback f) {
    create_histogram_function_ = f;
  }

  // Register an application-defined function to add a sample
  // to a histogram created with CreateHistogram function.
  void SetAddHistogramSampleFunction(AddHistogramSampleCallback f) {
    add_histogram_sample_function_ = f;
  }

  bool HasCounterFunction() const { return lookup_function_ != nullptr; }

  // Lookup the location of a counter by name.  If the lookup
  // is successful, returns a non-nullptr pointer for writing the
  // value of the counter.  Each thread calling this function
  // may receive a different location to store it's counter.
  // The return value must not be cached and reused across
  // threads, although a single thread is free to cache it.
  int* FindLocation(const char* name) {
    if (!lookup_function_) return nullptr;
    return lookup_function_(name);
  }

  // Create a histogram by name. If the create is successful,
  // returns a non-nullptr pointer for use with AddHistogramSample
  // function. min and max define the expected minimum and maximum
  // sample values. buckets is the maximum number of buckets
  // that the samples will be grouped into.
  void* CreateHistogram(const char* name, int min, int max, size_t buckets) {
    if (!create_histogram_function_) return nullptr;
    return create_histogram_function_(name, min, max, buckets);
  }

  // Add a sample to a histogram created with the CreateHistogram
  // function.
  void AddHistogramSample(void* histogram, int sample) {
    if (!add_histogram_sample_function_) return;
    return add_histogram_sample_function_(histogram, sample);
  }

 private:
  friend class Counters;

  explicit StatsTable(Counters* counters);

  CounterLookupCallback lookup_function_;
  CreateHistogramCallback create_histogram_function_;
  AddHistogramSampleCallback add_histogram_sample_function_;
};

// StatsCounters are dynamically created values which can be tracked in the
// StatsTable. They are designed to be lightweight to create and easy to use.
//
// Internally, a counter represents a value in a row of a StatsTable.
// The row has a 32bit value for each process/thread in the table and also
// a name (stored in the table metadata). Since the storage location can be
// thread-specific, this class cannot be shared across threads.
// This class is thread-safe.
class StatsCounter {
 public:
  const char* name() const { return name_; }

  void Set(int value) { GetPtr()->store(value, std::memory_order_relaxed); }
  int Get() { return GetPtr()->load(); }

  void Increment(int value = 1) {
    GetPtr()->fetch_add(value, std::memory_order_relaxed);
  }

  void Decrement(int value = 1) {
    GetPtr()->fetch_sub(value, std::memory_order_relaxed);
  }

  // Returns true if this counter is enabled (a lookup function was provided and
  // it returned a non-null pointer).
  V8_EXPORT_PRIVATE bool Enabled();

  // Get the internal pointer to the counter. This is used
  // by the code generator to emit code that manipulates a
  // given counter without calling the runtime system.
  std::atomic<int>* GetInternalPointer() { return GetPtr(); }

 private:
  friend class Counters;
  friend class CountersInitializer;
  friend class StatsCounterResetter;

  void Initialize(const char* name, Counters* counters) {
    DCHECK_NULL(counters_);
    DCHECK_NOT_NULL(counters);
    // Counter names always start with "c:V8.".
    DCHECK_EQ(0, memcmp(name, "c:V8.", 5));
    counters_ = counters;
    name_ = name;
  }

  V8_NOINLINE V8_EXPORT_PRIVATE std::atomic<int>* SetupPtrFromStatsTable();

  // Reset the cached internal pointer.
  void Reset() { ptr_.store(nullptr, std::memory_order_relaxed); }

  // Returns the cached address of this counter location.
  std::atomic<int>* GetPtr() {
    auto* ptr = ptr_.load(std::memory_order_acquire);
    if (V8_LIKELY(ptr)) return ptr;
    return SetupPtrFromStatsTable();
  }

  Counters* counters_ = nullptr;
  const char* name_ = nullptr;
  // A pointer to an atomic, set atomically in {GetPtr}.
  std::atomic<std::atomic<int>*> ptr_{nullptr};
};

// A Histogram represents a dynamically created histogram in the
// StatsTable.  Note: This class is thread safe.
class Histogram {
 public:
  // Add a single sample to this histogram.
  V8_EXPORT_PRIVATE void AddSample(int sample);

  // Returns true if this histogram is enabled.
  bool Enabled() { return histogram_ != nullptr; }

  const char* name() const { return name_; }

  int min() const { return min_; }
  int max() const { return max_; }
  int num_buckets() const { return num_buckets_; }

  // Asserts that |expected_counters| are the same as the Counters this
  // Histogram reports to.
  void AssertReportsToCounters(Counters* expected_counters) {
    DCHECK_EQ(counters_, expected_counters);
  }

 protected:
  Histogram() = default;
  Histogram(const Histogram&) = delete;
  Histogram& operator=(const Histogram&) = delete;

  void Initialize(const char* name, int min, int max, int num_buckets,
                  Counters* counters) {
    name_ = name;
    min_ = min;
    max_ = max;
    num_buckets_ = num_buckets;
    histogram_ = nullptr;
    counters_ = counters;
    DCHECK_NOT_NULL(counters_);
  }

  Counters* counters() const { return counters_; }

  // Reset the cached internal pointer to nullptr; the histogram will be
  // created lazily, the first time it is needed.
  void Reset() { histogram_ = nullptr; }

  // Lazily create the histogram, if it has not been created yet.
  void EnsureCreated(bool create_new = true) {
    if (create_new && histogram_.load(std::memory_order_acquire) == nullptr) {
      base::MutexGuard Guard(&mutex_);
      if (histogram_.load(std::memory_order_relaxed) == nullptr)
        histogram_.store(CreateHistogram(), std::memory_order_release);
    }
  }

 private:
  friend class Counters;
  friend class CountersInitializer;
  friend class HistogramResetter;

  V8_EXPORT_PRIVATE void* CreateHistogram() const;

  const char* name_;
  int min_;
  int max_;
  int num_buckets_;
  std::atomic<void*> histogram_;
  Counters* counters_;
  base::Mutex mutex_;
};

// Dummy classes for better visiting.

class PercentageHistogram : public Histogram {};
class LegacyMemoryHistogram : public Histogram {};

enum class TimedHistogramResolution { MILLISECOND, MICROSECOND };

// A thread safe histogram timer.
class TimedHistogram : public Histogram {
 public:
  // Records a TimeDelta::Max() result. Useful to record percentage of tasks
  // that never got to run in a given scenario. Log if isolate non-null.
  void RecordAbandon(base::ElapsedTimer* timer, Isolate* isolate);

  // Add a single sample to this histogram.
  V8_EXPORT_PRIVATE void AddTimedSample(base::TimeDelta sample);

#ifdef DEBUG
  // Ensures that we don't have nested timers for TimedHistogram per thread, use
  // NestedTimedHistogram which correctly pause and resume timers.
  // This method assumes that each timer is alternating between stopped and
  // started on a single thread. Multiple timers can be active on different
  // threads.
  bool ToggleRunningState(bool expected_is_running) const;
#endif  // DEBUG

 protected:
  void Stop(base::ElapsedTimer* timer);
  void LogStart(Isolate* isolate);
  void LogEnd(Isolate* isolate);

  friend class Counters;
  friend class CountersInitializer;

  TimedHistogramResolution resolution_;

  TimedHistogram() = default;
  TimedHistogram(const TimedHistogram&) = delete;
  TimedHistogram& operator=(const TimedHistogram&) = delete;

  void Initialize(const char* name, int min, int max,
                  TimedHistogramResolution resolution, int num_buckets,
                  Counters* counters) {
    Histogram::Initialize(name, min, max, num_buckets, counters);
    resolution_ = resolution;
  }
};

class NestedTimedHistogramScope;
class PauseNestedTimedHistogramScope;

// For use with the NestedTimedHistogramScope. 'Nested' here means that scopes
// may have nested lifetimes while still correctly accounting for time, e.g.:
//
// void f() {
//   NestedTimedHistogramScope timer(...);
//   ...
//   f();  // Recursive call.
// }
class NestedTimedHistogram : public TimedHistogram {
 public:
  // Note: public for testing purposes only.
  NestedTimedHistogram(const char* name, int min, int max,
                       TimedHistogramResolution resolution, int num_buckets,
                       Counters* counters)
      : NestedTimedHistogram() {
    Initialize(name, min, max, resolution, num_buckets, counters);
  }

 private:
  friend class Counters;
  friend class NestedTimedHistogramScope;
  friend class PauseNestedTimedHistogramScope;

  inline NestedTimedHistogramScope* Enter(NestedTimedHistogramScope* next) {
    NestedTimedHistogramScope* previous = current_;
    current_ = next;
    return previous;
  }

  inline void Leave(NestedTimedHistogramScope* previous) {
    current_ = previous;
  }

  NestedTimedHistogramScope* current_ = nullptr;

  NestedTimedHistogram() = default;
  NestedTimedHistogram(const NestedTimedHistogram&) = delete;
  NestedTimedHistogram& operator=(const NestedTimedHistogram&) = delete;
};

// A histogram timer that can aggregate events within a larger scope.
//
// Intended use of this timer is to have an outer (aggregating) and an inner
// (to be aggregated) scope, where the inner scope measure the time of events,
// and all those inner scope measurements will be summed up by the outer scope.
// An example use might be to aggregate the time spent in lazy compilation
// while running a script.
//
// Helpers:
// - AggregatingHistogramTimerScope, the "outer" scope within which
//     times will be summed up.
// - AggregatedHistogramTimerScope, the "inner" scope which defines the
//     events to be timed.
class AggregatableHistogramTimer : public Histogram {
 public:
  // Start/stop the "outer" scope.
  void Start() { time_ = base::TimeDelta(); }
  void Stop() {
    if (time_ != base::TimeDelta()) {
      // Only add non-zero samples, since zero samples represent situations
      // where there were no aggregated samples added.
      AddSample(static_cast<int>(time_.InMicroseconds()));
    }
  }

  // Add a time value ("inner" scope).
  void Add(base::TimeDelta other) { time_ += other; }

 private:
  friend class Counters;

  AggregatableHistogramTimer() = default;
  AggregatableHistogramTimer(const AggregatableHistogramTimer&) = delete;
  AggregatableHistogramTimer& operator=(const AggregatableHistogramTimer&) =
      delete;

  base::TimeDelta time_;
};

// A helper class for use with AggregatableHistogramTimer. This is the
// // outer-most timer scope used with an AggregatableHistogramTimer. It will
// // aggregate the information from the inner AggregatedHistogramTimerScope.
class V8_NODISCARD AggregatingHistogramTimerScope {
 public:
  explicit AggregatingHistogramTimerScope(AggregatableHistogramTimer* histogram)
      : histogram_(histogram) {
    histogram_->Start();
  }
  ~AggregatingHistogramTimerScope() { histogram_->Stop(); }

 private:
  AggregatableHistogramTimer* histogram_;
};

// A helper class for use with AggregatableHistogramTimer, the "inner" scope
// // which defines the events to be timed.
class V8_NODISCARD AggregatedHistogramTimerScope {
 public:
  explicit AggregatedHistogramTimerScope(AggregatableHistogramTimer* histogram)
      : histogram_(histogram) {
    timer_.Start();
  }
  ~AggregatedHistogramTimerScope() { histogram_->Add(timer_.Elapsed()); }

 private:
  base::ElapsedTimer timer_;
  AggregatableHistogramTimer* histogram_;
};

// AggretatedMemoryHistogram collects (time, value) sample pairs and turns
// them into time-uniform samples for the backing histogram, such that the
// backing histogram receives one sample every T ms, where the T is controlled
// by the v8_flags.histogram_interval.
//
// More formally: let F be a real-valued function that maps time to sample
// values. We define F as a linear interpolation between adjacent samples. For
// each time interval [x; x + T) the backing histogram gets one sample value
// that is the average of F(t) in the interval.
template <typename Histogram>
class AggregatedMemoryHistogram {
 public:
  // Note: public for testing purposes only.
  explicit AggregatedMemoryHistogram(Histogram* backing_histogram)
      : AggregatedMemoryHistogram() {
    backing_histogram_ = backing_histogram;
  }

  // Invariants that hold before and after AddSample if
  // is_initialized_ is true:
  //
  // 1) For we processed samples that came in before start_ms_ and sent the
  // corresponding aggregated samples to backing histogram.
  // 2) (last_ms_, last_value_) is the last received sample.
  // 3) last_ms_ < start_ms_ + v8_flags.histogram_interval.
  // 4) aggregate_value_ is the average of the function that is constructed by
  // linearly interpolating samples received between start_ms_ and last_ms_.
  void AddSample(double current_ms, double current_value);

 private:
  friend class Counters;

  AggregatedMemoryHistogram()
      : is_initialized_(false),
        start_ms_(0.0),
        last_ms_(0.0),
        aggregate_value_(0.0),
        last_value_(0.0),
        backing_histogram_(nullptr) {}
  double Aggregate(double current_ms, double current_value);

  bool is_initialized_;
  double start_ms_;
  double last_ms_;
  double aggregate_value_;
  double last_value_;
  Histogram* backing_histogram_;
};

template <typename Histogram>
void AggregatedMemoryHistogram<Histogram>::AddSample(double current_ms,
                                                     double current_value) {
  if (!is_initialized_) {
    aggregate_value_ = current_value;
    start_ms_ = current_ms;
    last_value_ = current_value;
    last_ms_ = current_ms;
    is_initialized_ = true;
  } else {
    const double kEpsilon = 1e-6;
    const int kMaxSamples = 1000;
    if (current_ms < last_ms_ + kEpsilon) {
      // Two samples have the same time, remember the last one.
      last_value_ = current_value;
    } else {
      double sample_interval_ms = v8_flags.histogram_interval;
      double end_ms = start_ms_ + sample_interval_ms;
      if (end_ms <= current_ms + kEpsilon) {
        // Linearly interpolate between the last_ms_ and the current_ms.
        double slope = (current_value - last_value_) / (current_ms - last_ms_);
        int i;
        // Send aggregated samples to the backing histogram from the start_ms
        // to the current_ms.
        for (i = 0; i < kMaxSamples && end_ms <= current_ms + kEpsilon; i++) {
          double end_value = last_value_ + (end_ms - last_ms_) * slope;
          double sample_value;
          if (i == 0) {
            // Take aggregate_value_ into account.
            sample_value = Aggregate(end_ms, end_value);
          } else {
            // There is no aggregate_value_ for i > 0.
            sample_value = (last_value_ + end_value) / 2;
          }
          backing_histogram_->AddSample(static_cast<int>(sample_value + 0.5));
          last_value_ = end_value;
          last_ms_ = end_ms;
          end_ms += sample_interval_ms;
        }
        if (i == kMaxSamples) {
          // We hit the sample limit, ignore the remaining samples.
          aggregate_value_ = current_value;
          start_ms_ = current_ms;
        } else {
          aggregate_value_ = last_value_;
          start_ms_ = last_ms_;
        }
      }
      aggregate_value_ = current_ms > start_ms_ + kEpsilon
                             ? Aggregate(current_ms, current_value)
                             : aggregate_value_;
      last_value_ = current_value;
      last_ms_ = current_ms;
    }
  }
}

template <typename Histogram>
double AggregatedMemoryHistogram<Histogram>::Aggregate(double current_ms,
                                                       double current_value) {
  double interval_ms = current_ms - start_ms_;
  double value = (current_value + last_value_) / 2;
  // The aggregate_value_ is the average for [start_ms_; last_ms_].
  // The value is the average for [last_ms_; current_ms].
  // Return the weighted average of the aggregate_value_ and the value.
  return aggregate_value_ * ((last_ms_ - start_ms_) / interval_ms) +
         value * ((current_ms - last_ms_) / interval_ms);
}

// This file contains all the v8 counters that are in use.
class Counters : public std::enable_shared_from_this<Counters> {
 public:
  explicit Counters(Isolate* isolate);

  // Register an application-defined function for recording
  // subsequent counter statistics. Note: Must be called on the main
  // thread.
  void ResetCounterFunction(CounterLookupCallback f);

  // Register an application-defined function to create histograms for
  // recording subsequent histogram samples. Note: Must be called on
  // the main thread.
  void ResetCreateHistogramFunction(CreateHistogramCallback f);

  // Register an application-defined function to add a sample
  // to a histogram. Will be used in all subsequent sample additions.
  // Note: Must be called on the main thread.
  void SetAddHistogramSampleFunction(AddHistogramSampleCallback f) {
    stats_table_.SetAddHistogramSampleFunction(f);
  }

#define HR(name, caption, min, max, num_buckets) \
  Histogram* name() {                            \
    name##_.EnsureCreated();                     \
    return &name##_;                             \
  }
  HISTOGRAM_RANGE_LIST(HR)
#undef HR

#if V8_ENABLE_DRUMBRAKE
#define HR(name, caption, min, max, num_buckets)     \
  Histogram* name() {                                \
    name##_.EnsureCreated(v8_flags.slow_histograms); \
    return &name##_;                                 \
  }
  HISTOGRAM_RANGE_LIST_SLOW(HR)
#undef HR
#endif  // V8_ENABLE_DRUMBRAKE

#define HT(name, caption, max, res) \
  NestedTimedHistogram* name() {    \
    name##_.EnsureCreated();        \
    return &name##_;                \
  }
  NESTED_TIMED_HISTOGRAM_LIST(HT)
#undef HT

#define HT(name, caption, max, res)                  \
  NestedTimedHistogram* name() {                     \
    name##_.EnsureCreated(v8_flags.slow_histograms); \
    return &name##_;                                 \
  }
  NESTED_TIMED_HISTOGRAM_LIST_SLOW(HT)
#undef HT

#define HT(name, caption, max, res) \
  TimedHistogram* name() {          \
    name##_.EnsureCreated();        \
    return &name##_;                \
  }
  TIMED_HISTOGRAM_LIST(HT)
#undef HT

#define AHT(name, caption)             \
  AggregatableHistogramTimer* name() { \
    name##_.EnsureCreated();           \
    return &name##_;                   \
  }
  AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT)
#undef AHT

#define HP(name, caption)       \
  PercentageHistogram* name() { \
    name##_.EnsureCreated();    \
    return &name##_;            \
  }
  HISTOGRAM_PERCENTAGE_LIST(HP)
#undef HP

#define HM(name, caption)         \
  LegacyMemoryHistogram* name() { \
    name##_.EnsureCreated();      \
    return &name##_;              \
  }
  HISTOGRAM_LEGACY_MEMORY_LIST(HM)
#undef HM

#define SC(name, caption) \
  StatsCounter* name() { return &name##_; }
  STATS_COUNTER_LIST(SC)
  STATS_COUNTER_NATIVE_CODE_LIST(SC)
#undef SC

#if defined(V8_RUNTIME_CALL_STATS) || defined(HITRACE_RUNTIME_CALL_STATS)
  RuntimeCallStats* runtime_call_stats() { return &runtime_call_stats_; }

  WorkerThreadRuntimeCallStats* worker_thread_runtime_call_stats() {
    return &worker_thread_runtime_call_stats_;
  }
#else   // V8_RUNTIME_CALL_STATS
  RuntimeCallStats* runtime_call_stats() { return nullptr; }

  WorkerThreadRuntimeCallStats* worker_thread_runtime_call_stats() {
    return nullptr;
  }
#endif  // V8_RUNTIME_CALL_STATS

 private:
  friend class CountersVisitor;
  friend class Histogram;
  friend class NestedTimedHistogramScope;
  friend class StatsCounter;
  friend class StatsTable;

  int* FindLocation(const char* name) {
    return stats_table_.FindLocation(name);
  }

  void* CreateHistogram(const char* name, int min, int max, size_t buckets) {
    return stats_table_.CreateHistogram(name, min, max, buckets);
  }

  void AddHistogramSample(void* histogram, int sample) {
    stats_table_.AddHistogramSample(histogram, sample);
  }

  Isolate* isolate() { return isolate_; }

#define HR(name, caption, min, max, num_buckets) Histogram name##_;
  HISTOGRAM_RANGE_LIST(HR)
#if V8_ENABLE_DRUMBRAKE
  HISTOGRAM_RANGE_LIST_SLOW(HR)
#endif  // V8_ENABLE_DRUMBRAKE
#undef HR

#define HT(name, caption, max, res) NestedTimedHistogram name##_;
  NESTED_TIMED_HISTOGRAM_LIST(HT)
  NESTED_TIMED_HISTOGRAM_LIST_SLOW(HT)
#undef HT

#define HT(name, caption, max, res) TimedHistogram name##_;
  TIMED_HISTOGRAM_LIST(HT)
#undef HT

#define AHT(name, caption) AggregatableHistogramTimer name##_;
  AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT)
#undef AHT

#define HP(name, caption) PercentageHistogram name##_;
  HISTOGRAM_PERCENTAGE_LIST(HP)
#undef HP

#define HM(name, caption) LegacyMemoryHistogram name##_;
  HISTOGRAM_LEGACY_MEMORY_LIST(HM)
#undef HM

#define SC(name, caption) StatsCounter name##_;
  STATS_COUNTER_LIST(SC)
  STATS_COUNTER_NATIVE_CODE_LIST(SC)
#undef SC

#if defined(V8_RUNTIME_CALL_STATS) || defined(HITRACE_RUNTIME_CALL_STATS)
  RuntimeCallStats runtime_call_stats_;
  WorkerThreadRuntimeCallStats worker_thread_runtime_call_stats_;
#endif
  Isolate* isolate_;
  StatsTable stats_table_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
};

class CountersVisitor {
 public:
  explicit CountersVisitor(Counters* counters) : counters_(counters) {}

  void Start();
  Counters* counters() { return counters_; }

 protected:
  virtual void VisitHistograms();
  virtual void VisitStatsCounters();

  virtual void VisitHistogram(Histogram* histogram, const char* caption) {}
  virtual void VisitStatsCounter(StatsCounter* counter, const char* caption) {}

  virtual void Visit(Histogram* histogram, const char* caption, int min,
                     int max, int num_buckets);
  virtual void Visit(TimedHistogram* histogram, const char* caption, int max,
                     TimedHistogramResolution res);
  virtual void Visit(NestedTimedHistogram* histogram, const char* caption,
                     int max, TimedHistogramResolution res);
  virtual void Visit(AggregatableHistogramTimer* histogram,
                     const char* caption);
  virtual void Visit(PercentageHistogram* histogram, const char* caption);
  virtual void Visit(LegacyMemoryHistogram* histogram, const char* caption);
  virtual void Visit(StatsCounter* counter, const char* caption);

 private:
  Counters* counters_;
};

class CountersInitializer : public CountersVisitor {
 public:
  using CountersVisitor::CountersVisitor;

 protected:
  void Visit(Histogram* histogram, const char* caption, int min, int max,
             int num_buckets) final;
  void Visit(TimedHistogram* histogram, const char* caption, int max,
             TimedHistogramResolution res) final;
  void Visit(NestedTimedHistogram* histogram, const char* caption, int max,
             TimedHistogramResolution res) final;
  void Visit(AggregatableHistogramTimer* histogram, const char* caption) final;
  void Visit(PercentageHistogram* histogram, const char* caption) final;
  void Visit(LegacyMemoryHistogram* histogram, const char* caption) final;
  void Visit(StatsCounter* counter, const char* caption) final;
};

class StatsCounterResetter : public CountersVisitor {
 public:
  using CountersVisitor::CountersVisitor;

 protected:
  void VisitHistograms() final {}
  void VisitStatsCounter(StatsCounter* counter, const char* caption) final;
};

class HistogramResetter : public CountersVisitor {
 public:
  using CountersVisitor::CountersVisitor;

 protected:
  void VisitStatsCounters() final {}
  void VisitHistogram(Histogram* histogram, const char* caption) final;
};

// Stores histogram samples and other counter updates and allows to publish them
// later in a given Isolate.
// This is useful for data which is collected in background work and/or when no
// isolate is available (yet). To easily support adding data from background
// threads, this class is synchronized automatically via an internal mutex.
class DelayedCounterUpdates {
 public:
  // We do not have histogram IDs, so just store the member function on the
  // isolate which returns the histogram.
  using GetHistogramFn = Histogram* (Counters::*)();
  using GetTimedHistogramFn = TimedHistogram* (Counters::*)();
  using GetStatsCounterFn = StatsCounter* (Counters::*)();

  // `Publish` will add any outstanding samples to the given isolate.
  void Publish(Isolate* isolate) {
    if (V8_LIKELY(!has_updates_.load(std::memory_order_relaxed))) return;
    PublishImpl(isolate);
  }

  void AddSample(GetHistogramFn fn, int sample) {
    base::MutexGuard mutex_guard{&mutex_};
    outstanding_updates_.push_back(HistogramUpdate{fn, sample});
    has_updates_.store(true, std::memory_order_relaxed);
  }

  void AddTimedSample(GetTimedHistogramFn fn, base::TimeDelta sample) {
    base::MutexGuard mutex_guard{&mutex_};
    outstanding_updates_.push_back(TimedHistogramUpdate{fn, sample});
    has_updates_.store(true, std::memory_order_relaxed);
  }

  void AddIncrement(GetStatsCounterFn fn, int increment) {
    base::MutexGuard mutex_guard{&mutex_};
    outstanding_updates_.push_back(StatsCounterUpdate{fn, increment});
    has_updates_.store(true, std::memory_order_relaxed);
  }

  void AddAll(DelayedCounterUpdates&& other) {
    // No need to take `other`'s mutex, as it's an r-value ref, so unshared.
    if (other.outstanding_updates_.empty()) return;
    base::MutexGuard mutex_guard{&mutex_};
    if (outstanding_updates_.empty()) {
      outstanding_updates_.swap(other.outstanding_updates_);
    } else {
      outstanding_updates_.insert(outstanding_updates_.end(),
                                  other.outstanding_updates_.begin(),
                                  other.outstanding_updates_.end());
      other.outstanding_updates_.clear();
    }
    has_updates_.store(true, std::memory_order_relaxed);
  }

  size_t EstimateCurrentMemoryConsumption() const {
    base::MutexGuard mutex_guard{&mutex_};
    return sizeof(this) + outstanding_updates_.capacity() *
                              sizeof(*outstanding_updates_.data());
  }

  // For debugging.
  size_t NumOutstandingUpdates() const {
    base::MutexGuard mutex_guard{&mutex_};
    return outstanding_updates_.size();
  }

 private:
  V8_NOINLINE V8_PRESERVE_MOST void PublishImpl(Isolate*);

  struct HistogramUpdate {
    GetHistogramFn fn;
    int sample;
  };
  struct TimedHistogramUpdate {
    GetTimedHistogramFn fn;
    base::TimeDelta sample;
  };
  struct StatsCounterUpdate {
    GetStatsCounterFn fn;
    int increment;
  };
  using AnyUpdate =
      std::variant<HistogramUpdate, TimedHistogramUpdate, StatsCounterUpdate>;

  // `has_updates_` enables the fast path in `Publish` for the common case that
  // no counter updates are outstanding.
  std::atomic<bool> has_updates_;
  mutable base::Mutex mutex_;
  std::vector<AnyUpdate> outstanding_updates_;
};

}  // namespace v8::internal

#endif  // V8_LOGGING_COUNTERS_H_