Mr.X

// 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 INCLUDE_V8_STATISTICS_H_
#define INCLUDE_V8_STATISTICS_H_

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

#include <memory>
#include <utility>
#include <vector>

#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-memory-span.h"   // NOLINT(build/include_directory)
#include "v8-promise.h"       // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)

namespace v8 {

class Context;
class Isolate;

namespace internal {
class ReadOnlyHeap;
}  // namespace internal

/**
 * Controls how the default MeasureMemoryDelegate reports the result of
 * the memory measurement to JS. With kSummary only the total size is reported.
 * With kDetailed the result includes the size of each native context.
 */
enum class MeasureMemoryMode { kSummary, kDetailed };

/**
 * Controls how promptly a memory measurement request is executed.
 * By default the measurement is folded with the next scheduled GC which may
 * happen after a while and is forced after some timeout.
 * The kEager mode starts incremental GC right away and is useful for testing.
 * The kLazy mode does not force GC.
 */
enum class MeasureMemoryExecution { kDefault, kEager, kLazy };

/**
 * The delegate is used in Isolate::MeasureMemory API.
 *
 * It specifies the contexts that need to be measured and gets called when
 * the measurement is completed to report the results.
 *
 * Both MeasurementComplete() callbacks will be invoked on completion.
 * Each implementation of this class should hence implement only one of them,
 * and leave the other empty.
 */
class V8_EXPORT MeasureMemoryDelegate {
 public:
  virtual ~MeasureMemoryDelegate() = default;

  /**
   * Returns true if the size of the given context needs to be measured.
   */
  virtual bool ShouldMeasure(Local<Context> context) = 0;

  /** Holds the result of a memory measurement request. */
  struct Result {
    /**
     * Two spans of equal length: the first includes each context for which
     * ShouldMeasure returned true and that was not garbage collected while
     * the memory measurement was in progress; the second includes the size
     * of the respective context.
     */
    const MemorySpan<const Local<Context>>& contexts;
    const MemorySpan<const size_t>& sizes_in_bytes;

    /**
     * Total size of objects that were not attributed to any context (i.e. are
     * likely shared objects).
     */
    size_t unattributed_size_in_bytes;

    /** Total size of generated code for Wasm (shared across contexts). */
    size_t wasm_code_size_in_bytes;

    /** Total size of Wasm metadata (except code; shared across contexts). */
    size_t wasm_metadata_size_in_bytes;
  };

  /**
   * This function is called when memory measurement finishes.
   *
   * \param result the result of the measurement.
   */
  virtual void MeasurementComplete(Result result) {}

  /**
   * Returns a default delegate that resolves the given promise when
   * the memory measurement completes.
   *
   * \param isolate the current isolate
   * \param context the current context
   * \param promise_resolver the promise resolver that is given the
   *   result of the memory measurement.
   * \param mode the detail level of the result.
   */
  static std::unique_ptr<MeasureMemoryDelegate> Default(
      Isolate* isolate, Local<Context> context,
      Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
};

/**
 * Collection of shared per-process V8 memory information.
 *
 * Instances of this class can be passed to
 * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8.
 */
class V8_EXPORT SharedMemoryStatistics {
 public:
  SharedMemoryStatistics();
  size_t read_only_space_size() { return read_only_space_size_; }
  size_t read_only_space_used_size() { return read_only_space_used_size_; }
  size_t read_only_space_physical_size() {
    return read_only_space_physical_size_;
  }

 private:
  size_t read_only_space_size_;
  size_t read_only_space_used_size_;
  size_t read_only_space_physical_size_;

  friend class V8;
  friend class internal::ReadOnlyHeap;
};

/**
 * Collection of V8 heap information.
 *
 * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to
 * get heap statistics from V8.
 */
class V8_EXPORT HeapStatistics {
 public:
  HeapStatistics();
  size_t total_heap_size() { return total_heap_size_; }
  size_t total_heap_size_executable() { return total_heap_size_executable_; }
  size_t total_physical_size() { return total_physical_size_; }
  size_t total_available_size() { return total_available_size_; }
  size_t total_global_handles_size() { return total_global_handles_size_; }
  size_t used_global_handles_size() { return used_global_handles_size_; }
  size_t used_heap_size() { return used_heap_size_; }
  size_t heap_size_limit() { return heap_size_limit_; }
  size_t malloced_memory() { return malloced_memory_; }
  size_t external_memory() { return external_memory_; }
  size_t peak_malloced_memory() { return peak_malloced_memory_; }
  size_t number_of_native_contexts() { return number_of_native_contexts_; }
  size_t number_of_detached_contexts() { return number_of_detached_contexts_; }

  /**
   * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap
   * garbage with a bit pattern.
   */
  size_t does_zap_garbage() { return does_zap_garbage_; }

 private:
  size_t total_heap_size_;
  size_t total_heap_size_executable_;
  size_t total_physical_size_;
  size_t total_available_size_;
  size_t used_heap_size_;
  size_t heap_size_limit_;
  size_t malloced_memory_;
  size_t external_memory_;
  size_t peak_malloced_memory_;
  bool does_zap_garbage_;
  size_t number_of_native_contexts_;
  size_t number_of_detached_contexts_;
  size_t total_global_handles_size_;
  size_t used_global_handles_size_;

