libv8-node 15.14.0.1-x86_64-linux → 16.10.0.0-x86_64-linux
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/ext/libv8-node/location.rb +1 -1
- data/ext/libv8-node/paths.rb +1 -1
- data/lib/libv8/node/version.rb +3 -3
- data/vendor/v8/include/cppgc/allocation.h +104 -45
- data/vendor/v8/include/cppgc/common.h +9 -6
- data/vendor/v8/include/cppgc/cross-thread-persistent.h +384 -0
- data/vendor/v8/include/cppgc/custom-space.h +37 -2
- data/vendor/v8/include/cppgc/default-platform.h +47 -48
- data/vendor/v8/include/cppgc/ephemeron-pair.h +30 -0
- data/vendor/v8/include/cppgc/explicit-management.h +82 -0
- data/vendor/v8/include/cppgc/garbage-collected.h +4 -3
- data/vendor/v8/include/cppgc/heap-consistency.h +236 -0
- data/vendor/v8/include/cppgc/heap-state.h +70 -0
- data/vendor/v8/include/cppgc/heap-statistics.h +120 -0
- data/vendor/v8/include/cppgc/heap.h +68 -6
- data/vendor/v8/include/cppgc/internal/api-constants.h +3 -3
- data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -1
- data/vendor/v8/include/cppgc/internal/compiler-specific.h +2 -2
- data/vendor/v8/include/cppgc/internal/gc-info.h +44 -13
- data/vendor/v8/include/cppgc/internal/name-trait.h +111 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +57 -1
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +69 -28
- data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +1 -1
- data/vendor/v8/include/cppgc/internal/write-barrier.h +353 -35
- data/vendor/v8/include/cppgc/liveness-broker.h +7 -1
- data/vendor/v8/include/cppgc/macros.h +2 -0
- data/vendor/v8/include/cppgc/member.h +85 -25
- data/vendor/v8/include/cppgc/name-provider.h +65 -0
- data/vendor/v8/include/cppgc/object-size-trait.h +58 -0
- data/vendor/v8/include/cppgc/persistent.h +33 -9
- data/vendor/v8/include/cppgc/platform.h +48 -25
- data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
- data/vendor/v8/include/cppgc/process-heap-statistics.h +36 -0
- data/vendor/v8/include/cppgc/sentinel-pointer.h +32 -0
- data/vendor/v8/include/cppgc/source-location.h +2 -1
- data/vendor/v8/include/cppgc/testing.h +99 -0
- data/vendor/v8/include/cppgc/trace-trait.h +8 -3
- data/vendor/v8/include/cppgc/type-traits.h +157 -19
- data/vendor/v8/include/cppgc/visitor.h +187 -23
- data/vendor/v8/include/libplatform/libplatform.h +11 -0
- data/vendor/v8/include/libplatform/v8-tracing.h +2 -0
- data/vendor/v8/include/v8-cppgc.h +258 -159
- data/vendor/v8/include/v8-fast-api-calls.h +562 -159
- data/vendor/v8/include/v8-inspector.h +23 -2
- data/vendor/v8/include/v8-internal.h +99 -27
- data/vendor/v8/include/v8-metrics.h +77 -8
- data/vendor/v8/include/v8-platform.h +47 -22
- data/vendor/v8/include/v8-profiler.h +75 -11
- data/vendor/v8/include/v8-unwinder-state.h +30 -0
- data/vendor/v8/include/v8-util.h +1 -1
- data/vendor/v8/include/v8-version.h +4 -4
- data/vendor/v8/include/v8.h +1192 -642
- data/vendor/v8/include/v8config.h +40 -9
- data/vendor/v8/{out.gn → x86_64-linux}/libv8/obj/libv8_monolith.a +0 -0
- metadata +17 -5
- data/vendor/v8/include/cppgc/internal/process-heap.h +0 -34
@@ -0,0 +1,120 @@
|
|
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_CPPGC_HEAP_STATISTICS_H_
|
6
|
+
#define INCLUDE_CPPGC_HEAP_STATISTICS_H_
|
7
|
+
|
8
|
+
#include <cstddef>
|
9
|
+
#include <cstdint>
|
10
|
+
#include <string>
|
11
|
+
#include <vector>
|
12
|
+
|
13
|
+
namespace cppgc {
|
14
|
+
|
15
|
+
/**
|
16
|
+
* `HeapStatistics` contains memory consumption and utilization statistics for a
|
17
|
+
* cppgc heap.
|
18
|
+
*/
|
19
|
+
struct HeapStatistics final {
|
20
|
+
/**
|
21
|
+
* Specifies the detail level of the heap statistics. Brief statistics contain
|
22
|
+
* only the top-level allocated and used memory statistics for the entire
|
23
|
+
* heap. Detailed statistics also contain a break down per space and page, as
|
24
|
+
* well as freelist statistics and object type histograms. Note that used
|
25
|
+
* memory reported by brief statistics and detailed statistics might differ
|
26
|
+
* slightly.
|
27
|
+
*/
|
28
|
+
enum DetailLevel : uint8_t {
|
29
|
+
kBrief,
|
30
|
+
kDetailed,
|
31
|
+
};
|
32
|
+
|
33
|
+
/**
|
34
|
+
* Object statistics for a single type.
|
35
|
+
*/
|
36
|
+
struct ObjectStatsEntry {
|
37
|
+
/**
|
38
|
+
* Number of allocated bytes.
|
39
|
+
*/
|
40
|
+
size_t allocated_bytes;
|
41
|
+
/**
|
42
|
+
* Number of allocated objects.
|
43
|
+
*/
|
44
|
+
size_t object_count;
|
45
|
+
};
|
46
|
+
|
47
|
+
/**
|
48
|
+
* Page granularity statistics. For each page the statistics record the
|
49
|
+
* allocated memory size and overall used memory size for the page.
|
50
|
+
*/
|
51
|
+
struct PageStatistics {
|
52
|
+
/** Overall committed amount of memory for the page. */
|
53
|
+
size_t committed_size_bytes = 0;
|
54
|
+
/** Resident amount of memory held by the page. */
|
55
|
+
size_t resident_size_bytes = 0;
|
56
|
+
/** Amount of memory actually used on the page. */
|
57
|
+
size_t used_size_bytes = 0;
|
58
|
+
/** Statistics for object allocated on the page. Filled only when
|
59
|
+
* NameProvider::HideInternalNames() is false. */
|
60
|
+
std::vector<ObjectStatsEntry> object_statistics;
|
61
|
+
};
|
62
|
+
|
63
|
+
/**
|
64
|
+
* Statistics of the freelist (used only in non-large object spaces). For
|
65
|
+
* each bucket in the freelist the statistics record the bucket size, the
|
66
|
+
* number of freelist entries in the bucket, and the overall allocated memory
|
67
|
+
* consumed by these freelist entries.
|
68
|
+
*/
|
69
|
+
struct FreeListStatistics {
|
70
|
+
/** bucket sizes in the freelist. */
|
71
|
+
std::vector<size_t> bucket_size;
|
72
|
+
/** number of freelist entries per bucket. */
|
73
|
+
std::vector<size_t> free_count;
|
74
|
+
/** memory size consumed by freelist entries per size. */
|
75
|
+
std::vector<size_t> free_size;
|
76
|
+
};
|
77
|
+
|
78
|
+
/**
|
79
|
+
* Space granularity statistics. For each space the statistics record the
|
80
|
+
* space name, the amount of allocated memory and overall used memory for the
|
81
|
+
* space. The statistics also contain statistics for each of the space's
|
82
|
+
* pages, its freelist and the objects allocated on the space.
|
83
|
+
*/
|
84
|
+
struct SpaceStatistics {
|
85
|
+
/** The space name */
|
86
|
+
std::string name;
|
87
|
+
/** Overall committed amount of memory for the heap. */
|
88
|
+
size_t committed_size_bytes = 0;
|
89
|
+
/** Resident amount of memory held by the heap. */
|
90
|
+
size_t resident_size_bytes = 0;
|
91
|
+
/** Amount of memory actually used on the space. */
|
92
|
+
size_t used_size_bytes = 0;
|
93
|
+
/** Statistics for each of the pages in the space. */
|
94
|
+
std::vector<PageStatistics> page_stats;
|
95
|
+
/** Statistics for the freelist of the space. */
|
96
|
+
FreeListStatistics free_list_stats;
|
97
|
+
};
|
98
|
+
|
99
|
+
/** Overall committed amount of memory for the heap. */
|
100
|
+
size_t committed_size_bytes = 0;
|
101
|
+
/** Resident amount of memory help by the heap. */
|
102
|
+
size_t resident_size_bytes = 0;
|
103
|
+
/** Amount of memory actually used on the heap. */
|
104
|
+
size_t used_size_bytes = 0;
|
105
|
+
/** Detail level of this HeapStatistics. */
|
106
|
+
DetailLevel detail_level;
|
107
|
+
|
108
|
+
/** Statistics for each of the spaces in the heap. Filled only when
|
109
|
+
* `detail_level` is `DetailLevel::kDetailed`. */
|
110
|
+
std::vector<SpaceStatistics> space_stats;
|
111
|
+
|
112
|
+
/**
|
113
|
+
* Vector of `cppgc::GarbageCollected` type names.
|
114
|
+
*/
|
115
|
+
std::vector<std::string> type_names;
|
116
|
+
};
|
117
|
+
|
118
|
+
} // namespace cppgc
|
119
|
+
|
120
|
+
#endif // INCLUDE_CPPGC_HEAP_STATISTICS_H_
|
@@ -5,6 +5,8 @@
|
|
5
5
|
#ifndef INCLUDE_CPPGC_HEAP_H_
|
6
6
|
#define INCLUDE_CPPGC_HEAP_H_
|
7
7
|
|
8
|
+
#include <cstddef>
|
9
|
+
#include <cstdint>
|
8
10
|
#include <memory>
|
9
11
|
#include <vector>
|
10
12
|
|
@@ -29,6 +31,11 @@ namespace internal {
|
|
29
31
|
class Heap;
|
30
32
|
} // namespace internal
|
31
33
|
|
34
|
+
/**
|
35
|
+
* Used for additional heap APIs.
|
36
|
+
*/
|
37
|
+
class HeapHandle;
|
38
|
+
|
32
39
|
class V8_EXPORT Heap {
|
33
40
|
public:
|
34
41
|
/**
|
@@ -51,6 +58,41 @@ class V8_EXPORT Heap {
|
|
51
58
|
kNoConservativeStackScan,
|
52
59
|
};
|
53
60
|
|
61
|
+
/**
|
62
|
+
* Specifies supported marking types
|
63
|
+
*/
|
64
|
+
enum class MarkingType : uint8_t {
|
65
|
+
/**
|
66
|
+
* Atomic stop-the-world marking. This option does not require any write
|
67
|
+
* barriers but is the most intrusive in terms of jank.
|
68
|
+
*/
|
69
|
+
kAtomic,
|
70
|
+
/**
|
71
|
+
* Incremental marking, i.e. interleave marking is the rest of the
|
72
|
+
* application on the same thread.
|
73
|
+
*/
|
74
|
+
kIncremental,
|
75
|
+
/**
|
76
|
+
* Incremental and concurrent marking.
|
77
|
+
*/
|
78
|
+
kIncrementalAndConcurrent
|
79
|
+
};
|
80
|
+
|
81
|
+
/**
|
82
|
+
* Specifies supported sweeping types
|
83
|
+
*/
|
84
|
+
enum class SweepingType : uint8_t {
|
85
|
+
/**
|
86
|
+
* Atomic stop-the-world sweeping. All of sweeping is performed at once.
|
87
|
+
*/
|
88
|
+
kAtomic,
|
89
|
+
/**
|
90
|
+
* Incremental and concurrent sweeping. Sweeping is split and interleaved
|
91
|
+
* with the rest of the application.
|
92
|
+
*/
|
93
|
+
kIncrementalAndConcurrent
|
94
|
+
};
|
95
|
+
|
54
96
|
/**
|
55
97
|
* Constraints for a Heap setup.
|
56
98
|
*/
|
@@ -66,33 +108,43 @@ class V8_EXPORT Heap {
|
|
66
108
|
|
67
109
|
/**
|
68
110
|
* Options specifying Heap properties (e.g. custom spaces) when initializing a
|
69
|
-
* heap through Heap::Create()
|
111
|
+
* heap through `Heap::Create()`.
|
70
112
|
*/
|
71
113
|
struct HeapOptions {
|
72
114
|
/**
|
73
115
|
* Creates reasonable defaults for instantiating a Heap.
|
74
116
|
*
|
75
|
-
* \returns the HeapOptions that can be passed to Heap::Create()
|
117
|
+
* \returns the HeapOptions that can be passed to `Heap::Create()`.
|
76
118
|
*/
|
77
119
|
static HeapOptions Default() { return {}; }
|
78
120
|
|
79
121
|
/**
|
80
122
|
* Custom spaces added to heap are required to have indices forming a
|
81
|
-
* numbered sequence starting at 0, i.e., their kSpaceIndex must
|
82
|
-
* to the index they reside in the vector.
|
123
|
+
* numbered sequence starting at 0, i.e., their `kSpaceIndex` must
|
124
|
+
* correspond to the index they reside in the vector.
|
83
125
|
*/
|
84
126
|
std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
|
85
127
|
|
86
128
|
/**
|
87
|
-
* Specifies whether
|
129
|
+
* Specifies whether conservative stack scan is supported. When conservative
|
88
130
|
* stack scan is not supported, the collector may try to invoke
|
89
131
|
* garbage collections using non-nestable task, which are guaranteed to have
|
90
132
|
* no interesting stack, through the provided Platform. If such tasks are
|
91
133
|
* not supported by the Platform, the embedder must take care of invoking
|
92
|
-
* the GC through ForceGarbageCollectionSlow()
|
134
|
+
* the GC through `ForceGarbageCollectionSlow()`.
|
93
135
|
*/
|
94
136
|
StackSupport stack_support = StackSupport::kSupportsConservativeStackScan;
|
95
137
|
|
138
|
+
/**
|
139
|
+
* Specifies which types of marking are supported by the heap.
|
140
|
+
*/
|
141
|
+
MarkingType marking_support = MarkingType::kIncrementalAndConcurrent;
|
142
|
+
|
143
|
+
/**
|
144
|
+
* Specifies which types of sweeping are supported by the heap.
|
145
|
+
*/
|
146
|
+
SweepingType sweeping_support = SweepingType::kIncrementalAndConcurrent;
|
147
|
+
|
96
148
|
/**
|
97
149
|
* Resource constraints specifying various properties that the internal
|
98
150
|
* GC scheduler follows.
|
@@ -126,8 +178,18 @@ class V8_EXPORT Heap {
|
|
126
178
|
const char* source, const char* reason,
|
127
179
|
StackState stack_state = StackState::kMayContainHeapPointers);
|
128
180
|
|
181
|
+
/**
|
182
|
+
* \returns the opaque handle for allocating objects using
|
183
|
+
* `MakeGarbageCollected()`.
|
184
|
+
*/
|
129
185
|
AllocationHandle& GetAllocationHandle();
|
130
186
|
|
187
|
+
/**
|
188
|
+
* \returns the opaque heap handle which may be used to refer to this heap in
|
189
|
+
* other APIs. Valid as long as the underlying `Heap` is alive.
|
190
|
+
*/
|
191
|
+
HeapHandle& GetHeapHandle();
|
192
|
+
|
131
193
|
private:
|
132
194
|
Heap() = default;
|
133
195
|
|
@@ -5,8 +5,8 @@
|
|
5
5
|
#ifndef INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
|
6
6
|
#define INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
|
7
7
|
|
8
|
-
#include <
|
9
|
-
#include <
|
8
|
+
#include <cstddef>
|
9
|
+
#include <cstdint>
|
10
10
|
|
11
11
|
#include "v8config.h" // NOLINT(build/include_directory)
|
12
12
|
|
@@ -28,7 +28,7 @@ constexpr size_t kGB = kMB * 1024;
|
|
28
28
|
static constexpr size_t kFullyConstructedBitFieldOffsetFromPayload =
|
29
29
|
2 * sizeof(uint16_t);
|
30
30
|
// Mask for in-construction bit.
|
31
|
-
static constexpr
|
31
|
+
static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
|
32
32
|
|
33
33
|
static constexpr size_t kPageSize = size_t{1} << 17;
|
34
34
|
|
@@ -10,6 +10,7 @@
|
|
10
10
|
#include "cppgc/internal/api-constants.h"
|
11
11
|
#include "cppgc/internal/logging.h"
|
12
12
|
#include "cppgc/platform.h"
|
13
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
13
14
|
|
14
15
|
namespace cppgc {
|
15
16
|
namespace internal {
|
@@ -54,7 +55,7 @@ static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
|
|
54
55
|
struct CagedHeapLocalData final {
|
55
56
|
explicit CagedHeapLocalData(HeapBase* heap_base) : heap_base(heap_base) {}
|
56
57
|
|
57
|
-
bool
|
58
|
+
bool is_incremental_marking_in_progress = false;
|
58
59
|
HeapBase* heap_base = nullptr;
|
59
60
|
#if defined(CPPGC_YOUNG_GENERATION)
|
60
61
|
AgeTable age_table;
|
@@ -21,13 +21,13 @@ namespace cppgc {
|
|
21
21
|
|
22
22
|
// [[no_unique_address]] comes in C++20 but supported in clang with -std >=
|
23
23
|
// c++11.
|
24
|
-
#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
|
24
|
+
#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
|
25
25
|
#define CPPGC_NO_UNIQUE_ADDRESS [[no_unique_address]]
|
26
26
|
#else
|
27
27
|
#define CPPGC_NO_UNIQUE_ADDRESS
|
28
28
|
#endif
|
29
29
|
|
30
|
-
#if CPPGC_HAS_ATTRIBUTE(unused)
|
30
|
+
#if CPPGC_HAS_ATTRIBUTE(unused)
|
31
31
|
#define CPPGC_UNUSED __attribute__((unused))
|
32
32
|
#else
|
33
33
|
#define CPPGC_UNUSED
|
@@ -5,9 +5,12 @@
|
|
5
5
|
#ifndef INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
|
6
6
|
#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
|
7
7
|
|
8
|
-
#include <
|
8
|
+
#include <atomic>
|
9
|
+
#include <cstdint>
|
10
|
+
#include <type_traits>
|
9
11
|
|
10
12
|
#include "cppgc/internal/finalizer-trait.h"
|
13
|
+
#include "cppgc/internal/name-trait.h"
|
11
14
|
#include "cppgc/trace-trait.h"
|
12
15
|
#include "v8config.h" // NOLINT(build/include_directory)
|
13
16
|
|
@@ -16,26 +19,54 @@ namespace internal {
|
|
16
19
|
|
17
20
|
using GCInfoIndex = uint16_t;
|
18
21
|
|
19
|
-
|
20
|
-
|
21
|
-
|
22
|
-
|
23
|
-
|
22
|
+
// Acquires a new GC info object and returns the index. In addition, also
|
23
|
+
// updates `registered_index` atomically.
|
24
|
+
V8_EXPORT GCInfoIndex
|
25
|
+
EnsureGCInfoIndex(std::atomic<GCInfoIndex>& registered_index,
|
26
|
+
FinalizationCallback, TraceCallback, NameCallback, bool);
|
24
27
|
|
25
|
-
|
26
|
-
|
28
|
+
// Fold types based on finalizer behavior. Note that finalizer characteristics
|
29
|
+
// align with trace behavior, i.e., destructors are virtual when trace methods
|
30
|
+
// are and vice versa.
|
31
|
+
template <typename T, typename ParentMostGarbageCollectedType>
|
32
|
+
struct GCInfoFolding {
|
33
|
+
static constexpr bool kHasVirtualDestructorAtBase =
|
34
|
+
std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;
|
35
|
+
static constexpr bool kBothTypesAreTriviallyDestructible =
|
36
|
+
std::is_trivially_destructible<ParentMostGarbageCollectedType>::value &&
|
37
|
+
std::is_trivially_destructible<T>::value;
|
38
|
+
static constexpr bool kHasCustomFinalizerDispatchAtBase =
|
39
|
+
internal::HasFinalizeGarbageCollectedObject<
|
40
|
+
ParentMostGarbageCollectedType>::value;
|
41
|
+
#ifdef CPPGC_SUPPORTS_OBJECT_NAMES
|
42
|
+
static constexpr bool kWantsDetailedObjectNames = true;
|
43
|
+
#else // !CPPGC_SUPPORTS_OBJECT_NAMES
|
44
|
+
static constexpr bool kWantsDetailedObjectNames = false;
|
45
|
+
#endif // !CPPGC_SUPPORTS_OBJECT_NAMES
|
46
|
+
|
47
|
+
// Folding would regresses name resolution when deriving names from C++
|
48
|
+
// class names as it would just folds a name to the base class name.
|
49
|
+
using ResultType = std::conditional_t<(kHasVirtualDestructorAtBase ||
|
50
|
+
kBothTypesAreTriviallyDestructible ||
|
51
|
+
kHasCustomFinalizerDispatchAtBase) &&
|
52
|
+
!kWantsDetailedObjectNames,
|
53
|
+
ParentMostGarbageCollectedType, T>;
|
27
54
|
};
|
28
55
|
|
29
56
|
// Trait determines how the garbage collector treats objects wrt. to traversing,
|
30
57
|
// finalization, and naming.
|
31
58
|
template <typename T>
|
32
|
-
struct GCInfoTrait {
|
59
|
+
struct GCInfoTrait final {
|
33
60
|
static GCInfoIndex Index() {
|
34
61
|
static_assert(sizeof(T), "T must be fully defined");
|
35
|
-
static
|
36
|
-
|
37
|
-
|
38
|
-
return
|
62
|
+
static std::atomic<GCInfoIndex>
|
63
|
+
registered_index; // Uses zero initialization.
|
64
|
+
const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
|
65
|
+
return index ? index
|
66
|
+
: EnsureGCInfoIndex(
|
67
|
+
registered_index, FinalizerTrait<T>::kCallback,
|
68
|
+
TraceTrait<T>::Trace, NameTrait<T>::GetName,
|
69
|
+
std::is_polymorphic<T>::value);
|
39
70
|
}
|
40
71
|
};
|
41
72
|
|
@@ -0,0 +1,111 @@
|
|
1
|
+
// Copyright 2020 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_CPPGC_INTERNAL_NAME_TRAIT_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
|
7
|
+
|
8
|
+
#include <cstddef>
|
9
|
+
|
10
|
+
#include "cppgc/name-provider.h"
|
11
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
12
|
+
|
13
|
+
namespace cppgc {
|
14
|
+
namespace internal {
|
15
|
+
|
16
|
+
#if CPPGC_SUPPORTS_OBJECT_NAMES && defined(__clang__)
|
17
|
+
#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 1
|
18
|
+
|
19
|
+
// Provides constexpr c-string storage for a name of fixed |Size| characters.
|
20
|
+
// Automatically appends terminating 0 byte.
|
21
|
+
template <size_t Size>
|
22
|
+
struct NameBuffer {
|
23
|
+
char name[Size + 1]{};
|
24
|
+
|
25
|
+
static constexpr NameBuffer FromCString(const char* str) {
|
26
|
+
NameBuffer result;
|
27
|
+
for (size_t i = 0; i < Size; ++i) result.name[i] = str[i];
|
28
|
+
result.name[Size] = 0;
|
29
|
+
return result;
|
30
|
+
}
|
31
|
+
};
|
32
|
+
|
33
|
+
template <typename T>
|
34
|
+
const char* GetTypename() {
|
35
|
+
static constexpr char kSelfPrefix[] =
|
36
|
+
"const char *cppgc::internal::GetTypename() [T =";
|
37
|
+
static_assert(__builtin_strncmp(__PRETTY_FUNCTION__, kSelfPrefix,
|
38
|
+
sizeof(kSelfPrefix) - 1) == 0,
|
39
|
+
"The prefix must match");
|
40
|
+
static constexpr const char* kTypenameStart =
|
41
|
+
__PRETTY_FUNCTION__ + sizeof(kSelfPrefix);
|
42
|
+
static constexpr size_t kTypenameSize =
|
43
|
+
__builtin_strlen(__PRETTY_FUNCTION__) - sizeof(kSelfPrefix) - 1;
|
44
|
+
// NameBuffer is an indirection that is needed to make sure that only a
|
45
|
+
// substring of __PRETTY_FUNCTION__ gets materialized in the binary.
|
46
|
+
static constexpr auto buffer =
|
47
|
+
NameBuffer<kTypenameSize>::FromCString(kTypenameStart);
|
48
|
+
return buffer.name;
|
49
|
+
}
|
50
|
+
|
51
|
+
#else
|
52
|
+
#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 0
|
53
|
+
#endif
|
54
|
+
|
55
|
+
struct HeapObjectName {
|
56
|
+
const char* value;
|
57
|
+
bool name_was_hidden;
|
58
|
+
};
|
59
|
+
|
60
|
+
class V8_EXPORT NameTraitBase {
|
61
|
+
protected:
|
62
|
+
static HeapObjectName GetNameFromTypeSignature(const char*);
|
63
|
+
};
|
64
|
+
|
65
|
+
// Trait that specifies how the garbage collector retrieves the name for a
|
66
|
+
// given object.
|
67
|
+
template <typename T>
|
68
|
+
class NameTrait final : public NameTraitBase {
|
69
|
+
public:
|
70
|
+
static HeapObjectName GetName(const void* obj) {
|
71
|
+
return GetNameFor(static_cast<const T*>(obj));
|
72
|
+
}
|
73
|
+
|
74
|
+
private:
|
75
|
+
static HeapObjectName GetNameFor(const NameProvider* name_provider) {
|
76
|
+
return {name_provider->GetHumanReadableName(), false};
|
77
|
+
}
|
78
|
+
|
79
|
+
static HeapObjectName GetNameFor(...) {
|
80
|
+
#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
|
81
|
+
return {GetTypename<T>(), false};
|
82
|
+
#elif CPPGC_SUPPORTS_OBJECT_NAMES
|
83
|
+
|
84
|
+
#if defined(V8_CC_GNU)
|
85
|
+
#define PRETTY_FUNCTION_VALUE __PRETTY_FUNCTION__
|
86
|
+
#elif defined(V8_CC_MSVC)
|
87
|
+
#define PRETTY_FUNCTION_VALUE __FUNCSIG__
|
88
|
+
#else
|
89
|
+
#define PRETTY_FUNCTION_VALUE nullptr
|
90
|
+
#endif
|
91
|
+
|
92
|
+
static const HeapObjectName leaky_name =
|
93
|
+
GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
|
94
|
+
return {leaky_name, false};
|
95
|
+
|
96
|
+
#undef PRETTY_FUNCTION_VALUE
|
97
|
+
|
98
|
+
#else // !CPPGC_SUPPORTS_OBJECT_NAMES
|
99
|
+
return {NameProvider::kHiddenName, true};
|
100
|
+
#endif // !CPPGC_SUPPORTS_OBJECT_NAMES
|
101
|
+
}
|
102
|
+
};
|
103
|
+
|
104
|
+
using NameCallback = HeapObjectName (*)(const void*);
|
105
|
+
|
106
|
+
} // namespace internal
|
107
|
+
} // namespace cppgc
|
108
|
+
|
109
|
+
#undef CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
|
110
|
+
|
111
|
+
#endif // INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
|
@@ -19,7 +19,9 @@ class Visitor;
|
|
19
19
|
|
20
20
|
namespace internal {
|
21
21
|
|
22
|
-
|
22
|
+
class CrossThreadPersistentRegion;
|
23
|
+
|
24
|
+
// PersistentNode represents a variant of two states:
|
23
25
|
// 1) traceable node with a back pointer to the Persistent object;
|
24
26
|
// 2) freelist entry.
|
25
27
|
class PersistentNode final {
|
@@ -30,6 +32,7 @@ class PersistentNode final {
|
|
30
32
|
PersistentNode& operator=(const PersistentNode&) = delete;
|
31
33
|
|
32
34
|
void InitializeAsUsedNode(void* owner, TraceCallback trace) {
|
35
|
+
CPPGC_DCHECK(trace);
|
33
36
|
owner_ = owner;
|
34
37
|
trace_ = trace;
|
35
38
|
}
|
@@ -89,24 +92,77 @@ class V8_EXPORT PersistentRegion final {
|
|
89
92
|
}
|
90
93
|
PersistentNode* node = free_list_head_;
|
91
94
|
free_list_head_ = free_list_head_->FreeListNext();
|
95
|
+
CPPGC_DCHECK(!node->IsUsed());
|
92
96
|
node->InitializeAsUsedNode(owner, trace);
|
97
|
+
nodes_in_use_++;
|
93
98
|
return node;
|
94
99
|
}
|
95
100
|
|
96
101
|
void FreeNode(PersistentNode* node) {
|
102
|
+
CPPGC_DCHECK(node);
|
103
|
+
CPPGC_DCHECK(node->IsUsed());
|
97
104
|
node->InitializeAsFreeNode(free_list_head_);
|
98
105
|
free_list_head_ = node;
|
106
|
+
CPPGC_DCHECK(nodes_in_use_ > 0);
|
107
|
+
nodes_in_use_--;
|
99
108
|
}
|
100
109
|
|
101
110
|
void Trace(Visitor*);
|
102
111
|
|
103
112
|
size_t NodesInUse() const;
|
104
113
|
|
114
|
+
void ClearAllUsedNodes();
|
115
|
+
|
105
116
|
private:
|
106
117
|
void EnsureNodeSlots();
|
107
118
|
|
108
119
|
std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
|
109
120
|
PersistentNode* free_list_head_ = nullptr;
|
121
|
+
size_t nodes_in_use_ = 0;
|
122
|
+
|
123
|
+
friend class CrossThreadPersistentRegion;
|
124
|
+
};
|
125
|
+
|
126
|
+
// CrossThreadPersistent uses PersistentRegion but protects it using this lock
|
127
|
+
// when needed.
|
128
|
+
class V8_EXPORT PersistentRegionLock final {
|
129
|
+
public:
|
130
|
+
PersistentRegionLock();
|
131
|
+
~PersistentRegionLock();
|
132
|
+
|
133
|
+
static void AssertLocked();
|
134
|
+
};
|
135
|
+
|
136
|
+
// Variant of PersistentRegion that checks whether the PersistentRegionLock is
|
137
|
+
// locked.
|
138
|
+
class V8_EXPORT CrossThreadPersistentRegion final {
|
139
|
+
public:
|
140
|
+
CrossThreadPersistentRegion() = default;
|
141
|
+
// Clears Persistent fields to avoid stale pointers after heap teardown.
|
142
|
+
~CrossThreadPersistentRegion();
|
143
|
+
|
144
|
+
CrossThreadPersistentRegion(const CrossThreadPersistentRegion&) = delete;
|
145
|
+
CrossThreadPersistentRegion& operator=(const CrossThreadPersistentRegion&) =
|
146
|
+
delete;
|
147
|
+
|
148
|
+
V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
|
149
|
+
PersistentRegionLock::AssertLocked();
|
150
|
+
return persistent_region_.AllocateNode(owner, trace);
|
151
|
+
}
|
152
|
+
|
153
|
+
V8_INLINE void FreeNode(PersistentNode* node) {
|
154
|
+
PersistentRegionLock::AssertLocked();
|
155
|
+
persistent_region_.FreeNode(node);
|
156
|
+
}
|
157
|
+
|
158
|
+
void Trace(Visitor*);
|
159
|
+
|
160
|
+
size_t NodesInUse() const;
|
161
|
+
|
162
|
+
void ClearAllUsedNodes();
|
163
|
+
|
164
|
+
private:
|
165
|
+
PersistentRegion persistent_region_;
|
110
166
|
};
|
111
167
|
|
112
168
|
} // namespace internal
|