Gecko [ c.stage.kornherr.net ]

Name	Size	Permission	Date
cppgc	[ DIR ]	drwxr-xr-x	2024-07-10 10:55
libplatform	[ DIR ]	drwxr-xr-x	2024-07-10 10:55
v8-array-buffer.h	15.53 KB	-rw-r--r--	2024-02-13 21:40
v8-callbacks.h	14.05 KB	-rw-r--r--	2024-02-13 21:40
v8-container.h	3.4 KB	-rw-r--r--	2024-02-13 21:40
v8-context.h	13.91 KB	-rw-r--r--	2024-02-13 21:40
v8-cppgc.h	6.36 KB	-rw-r--r--	2024-02-13 21:40
v8-data.h	1.58 KB	-rw-r--r--	2024-02-13 21:40
v8-date.h	1.09 KB	-rw-r--r--	2024-02-13 21:40
v8-debug.h	5.04 KB	-rw-r--r--	2024-02-13 21:40
v8-embedder-heap.h	6.72 KB	-rw-r--r--	2024-02-13 21:40
v8-embedder-state-scope.h	1.51 KB	-rw-r--r--	2024-02-13 21:40
v8-exception.h	6.98 KB	-rw-r--r--	2024-02-13 21:40
v8-extension.h	1.83 KB	-rw-r--r--	2024-02-13 21:40
v8-external.h	924 B	-rw-r--r--	2024-02-13 21:40
v8-fast-api-calls.h	35.2 KB	-rw-r--r--	2024-02-13 21:40
v8-forward.h	1.62 KB	-rw-r--r--	2024-02-13 21:40
v8-function-callback.h	15.02 KB	-rw-r--r--	2024-02-13 21:40
v8-function.h	3.91 KB	-rw-r--r--	2024-02-13 21:40
v8-initialization.h	10.97 KB	-rw-r--r--	2024-02-13 21:40
v8-inspector-protocol.h	553 B	-rw-r--r--	2024-02-13 21:40
v8-inspector.h	13.04 KB	-rw-r--r--	2024-02-13 21:40
v8-internal.h	26.03 KB	-rw-r--r--	2024-02-13 21:40
v8-isolate.h	61.74 KB	-rw-r--r--	2024-02-13 21:40
v8-json.h	1.32 KB	-rw-r--r--	2024-02-13 21:40
v8-local-handle.h	14.24 KB	-rw-r--r--	2024-02-13 21:40
v8-locker.h	4.31 KB	-rw-r--r--	2024-02-13 21:40
v8-maybe.h	3.66 KB	-rw-r--r--	2024-02-13 21:40
v8-memory-span.h	1.25 KB	-rw-r--r--	2024-02-13 21:40
v8-message.h	6.38 KB	-rw-r--r--	2024-02-13 21:40
v8-metrics.h	8.44 KB	-rw-r--r--	2024-02-13 21:40
v8-microtask-queue.h	4.79 KB	-rw-r--r--	2024-02-13 21:40
v8-microtask.h	861 B	-rw-r--r--	2024-02-13 21:40
v8-object.h	27.4 KB	-rw-r--r--	2024-02-13 21:40
v8-persistent-handle.h	18.69 KB	-rw-r--r--	2024-02-13 21:40
v8-platform.h	38.07 KB	-rw-r--r--	2024-02-13 21:40
v8-primitive-object.h	2.53 KB	-rw-r--r--	2024-02-13 21:40
v8-primitive.h	27.47 KB	-rw-r--r--	2024-02-13 21:40
v8-profiler.h	37.62 KB	-rw-r--r--	2024-02-13 21:40
v8-promise.h	5.17 KB	-rw-r--r--	2024-02-13 21:40
v8-proxy.h	1.23 KB	-rw-r--r--	2024-02-13 21:40
v8-regexp.h	3.07 KB	-rw-r--r--	2024-02-13 21:40
v8-script.h	24.77 KB	-rw-r--r--	2024-02-13 21:40
v8-snapshot.h	7.07 KB	-rw-r--r--	2024-02-13 21:40
v8-statistics.h	6.8 KB	-rw-r--r--	2024-02-13 21:40
v8-template.h	39.96 KB	-rw-r--r--	2024-02-13 21:40
v8-traced-handle.h	12.36 KB	-rw-r--r--	2024-02-13 21:40
v8-typed-array.h	8.06 KB	-rw-r--r--	2024-02-13 21:40
v8-unwinder-state.h	865 B	-rw-r--r--	2024-02-13 21:40
v8-unwinder.h	4.63 KB	-rw-r--r--	2024-02-13 21:40
v8-util.h	19.73 KB	-rw-r--r--	2024-02-13 21:40
v8-value-serializer-version.h	648 B	-rw-r--r--	2024-02-13 21:40
v8-value-serializer.h	9.47 KB	-rw-r--r--	2024-02-13 21:40
v8-value.h	12.64 KB	-rw-r--r--	2024-02-13 21:40
v8-version-string.h	1.13 KB	-rw-r--r--	2024-02-13 21:40
v8-version.h	773 B	-rw-r--r--	2024-02-13 21:40
v8-wasm-trap-handler-posix.h	1.18 KB	-rw-r--r--	2024-02-13 21:40
v8-wasm-trap-handler-win.h	1.01 KB	-rw-r--r--	2024-02-13 21:40
v8-wasm.h	7.85 KB	-rw-r--r--	2024-02-13 21:40
v8-weak-callback-info.h	2.79 KB	-rw-r--r--	2024-02-13 21:40
v8.h	3.69 KB	-rw-r--r--	2024-02-13 21:40
v8config.h	18.87 KB	-rw-r--r--	2024-02-13 21:40