  friend class V8;
  friend class Isolate;
};

class V8_EXPORT HeapSpaceStatistics {
 public:
  HeapSpaceStatistics();
  const char* space_name() { return space_name_; }
  size_t space_size() { return space_size_; }
  size_t space_used_size() { return space_used_size_; }
  size_t space_available_size() { return space_available_size_; }
  size_t physical_space_size() { return physical_space_size_; }

 private:
  const char* space_name_;
  size_t space_size_;
  size_t space_used_size_;
  size_t space_available_size_;
  size_t physical_space_size_;

  friend class Isolate;
};

class V8_EXPORT HeapObjectStatistics {
 public:
  HeapObjectStatistics();
  const char* object_type() { return object_type_; }
  const char* object_sub_type() { return object_sub_type_; }
  size_t object_count() { return object_count_; }
  size_t object_size() { return object_size_; }

 private:
  const char* object_type_;
  const char* object_sub_type_;
  size_t object_count_;
  size_t object_size_;

  friend class Isolate;
};

class V8_EXPORT HeapCodeStatistics {
 public:
  HeapCodeStatistics();
  size_t code_and_metadata_size() { return code_and_metadata_size_; }
  size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
  size_t external_script_source_size() { return external_script_source_size_; }
  size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }

 private:
  size_t code_and_metadata_size_;
  size_t bytecode_and_metadata_size_;
  size_t external_script_source_size_;
  size_t cpu_profiler_metadata_size_;

  friend class Isolate;
};

}  // namespace v8

#endif  // INCLUDE_V8_STATISTICS_H_

Name	Type	Size	Permission
cppgc	Folder		0755
libplatform	Folder		0755
openssl	Folder		0755
uv	Folder		0755
common.gypi	File	26.59 KB	0644
config.gypi	File	32.08 KB	0644
js_native_api.h	File	31.64 KB	0644
js_native_api_types.h	File	6.87 KB	0644
node.h	File	67.99 KB	0644
node_api.h	File	10.34 KB	0644
node_api_types.h	File	1.57 KB	0644
node_buffer.h	File	3.6 KB	0644
node_object_wrap.h	File	3.78 KB	0644
node_version.h	File	4.14 KB	0644
uv.h	File	71.1 KB	0644
v8-array-buffer.h	File	17.89 KB	0644
v8-callbacks.h	File	16.59 KB	0644
v8-container.h	File	5.82 KB	0644
v8-context.h	File	17.76 KB	0644
v8-cppgc.h	File	7.46 KB	0644
v8-data.h	File	1.58 KB	0644
v8-date.h	File	1.19 KB	0644
v8-debug.h	File	5.04 KB	0644
v8-embedder-heap.h	File	2.71 KB	0644
v8-embedder-state-scope.h	File	1.46 KB	0644
v8-exception.h	File	7.41 KB	0644
v8-extension.h	File	1.83 KB	0644
v8-external.h	File	924 B	0644
v8-forward.h	File	1.65 KB	0644
v8-function-callback.h	File	19.19 KB	0644
v8-function.h	File	4.42 KB	0644
v8-handle-base.h	File	4.3 KB	0644
v8-initialization.h	File	10.23 KB	0644
v8-internal.h	File	57.22 KB	0644
v8-isolate.h	File	63.38 KB	0644
v8-json.h	File	1.32 KB	0644
v8-local-handle.h	File	23.6 KB	0644
v8-locker.h	File	3.86 KB	0644
v8-maybe.h	File	4.47 KB	0644
v8-memory-span.h	File	6.27 KB	0644
v8-message.h	File	7.24 KB	0644
v8-microtask-queue.h	File	4.95 KB	0644
v8-microtask.h	File	861 B	0644
v8-object.h	File	29.55 KB	0644
v8-persistent-handle.h	File	17.81 KB	0644
v8-platform.h	File	47.9 KB	0644
v8-primitive-object.h	File	2.53 KB	0644
v8-primitive.h	File	27.69 KB	0644
v8-profiler.h	File	41.11 KB	0644
v8-promise.h	File	5.17 KB	0644
v8-proxy.h	File	1.23 KB	0644
v8-regexp.h	File	3.1 KB	0644
v8-script.h	File	30.59 KB	0644
v8-snapshot.h	File	10.15 KB	0644
v8-source-location.h	File	2.54 KB	0644
v8-statistics.h	File	7.45 KB	0644
v8-template.h	File	50.36 KB	0644
v8-traced-handle.h	File	12.4 KB	0644
v8-typed-array.h	File	11.3 KB	0644
v8-unwinder.h	File	4.64 KB	0644
v8-value-serializer.h	File	10.56 KB	0644
v8-value.h	File	16.71 KB	0644
v8-version.h	File	773 B	0644
v8-wasm.h	File	6 KB	0644
v8-weak-callback-info.h	File	2.41 KB	0644
v8.h	File	3.69 KB	0644
v8config.h	File	32.85 KB	0644
zconf.h	File	16.6 KB	0644
zlib.h	File	95.17 KB	0644

Upload:

Command:

Filemanager

Server Info

System Info

User Info