v8-statistics.h

Go to the documentation of this file.

// 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
 
enum class MeasureMemoryMode { kSummary, kDetailed };
 
enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
 
class V8_EXPORT MeasureMemoryDelegate {
 public:
  virtual ~MeasureMemoryDelegate() = default;
 
  virtual bool ShouldMeasure(Local<Context> context) = 0;
 
  struct Result {
    const MemorySpan<const Local<Context>>& contexts;
    const MemorySpan<const size_t>& sizes_in_bytes;
 
    size_t unattributed_size_in_bytes;
 
    size_t wasm_code_size_in_bytes;
 
    size_t wasm_metadata_size_in_bytes;
  };
 
  virtual void MeasurementComplete(Result result) {}
 
  static std::unique_ptr<MeasureMemoryDelegate> Default(
      Isolate* isolate, Local<Context> context,
      Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
};
 
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;
};
 
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_; }
 
  uint64_t total_allocated_bytes() { return total_allocated_bytes_; }
 
  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_;
  uint64_t total_allocated_bytes_;
 
  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_