v8 10.2.154 (node 18.16.0)
V8 is Google's open source JavaScript engine
Loading...
Searching...
No Matches
v8-statistics.h
Go to the documentation of this file.
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-promise.h" // NOLINT(build/include_directory)
17#include "v8config.h" // NOLINT(build/include_directory)
18
19namespace v8 {
20
21class Context;
22class Isolate;
23
24namespace internal {
25class ReadOnlyHeap;
26} // namespace internal
27
34
43
51 public:
52 virtual ~MeasureMemoryDelegate() = default;
53
57 virtual bool ShouldMeasure(Local<Context> context) = 0;
58
69 virtual void MeasurementComplete(
70 const std::vector<std::pair<Local<Context>, size_t>>&
71 context_sizes_in_bytes,
72 size_t unattributed_size_in_bytes) = 0;
73
84 static std::unique_ptr<MeasureMemoryDelegate> Default(
85 Isolate* isolate, Local<Context> context,
86 Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
87};
88
96 public:
98 size_t read_only_space_size() { return read_only_space_size_; }
99 size_t read_only_space_used_size() { return read_only_space_used_size_; }
101 return read_only_space_physical_size_;
102 }
103
104 private:
105 size_t read_only_space_size_;
106 size_t read_only_space_used_size_;
107 size_t read_only_space_physical_size_;
108
109 friend class V8;
110 friend class internal::ReadOnlyHeap;
111};
112
120 public:
122 size_t total_heap_size() { return total_heap_size_; }
123 size_t total_heap_size_executable() { return total_heap_size_executable_; }
124 size_t total_physical_size() { return total_physical_size_; }
125 size_t total_available_size() { return total_available_size_; }
126 size_t total_global_handles_size() { return total_global_handles_size_; }
127 size_t used_global_handles_size() { return used_global_handles_size_; }
128 size_t used_heap_size() { return used_heap_size_; }
129 size_t heap_size_limit() { return heap_size_limit_; }
130 size_t malloced_memory() { return malloced_memory_; }
131 size_t external_memory() { return external_memory_; }
132 size_t peak_malloced_memory() { return peak_malloced_memory_; }
133 size_t number_of_native_contexts() { return number_of_native_contexts_; }
134 size_t number_of_detached_contexts() { return number_of_detached_contexts_; }
135
140 size_t does_zap_garbage() { return does_zap_garbage_; }
141
142 private:
143 size_t total_heap_size_;
144 size_t total_heap_size_executable_;
145 size_t total_physical_size_;
146 size_t total_available_size_;
147 size_t used_heap_size_;
148 size_t heap_size_limit_;
149 size_t malloced_memory_;
150 size_t external_memory_;
151 size_t peak_malloced_memory_;
152 bool does_zap_garbage_;
153 size_t number_of_native_contexts_;
154 size_t number_of_detached_contexts_;
155 size_t total_global_handles_size_;
156 size_t used_global_handles_size_;
157
158 friend class V8;
159 friend class Isolate;
160};
161
163 public:
165 const char* space_name() { return space_name_; }
166 size_t space_size() { return space_size_; }
167 size_t space_used_size() { return space_used_size_; }
168 size_t space_available_size() { return space_available_size_; }
169 size_t physical_space_size() { return physical_space_size_; }
170
171 private:
172 const char* space_name_;
173 size_t space_size_;
174 size_t space_used_size_;
175 size_t space_available_size_;
176 size_t physical_space_size_;
177
178 friend class Isolate;
179};
180
182 public:
184 const char* object_type() { return object_type_; }
185 const char* object_sub_type() { return object_sub_type_; }
186 size_t object_count() { return object_count_; }
187 size_t object_size() { return object_size_; }
188
189 private:
190 const char* object_type_;
191 const char* object_sub_type_;
192 size_t object_count_;
193 size_t object_size_;
194
195 friend class Isolate;
196};
197
199 public:
201 size_t code_and_metadata_size() { return code_and_metadata_size_; }
202 size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
203 size_t external_script_source_size() { return external_script_source_size_; }
204 size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }
205
206 private:
207 size_t code_and_metadata_size_;
208 size_t bytecode_and_metadata_size_;
209 size_t external_script_source_size_;
210 size_t cpu_profiler_metadata_size_;
211
212 friend class Isolate;
213};
214
215} // namespace v8
216
217#endif // INCLUDE_V8_STATISTICS_H_
size_t bytecode_and_metadata_size()
size_t external_script_source_size()
size_t cpu_profiler_metadata_size()
const char * object_sub_type()
const char * space_name()
size_t total_heap_size_executable()
size_t number_of_detached_contexts()
size_t peak_malloced_memory()
size_t number_of_native_contexts()
size_t used_global_handles_size()
size_t total_global_handles_size()
size_t total_available_size()
size_t total_physical_size()
virtual bool ShouldMeasure(Local< Context > context)=0
static std::unique_ptr< MeasureMemoryDelegate > Default(Isolate *isolate, Local< Context > context, Local< Promise::Resolver > promise_resolver, MeasureMemoryMode mode)
virtual void MeasurementComplete(const std::vector< std::pair< Local< Context >, size_t > > &context_sizes_in_bytes, size_t unattributed_size_in_bytes)=0
virtual ~MeasureMemoryDelegate()=default
MeasureMemoryExecution
MeasureMemoryMode
#define V8_EXPORT
Definition v8config.h:578