Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/node/v8-statistics.h

$ cat -n /usr/include/node/v8-statistics.h

     1	// Copyright 2021 the V8 project authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style license that can be
     3	// found in the LICENSE file.
     4	
     5	#ifndef INCLUDE_V8_STATISTICS_H_
     6	#define INCLUDE_V8_STATISTICS_H_
     7	
     8	#include <stddef.h>
     9	#include <stdint.h>
    10	
    11	#include <memory>
    12	#include <utility>
    13	#include <vector>
    14	
    15	#include "v8-local-handle.h"  // NOLINT(build/include_directory)
    16	#include "v8-memory-span.h"   // NOLINT(build/include_directory)
    17	#include "v8-promise.h"       // NOLINT(build/include_directory)
    18	#include "v8config.h"         // NOLINT(build/include_directory)
    19	
    20	namespace v8 {
    21	
    22	class Context;
    23	class Isolate;
    24	
    25	namespace internal {
    26	class ReadOnlyHeap;
    27	}  // namespace internal
    28	
    29	/**
    30	 * Controls how the default MeasureMemoryDelegate reports the result of
    31	 * the memory measurement to JS. With kSummary only the total size is reported.
    32	 * With kDetailed the result includes the size of each native context.
    33	 */
    34	enum class MeasureMemoryMode { kSummary, kDetailed };
    35	
    36	/**
    37	 * Controls how promptly a memory measurement request is executed.
    38	 * By default the measurement is folded with the next scheduled GC which may
    39	 * happen after a while and is forced after some timeout.
    40	 * The kEager mode starts incremental GC right away and is useful for testing.
    41	 * The kLazy mode does not force GC.
    42	 */
    43	enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
    44	
    45	/**
    46	 * The delegate is used in Isolate::MeasureMemory API.
    47	 *
    48	 * It specifies the contexts that need to be measured and gets called when
    49	 * the measurement is completed to report the results.
    50	 *
    51	 * Both MeasurementComplete() callbacks will be invoked on completion.
    52	 * Each implementation of this class should hence implement only one of them,
    53	 * and leave the other empty.
    54	 */
    55	class V8_EXPORT MeasureMemoryDelegate {
    56	 public:
    57	  virtual ~MeasureMemoryDelegate() = default;
    58	
    59	  /**
    60	   * Returns true if the size of the given context needs to be measured.
    61	   */
    62	  virtual bool ShouldMeasure(Local<Context> context) = 0;
    63	
    64	  /** Holds the result of a memory measurement request. */
    65	  struct Result {
    66	    /**
    67	     * Two spans of equal length: the first includes each context for which
    68	     * ShouldMeasure returned true and that was not garbage collected while
    69	     * the memory measurement was in progress; the second includes the size
    70	     * of the respective context.
    71	     */
    72	    const MemorySpan<const Local<Context>>& contexts;
    73	    const MemorySpan<const size_t>& sizes_in_bytes;
    74	
    75	    /**
    76	     * Total size of objects that were not attributed to any context (i.e. are
    77	     * likely shared objects).
    78	     */
    79	    size_t unattributed_size_in_bytes;
    80	
    81	    /** Total size of generated code for Wasm (shared across contexts). */
    82	    size_t wasm_code_size_in_bytes;
    83	
    84	    /** Total size of Wasm metadata (except code; shared across contexts). */
    85	    size_t wasm_metadata_size_in_bytes;
    86	  };
    87	
    88	  /**
    89	   * This function is called when memory measurement finishes.
    90	   *
    91	   * \param result the result of the measurement.
    92	   */
    93	  virtual void MeasurementComplete(Result result) {}
    94	
    95	  /**
    96	   * Returns a default delegate that resolves the given promise when
    97	   * the memory measurement completes.
    98	   *
    99	   * \param isolate the current isolate
   100	   * \param context the current context
   101	   * \param promise_resolver the promise resolver that is given the
   102	   *   result of the memory measurement.
   103	   * \param mode the detail level of the result.
   104	   */
   105	  static std::unique_ptr<MeasureMemoryDelegate> Default(
   106	      Isolate* isolate, Local<Context> context,
   107	      Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
   108	};
   109	
   110	/**
   111	 * Collection of shared per-process V8 memory information.
   112	 *
   113	 * Instances of this class can be passed to
   114	 * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8.
   115	 */
   116	class V8_EXPORT SharedMemoryStatistics {
   117	 public:
   118	  SharedMemoryStatistics();
   119	  size_t read_only_space_size() { return read_only_space_size_; }
   120	  size_t read_only_space_used_size() { return read_only_space_used_size_; }
   121	  size_t read_only_space_physical_size() {
   122	    return read_only_space_physical_size_;
   123	  }
   124	
   125	 private:
   126	  size_t read_only_space_size_;
   127	  size_t read_only_space_used_size_;
   128	  size_t read_only_space_physical_size_;
   129	
   130	  friend class V8;
   131	  friend class internal::ReadOnlyHeap;
   132	};
   133	
   134	/**
   135	 * Collection of V8 heap information.
   136	 *
   137	 * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to
   138	 * get heap statistics from V8.
   139	 */
   140	class V8_EXPORT HeapStatistics {
   141	 public:
   142	  HeapStatistics();
   143	  size_t total_heap_size() { return total_heap_size_; }
   144	  size_t total_heap_size_executable() { return total_heap_size_executable_; }
   145	  size_t total_physical_size() { return total_physical_size_; }
   146	  size_t total_available_size() { return total_available_size_; }
   147	  size_t total_global_handles_size() { return total_global_handles_size_; }
   148	  size_t used_global_handles_size() { return used_global_handles_size_; }
   149	  size_t used_heap_size() { return used_heap_size_; }
   150	  size_t heap_size_limit() { return heap_size_limit_; }
   151	  size_t malloced_memory() { return malloced_memory_; }
   152	  size_t external_memory() { return external_memory_; }
   153	  size_t peak_malloced_memory() { return peak_malloced_memory_; }
   154	  size_t number_of_native_contexts() { return number_of_native_contexts_; }
   155	  size_t number_of_detached_contexts() { return number_of_detached_contexts_; }
   156	
   157	  /**
   158	   * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap
   159	   * garbage with a bit pattern.
   160	   */
   161	  size_t does_zap_garbage() { return does_zap_garbage_; }
   162	
   163	 private:
   164	  size_t total_heap_size_;
   165	  size_t total_heap_size_executable_;
   166	  size_t total_physical_size_;
   167	  size_t total_available_size_;
   168	  size_t used_heap_size_;
   169	  size_t heap_size_limit_;
   170	  size_t malloced_memory_;
   171	  size_t external_memory_;
   172	  size_t peak_malloced_memory_;
   173	  bool does_zap_garbage_;
   174	  size_t number_of_native_contexts_;
   175	  size_t number_of_detached_contexts_;
   176	  size_t total_global_handles_size_;
   177	  size_t used_global_handles_size_;
   178	
   179	  friend class V8;
   180	  friend class Isolate;
   181	};
   182	
   183	class V8_EXPORT HeapSpaceStatistics {
   184	 public:
   185	  HeapSpaceStatistics();
   186	  const char* space_name() { return space_name_; }
   187	  size_t space_size() { return space_size_; }
   188	  size_t space_used_size() { return space_used_size_; }
   189	  size_t space_available_size() { return space_available_size_; }
   190	  size_t physical_space_size() { return physical_space_size_; }
   191	
   192	 private:
   193	  const char* space_name_;
   194	  size_t space_size_;
   195	  size_t space_used_size_;
   196	  size_t space_available_size_;
   197	  size_t physical_space_size_;
   198	
   199	  friend class Isolate;
   200	};
   201	
   202	class V8_EXPORT HeapObjectStatistics {
   203	 public:
   204	  HeapObjectStatistics();
   205	  const char* object_type() { return object_type_; }
   206	  const char* object_sub_type() { return object_sub_type_; }
   207	  size_t object_count() { return object_count_; }
   208	  size_t object_size() { return object_size_; }
   209	
   210	 private:
   211	  const char* object_type_;
   212	  const char* object_sub_type_;
   213	  size_t object_count_;
   214	  size_t object_size_;
   215	
   216	  friend class Isolate;
   217	};
   218	
   219	class V8_EXPORT HeapCodeStatistics {
   220	 public:
   221	  HeapCodeStatistics();
   222	  size_t code_and_metadata_size() { return code_and_metadata_size_; }
   223	  size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
   224	  size_t external_script_source_size() { return external_script_source_size_; }
   225	  size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }
   226	
   227	 private:
   228	  size_t code_and_metadata_size_;
   229	  size_t bytecode_and_metadata_size_;
   230	  size_t external_script_source_size_;
   231	  size_t cpu_profiler_metadata_size_;
   232	
   233	  friend class Isolate;
   234	};
   235	
   236	}  // namespace v8
   237	
   238	#endif  // INCLUDE_V8_STATISTICS_H_
Welcome to MyWebUniversity on June 30, 2025.