Rename

// Copyright 2020 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_METRICS_H_
#define V8_METRICS_H_

#include <stddef.h>
#include <stdint.h>

#include <vector>

#include "v8-internal.h"      // NOLINT(build/include_directory)
#include "v8-local-handle.h"  // NOLINT(build/include_directory)

namespace v8 {

class Context;
class Isolate;

namespace metrics {

struct GarbageCollectionPhases {
  int64_t total_wall_clock_duration_in_us = -1;
  int64_t compact_wall_clock_duration_in_us = -1;
  int64_t mark_wall_clock_duration_in_us = -1;
  int64_t sweep_wall_clock_duration_in_us = -1;
  int64_t weak_wall_clock_duration_in_us = -1;
};

struct GarbageCollectionSizes {
  int64_t bytes_before = -1;
  int64_t bytes_after = -1;
  int64_t bytes_freed = -1;
};

struct GarbageCollectionFullCycle {
  int reason = -1;
  GarbageCollectionPhases total;
  GarbageCollectionPhases total_cpp;
  GarbageCollectionPhases main_thread;
  GarbageCollectionPhases main_thread_cpp;
  GarbageCollectionPhases main_thread_atomic;
  GarbageCollectionPhases main_thread_atomic_cpp;
  GarbageCollectionPhases main_thread_incremental;
  GarbageCollectionPhases main_thread_incremental_cpp;
  GarbageCollectionSizes objects;
  GarbageCollectionSizes objects_cpp;
  GarbageCollectionSizes memory;
  GarbageCollectionSizes memory_cpp;
  double collection_rate_in_percent = -1.0;
  double collection_rate_cpp_in_percent = -1.0;
  double efficiency_in_bytes_per_us = -1.0;
  double efficiency_cpp_in_bytes_per_us = -1.0;
  double main_thread_efficiency_in_bytes_per_us = -1.0;
  double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
};

struct GarbageCollectionFullMainThreadIncrementalMark {
  int64_t wall_clock_duration_in_us = -1;
  int64_t cpp_wall_clock_duration_in_us = -1;
};

struct GarbageCollectionFullMainThreadIncrementalSweep {
  int64_t wall_clock_duration_in_us = -1;
  int64_t cpp_wall_clock_duration_in_us = -1;
};

template <typename EventType>
struct GarbageCollectionBatchedEvents {
  std::vector<EventType> events;
};

using GarbageCollectionFullMainThreadBatchedIncrementalMark =
    GarbageCollectionBatchedEvents<
        GarbageCollectionFullMainThreadIncrementalMark>;
using GarbageCollectionFullMainThreadBatchedIncrementalSweep =
    GarbageCollectionBatchedEvents<
        GarbageCollectionFullMainThreadIncrementalSweep>;

struct GarbageCollectionYoungCycle {
  int reason = -1;
  int64_t total_wall_clock_duration_in_us = -1;
  int64_t main_thread_wall_clock_duration_in_us = -1;
  double collection_rate_in_percent = -1.0;
  double efficiency_in_bytes_per_us = -1.0;
  double main_thread_efficiency_in_bytes_per_us = -1.0;
#if defined(CPPGC_YOUNG_GENERATION)
  GarbageCollectionPhases total_cpp;
  GarbageCollectionSizes objects_cpp;
  GarbageCollectionSizes memory_cpp;
  double collection_rate_cpp_in_percent = -1.0;
  double efficiency_cpp_in_bytes_per_us = -1.0;
  double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
#endif  // defined(CPPGC_YOUNG_GENERATION)
};

struct WasmModuleDecoded {
  bool async = false;
  bool streamed = false;
  bool success = false;
  size_t module_size_in_bytes = 0;
  size_t function_count = 0;
  int64_t wall_clock_duration_in_us = -1;
  int64_t cpu_duration_in_us = -1;
};

struct WasmModuleCompiled {
  bool async = false;
  bool streamed = false;
  bool cached = false;
  bool deserialized = false;
  bool lazy = false;
  bool success = false;
  size_t code_size_in_bytes = 0;
  size_t liftoff_bailout_count = 0;
  int64_t wall_clock_duration_in_us = -1;
  int64_t cpu_duration_in_us = -1;
};

struct WasmModuleInstantiated {
  bool async = false;
  bool success = false;
  size_t imported_function_count = 0;
  int64_t wall_clock_duration_in_us = -1;
};

struct WasmModuleTieredUp {
  bool lazy = false;
  size_t code_size_in_bytes = 0;
  int64_t wall_clock_duration_in_us = -1;
  int64_t cpu_duration_in_us = -1;
};

struct WasmModulesPerIsolate {
  size_t count = 0;
};

#define V8_MAIN_THREAD_METRICS_EVENTS(V)                    \
  V(GarbageCollectionFullCycle)                             \
  V(GarbageCollectionFullMainThreadIncrementalMark)         \
  V(GarbageCollectionFullMainThreadBatchedIncrementalMark)  \
  V(GarbageCollectionFullMainThreadIncrementalSweep)        \
  V(GarbageCollectionFullMainThreadBatchedIncrementalSweep) \
  V(GarbageCollectionYoungCycle)                            \
  V(WasmModuleDecoded)                                      \
  V(WasmModuleCompiled)                                     \
  V(WasmModuleInstantiated)                                 \
  V(WasmModuleTieredUp)

#define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)

/**
 * This class serves as a base class for recording event-based metrics in V8.
 * There a two kinds of metrics, those which are expected to be thread-safe and
 * whose implementation is required to fulfill this requirement and those whose
 * implementation does not have that requirement and only needs to be
 * executable on the main thread. If such an event is triggered from a
 * background thread, it will be delayed and executed by the foreground task
 * runner.
 *
 * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
 * macro above while the main thread event are listed in
 * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
 * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
 * generated and for the latter AddThreadSafeEvent(const E& event).
 *
 * Thread-safe events are not allowed to access the context and therefore do
 * not carry a context ID with them. These IDs can be generated using
 * Recorder::GetContextId() and the ID will be valid throughout the lifetime
 * of the isolate. It is not guaranteed that the ID will still resolve to
 * a valid context using Recorder::GetContext() at the time the metric is
 * recorded. In this case, an empty handle will be returned.
 *
 * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
 * providing its implementation and have the virtual methods overwritten
 * for the events it cares about.
 */
class V8_EXPORT Recorder {
 public:
  // A unique identifier for a context in this Isolate.
  // It is guaranteed to not be reused throughout the lifetime of the Isolate.
  class ContextId {
   public:
    ContextId() : id_(kEmptyId) {}

bool IsEmpty() const { return id_ == kEmptyId; }
    static const ContextId Empty() { return ContextId{kEmptyId}; }

bool operator==(const ContextId& other) const { return id_ == other.id_; }
    bool operator!=(const ContextId& other) const { return id_ != other.id_; }

private:
    friend class ::v8::Context;
    friend class ::v8::internal::Isolate;

explicit ContextId(uintptr_t id) : id_(id) {}

static constexpr uintptr_t kEmptyId = 0;
    uintptr_t id_;
  };

virtual ~Recorder() = default;

#define ADD_MAIN_THREAD_EVENT(E) \
  virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
  V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
#undef ADD_MAIN_THREAD_EVENT

#define ADD_THREAD_SAFE_EVENT(E) \
  virtual void AddThreadSafeEvent(const E& event) {}
  V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
#undef ADD_THREAD_SAFE_EVENT

virtual void NotifyIsolateDisposal() {}

// Return the context with the given id or an empty handle if the context
  // was already garbage collected.
  static MaybeLocal<Context> GetContext(Isolate* isolate, ContextId id);
  // Return the unique id corresponding to the given context.
  static ContextId GetContextId(Local<Context> context);
};

/**
 * Experimental API intended for the LongTasks UKM (crbug.com/1173527).
 * The Reset() method should be called at the start of a potential
 * long task. The Get() method returns durations of V8 work that
 * happened during the task.
 *
 * This API is experimental and may be removed/changed in the future.
 */
struct V8_EXPORT LongTaskStats {
  /**
   * Resets durations of V8 work for the new task.
   */
  V8_INLINE static void Reset(Isolate* isolate) {
    v8::internal::Internals::IncrementLongTasksStatsCounter(isolate);
  }

/**
   * Returns durations of V8 work that happened since the last Reset().
   */
  static LongTaskStats Get(Isolate* isolate);

int64_t gc_full_atomic_wall_clock_duration_us = 0;
  int64_t gc_full_incremental_wall_clock_duration_us = 0;
  int64_t gc_young_wall_clock_duration_us = 0;
  // Only collected with --slow-histograms
  int64_t v8_execute_us = 0;
};

}  // namespace metrics
}  // namespace v8

#endif  // V8_METRICS_H_