libv8-node 15.14.0.1-x86_64-darwin-19 → 16.10.0.0-x86_64-darwin-19

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.
Files changed (57) hide show
  1. checksums.yaml +4 -4
  2. data/ext/libv8-node/location.rb +1 -1
  3. data/ext/libv8-node/paths.rb +1 -1
  4. data/lib/libv8/node/version.rb +3 -3
  5. data/vendor/v8/include/cppgc/allocation.h +104 -45
  6. data/vendor/v8/include/cppgc/common.h +9 -6
  7. data/vendor/v8/include/cppgc/cross-thread-persistent.h +384 -0
  8. data/vendor/v8/include/cppgc/custom-space.h +37 -2
  9. data/vendor/v8/include/cppgc/default-platform.h +47 -48
  10. data/vendor/v8/include/cppgc/ephemeron-pair.h +30 -0
  11. data/vendor/v8/include/cppgc/explicit-management.h +82 -0
  12. data/vendor/v8/include/cppgc/garbage-collected.h +4 -3
  13. data/vendor/v8/include/cppgc/heap-consistency.h +236 -0
  14. data/vendor/v8/include/cppgc/heap-state.h +70 -0
  15. data/vendor/v8/include/cppgc/heap-statistics.h +120 -0
  16. data/vendor/v8/include/cppgc/heap.h +68 -6
  17. data/vendor/v8/include/cppgc/internal/api-constants.h +3 -3
  18. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -1
  19. data/vendor/v8/include/cppgc/internal/compiler-specific.h +2 -2
  20. data/vendor/v8/include/cppgc/internal/gc-info.h +44 -13
  21. data/vendor/v8/include/cppgc/internal/name-trait.h +111 -0
  22. data/vendor/v8/include/cppgc/internal/persistent-node.h +57 -1
  23. data/vendor/v8/include/cppgc/internal/pointer-policies.h +69 -28
  24. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +1 -1
  25. data/vendor/v8/include/cppgc/internal/write-barrier.h +353 -35
  26. data/vendor/v8/include/cppgc/liveness-broker.h +7 -1
  27. data/vendor/v8/include/cppgc/macros.h +2 -0
  28. data/vendor/v8/include/cppgc/member.h +85 -25
  29. data/vendor/v8/include/cppgc/name-provider.h +65 -0
  30. data/vendor/v8/include/cppgc/object-size-trait.h +58 -0
  31. data/vendor/v8/include/cppgc/persistent.h +33 -9
  32. data/vendor/v8/include/cppgc/platform.h +48 -25
  33. data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
  34. data/vendor/v8/include/cppgc/process-heap-statistics.h +36 -0
  35. data/vendor/v8/include/cppgc/sentinel-pointer.h +32 -0
  36. data/vendor/v8/include/cppgc/source-location.h +2 -1
  37. data/vendor/v8/include/cppgc/testing.h +99 -0
  38. data/vendor/v8/include/cppgc/trace-trait.h +8 -3
  39. data/vendor/v8/include/cppgc/type-traits.h +157 -19
  40. data/vendor/v8/include/cppgc/visitor.h +187 -23
  41. data/vendor/v8/include/libplatform/libplatform.h +11 -0
  42. data/vendor/v8/include/libplatform/v8-tracing.h +2 -0
  43. data/vendor/v8/include/v8-cppgc.h +258 -159
  44. data/vendor/v8/include/v8-fast-api-calls.h +562 -159
  45. data/vendor/v8/include/v8-inspector.h +23 -2
  46. data/vendor/v8/include/v8-internal.h +99 -27
  47. data/vendor/v8/include/v8-metrics.h +77 -8
  48. data/vendor/v8/include/v8-platform.h +47 -22
  49. data/vendor/v8/include/v8-profiler.h +75 -11
  50. data/vendor/v8/include/v8-unwinder-state.h +30 -0
  51. data/vendor/v8/include/v8-util.h +1 -1
  52. data/vendor/v8/include/v8-version.h +4 -4
  53. data/vendor/v8/include/v8.h +1192 -642
  54. data/vendor/v8/include/v8config.h +40 -9
  55. data/vendor/v8/{out.gn → x86_64-darwin-19}/libv8/obj/libv8_monolith.a +0 -0
  56. metadata +18 -6
  57. data/vendor/v8/include/cppgc/internal/process-heap.h +0 -34
@@ -105,7 +105,9 @@ class V8_EXPORT V8StackTrace {
105
105
  virtual StringView topSourceURL() const = 0;
106
106
  virtual int topLineNumber() const = 0;
107
107
  virtual int topColumnNumber() const = 0;
108
- virtual StringView topScriptId() const = 0;
108
+ virtual int topScriptId() const = 0;
109
+ V8_DEPRECATE_SOON("Use V8::StackTrace::topScriptId() instead.")
110
+ int topScriptIdAsInteger() const { return topScriptId(); }
109
111
  virtual StringView topFunctionName() const = 0;
110
112
 
111
113
  virtual ~V8StackTrace() = default;
@@ -129,6 +131,10 @@ class V8_EXPORT V8InspectorSession {
129
131
  virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
130
132
  virtual ~Inspectable() = default;
131
133
  };
134
+ class V8_EXPORT CommandLineAPIScope {
135
+ public:
136
+ virtual ~CommandLineAPIScope() = default;
137
+ };
132
138
  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
133
139
 
134
140
  // Dispatching protocol messages.
@@ -138,6 +144,9 @@ class V8_EXPORT V8InspectorSession {
138
144
  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
139
145
  supportedDomains() = 0;
140
146
 
147
+ virtual std::unique_ptr<V8InspectorSession::CommandLineAPIScope>
148
+ initializeCommandLineAPIScope(int executionContextId) = 0;
149
+
141
150
  // Debugger actions.
142
151
  virtual void schedulePauseOnNextStatement(StringView breakReason,
143
152
  StringView breakDetails) = 0;
@@ -161,7 +170,7 @@ class V8_EXPORT V8InspectorSession {
161
170
  v8::Local<v8::Context>*,
162
171
  std::unique_ptr<StringBuffer>* objectGroup) = 0;
163
172
  virtual void releaseObjectGroup(StringView) = 0;
164
- virtual void triggerPreciseCoverageDeltaUpdate(StringView occassion) = 0;
173
+ virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
165
174
  };
166
175
 
167
176
  class V8_EXPORT V8InspectorClient {
@@ -181,6 +190,10 @@ class V8_EXPORT V8InspectorClient {
181
190
  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
182
191
  return nullptr;
183
192
  }
193
+ virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
194
+ v8::Local<v8::Context>, v8::Local<v8::Value>) {
195
+ return nullptr;
196
+ }
184
197
  virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>) {
185
198
  return false;
186
199
  }
@@ -224,6 +237,10 @@ class V8_EXPORT V8InspectorClient {
224
237
  const StringView& resourceName) {
225
238
  return nullptr;
226
239
  }
240
+
241
+ // The caller would defer to generating a random 64 bit integer if
242
+ // this method returns 0.
243
+ virtual int64_t generateUniqueId() { return 0; }
227
244
  };
228
245
 
229
246
  // These stack trace ids are intended to be passed between debuggers and be
@@ -284,6 +301,10 @@ class V8_EXPORT V8Inspector {
284
301
  int scriptId) = 0;
285
302
  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
286
303
  StringView message) = 0;
304
+ virtual bool associateExceptionData(v8::Local<v8::Context>,
305
+ v8::Local<v8::Value> exception,
306
+ v8::Local<v8::Name> key,
307
+ v8::Local<v8::Value> value) = 0;
287
308
 
288
309
  // Connection.
289
310
  class V8_EXPORT Channel {
@@ -40,6 +40,13 @@ const int kWeakHeapObjectTag = 3;
40
40
  const int kHeapObjectTagSize = 2;
41
41
  const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
42
42
 
43
+ // Tag information for fowarding pointers stored in object headers.
44
+ // 0b00 at the lowest 2 bits in the header indicates that the map word is a
45
+ // forwarding pointer.
46
+ const int kForwardingTag = 0;
47
+ const int kForwardingTagSize = 2;
48
+ const intptr_t kForwardingTagMask = (1 << kForwardingTagSize) - 1;
49
+
43
50
  // Tag information for Smi.
44
51
  const int kSmiTag = 0;
45
52
  const int kSmiTagSize = 1;
@@ -120,6 +127,29 @@ constexpr bool HeapSandboxIsEnabled() {
120
127
 
121
128
  using ExternalPointer_t = Address;
122
129
 
130
+ // If the heap sandbox is enabled, these tag values will be ORed with the
131
+ // external pointers in the external pointer table to prevent use of pointers of
132
+ // the wrong type. When a pointer is loaded, it is ANDed with the inverse of the
133
+ // expected type's tag. The tags are constructed in a way that guarantees that a
134
+ // failed type check will result in one or more of the top bits of the pointer
135
+ // to be set, rendering the pointer inacessible. This construction allows
136
+ // performing the type check and removing GC marking bits from the pointer at
137
+ // the same time.
138
+ enum ExternalPointerTag : uint64_t {
139
+ kExternalPointerNullTag = 0x0000000000000000,
140
+ kArrayBufferBackingStoreTag = 0x00ff000000000000, // 0b000000011111111
141
+ kTypedArrayExternalPointerTag = 0x017f000000000000, // 0b000000101111111
142
+ kDataViewDataPointerTag = 0x01bf000000000000, // 0b000000110111111
143
+ kExternalStringResourceTag = 0x01df000000000000, // 0b000000111011111
144
+ kExternalStringResourceDataTag = 0x01ef000000000000, // 0b000000111101111
145
+ kForeignForeignAddressTag = 0x01f7000000000000, // 0b000000111110111
146
+ kNativeContextMicrotaskQueueTag = 0x01fb000000000000, // 0b000000111111011
147
+ kEmbedderDataSlotPayloadTag = 0x01fd000000000000, // 0b000000111111101
148
+ kCodeEntryPointTag = 0x01fe000000000000, // 0b000000111111110
149
+ };
150
+
151
+ constexpr uint64_t kExternalPointerTagMask = 0xffff000000000000;
152
+
123
153
  #ifdef V8_31BIT_SMIS_ON_64BIT_ARCH
124
154
  using PlatformSmiTagging = SmiTagging<kApiInt32Size>;
125
155
  #else
@@ -140,6 +170,11 @@ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
140
170
  kSmiTag;
141
171
  }
142
172
 
173
+ // Converts encoded external pointer to address.
174
+ V8_EXPORT Address DecodeExternalPointerImpl(const Isolate* isolate,
175
+ ExternalPointer_t pointer,
176
+ ExternalPointerTag tag);
177
+
143
178
  // {obj} must be the raw tagged pointer representation of a HeapObject
144
179
  // that's guaranteed to never be in ReadOnlySpace.
145
180
  V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);
@@ -155,6 +190,14 @@ V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
155
190
  * depend on functions and constants defined here.
156
191
  */
157
192
  class Internals {
193
+ #ifdef V8_MAP_PACKING
194
+ V8_INLINE static constexpr internal::Address UnpackMapWord(
195
+ internal::Address mapword) {
196
+ // TODO(wenyuzhao): Clear header metadata.
197
+ return mapword ^ kMapWordXorMask;
198
+ }
199
+ #endif
200
+
158
201
  public:
159
202
  // These values match non-compiler-dependent values defined within
160
203
  // the implementation of v8.
@@ -168,6 +211,9 @@ class Internals {
168
211
  static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
169
212
  static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
170
213
  static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
214
+ #ifdef V8_HEAP_SANDBOX
215
+ static const int kEmbedderDataSlotRawPayloadOffset = kApiTaggedSize;
216
+ #endif
171
217
  static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
172
218
  static const int kFullStringRepresentationMask = 0x0f;
173
219
  static const int kStringEncodingMask = 0x8;
@@ -182,11 +228,19 @@ class Internals {
182
228
  kNumIsolateDataSlots * kApiSystemPointerSize;
183
229
  static const int kIsolateFastCCallCallerPcOffset =
184
230
  kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;
185
- static const int kIsolateStackGuardOffset =
231
+ static const int kIsolateFastApiCallTargetOffset =
186
232
  kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
233
+ static const int kIsolateStackGuardOffset =
234
+ kIsolateFastApiCallTargetOffset + kApiSystemPointerSize;
187
235
  static const int kIsolateRootsOffset =
188
236
  kIsolateStackGuardOffset + 7 * kApiSystemPointerSize;
189
237
 
238
+ static const int kExternalPointerTableBufferOffset = 0;
239
+ static const int kExternalPointerTableLengthOffset =
240
+ kExternalPointerTableBufferOffset + kApiSystemPointerSize;
241
+ static const int kExternalPointerTableCapacityOffset =
242
+ kExternalPointerTableLengthOffset + kApiInt32Size;
243
+
190
244
  static const int kUndefinedValueRootIndex = 4;
191
245
  static const int kTheHoleValueRootIndex = 5;
192
246
  static const int kNullValueRootIndex = 6;
@@ -220,6 +274,17 @@ class Internals {
220
274
  // incremental GC once the external memory reaches this limit.
221
275
  static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024;
222
276
 
277
+ #ifdef V8_MAP_PACKING
278
+ static const uintptr_t kMapWordMetadataMask = 0xffffULL << 48;
279
+ // The lowest two bits of mapwords are always `0b10`
280
+ static const uintptr_t kMapWordSignature = 0b10;
281
+ // XORing a (non-compressed) map with this mask ensures that the two
282
+ // low-order bits are 0b10. The 0 at the end makes this look like a Smi,
283
+ // although real Smis have all lower 32 bits unset. We only rely on these
284
+ // values passing as Smis in very few places.
285
+ static const int kMapWordXorMask = 0b11;
286
+ #endif
287
+
223
288
  V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
224
289
  V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
225
290
  #ifdef V8_ENABLE_CHECKS
@@ -246,6 +311,9 @@ class Internals {
246
311
  V8_INLINE static int GetInstanceType(const internal::Address obj) {
247
312
  typedef internal::Address A;
248
313
  A map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);
314
+ #ifdef V8_MAP_PACKING
315
+ map = UnpackMapWord(map);
316
+ #endif
249
317
  return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset);
250
318
  }
251
319
 
@@ -325,8 +393,9 @@ class Internals {
325
393
  internal::Address heap_object_ptr, int offset) {
326
394
  #ifdef V8_COMPRESS_POINTERS
327
395
  uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);
328
- internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
329
- return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
396
+ internal::Address base =
397
+ GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr);
398
+ return base + static_cast<internal::Address>(static_cast<uintptr_t>(value));
330
399
  #else
331
400
  return ReadRawField<internal::Address>(heap_object_ptr, offset);
332
401
  #endif
@@ -352,45 +421,47 @@ class Internals {
352
421
  #endif
353
422
  }
354
423
 
424
+ V8_INLINE static Address DecodeExternalPointer(
425
+ const Isolate* isolate, ExternalPointer_t encoded_pointer,
426
+ ExternalPointerTag tag) {
427
+ #ifdef V8_HEAP_SANDBOX
428
+ return internal::DecodeExternalPointerImpl(isolate, encoded_pointer, tag);
429
+ #else
430
+ return encoded_pointer;
431
+ #endif
432
+ }
433
+
355
434
  V8_INLINE static internal::Address ReadExternalPointerField(
356
- internal::Isolate* isolate, internal::Address heap_object_ptr,
357
- int offset) {
358
- internal::Address value = ReadRawField<Address>(heap_object_ptr, offset);
435
+ internal::Isolate* isolate, internal::Address heap_object_ptr, int offset,
436
+ ExternalPointerTag tag) {
359
437
  #ifdef V8_HEAP_SANDBOX
438
+ internal::ExternalPointer_t encoded_value =
439
+ ReadRawField<uint32_t>(heap_object_ptr, offset);
360
440
  // We currently have to treat zero as nullptr in embedder slots.
361
- if (value) value = DecodeExternalPointer(isolate, value);
441
+ return encoded_value ? DecodeExternalPointer(isolate, encoded_value, tag)
442
+ : 0;
443
+ #else
444
+ return ReadRawField<Address>(heap_object_ptr, offset);
362
445
  #endif
363
- return value;
364
446
  }
365
447
 
366
448
  #ifdef V8_COMPRESS_POINTERS
367
449
  // See v8:7703 or src/ptr-compr.* for details about pointer compression.
368
- static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32;
369
- static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32;
370
-
371
- // See v8:10391 for details about V8 heap sandbox.
372
- static constexpr uint32_t kExternalPointerSalt =
373
- 0x7fffffff & ~static_cast<uint32_t>(kHeapObjectTagMask);
450
+ static constexpr size_t kPtrComprCageReservationSize = size_t{1} << 32;
451
+ static constexpr size_t kPtrComprCageBaseAlignment = size_t{1} << 32;
374
452
 
375
- V8_INLINE static internal::Address GetRootFromOnHeapAddress(
453
+ V8_INLINE static internal::Address GetPtrComprCageBaseFromOnHeapAddress(
376
454
  internal::Address addr) {
377
- return addr & -static_cast<intptr_t>(kPtrComprIsolateRootAlignment);
455
+ return addr & -static_cast<intptr_t>(kPtrComprCageBaseAlignment);
378
456
  }
379
457
 
380
458
  V8_INLINE static internal::Address DecompressTaggedAnyField(
381
459
  internal::Address heap_object_ptr, uint32_t value) {
382
- internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
383
- return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
460
+ internal::Address base =
461
+ GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr);
462
+ return base + static_cast<internal::Address>(static_cast<uintptr_t>(value));
384
463
  }
385
464
 
386
- V8_INLINE static Address DecodeExternalPointer(
387
- const Isolate* isolate, ExternalPointer_t encoded_pointer) {
388
- #ifndef V8_HEAP_SANDBOX
389
- return encoded_pointer;
390
- #else
391
- return encoded_pointer ^ kExternalPointerSalt;
392
- #endif
393
- }
394
465
  #endif // V8_COMPRESS_POINTERS
395
466
  };
396
467
 
@@ -414,7 +485,8 @@ void CastCheck<false>::Perform(T* data) {}
414
485
 
415
486
  template <class T>
416
487
  V8_INLINE void PerformCastCheck(T* data) {
417
- CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
488
+ CastCheck<std::is_base_of<Data, T>::value &&
489
+ !std::is_same<Data, std::remove_cv_t<T>>::value>::Perform(data);
418
490
  }
419
491
 
420
492
  // A base class for backing stores, which is needed due to vagaries of
@@ -10,13 +10,74 @@
10
10
  namespace v8 {
11
11
  namespace metrics {
12
12
 
13
+ struct GarbageCollectionPhases {
14
+ int64_t compact_wall_clock_duration_in_us = -1;
15
+ int64_t mark_wall_clock_duration_in_us = -1;
16
+ int64_t sweep_wall_clock_duration_in_us = -1;
17
+ int64_t weak_wall_clock_duration_in_us = -1;
18
+ };
19
+
20
+ struct GarbageCollectionSizes {
21
+ int64_t bytes_before = -1;
22
+ int64_t bytes_after = -1;
23
+ int64_t bytes_freed = -1;
24
+ };
25
+
26
+ struct GarbageCollectionFullCycle {
27
+ GarbageCollectionPhases total;
28
+ GarbageCollectionPhases total_cpp;
29
+ GarbageCollectionPhases main_thread;
30
+ GarbageCollectionPhases main_thread_cpp;
31
+ GarbageCollectionPhases main_thread_atomic;
32
+ GarbageCollectionPhases main_thread_atomic_cpp;
33
+ GarbageCollectionPhases main_thread_incremental;
34
+ GarbageCollectionPhases main_thread_incremental_cpp;
35
+ GarbageCollectionSizes objects;
36
+ GarbageCollectionSizes objects_cpp;
37
+ GarbageCollectionSizes memory;
38
+ GarbageCollectionSizes memory_cpp;
39
+ double collection_rate_in_percent;
40
+ double collection_rate_cpp_in_percent;
41
+ double efficiency_in_bytes_per_us;
42
+ double efficiency_cpp_in_bytes_per_us;
43
+ double main_thread_efficiency_in_bytes_per_us;
44
+ double main_thread_efficiency_cpp_in_bytes_per_us;
45
+ };
46
+
47
+ struct GarbageCollectionFullMainThreadIncrementalMark {
48
+ int64_t wall_clock_duration_in_us = -1;
49
+ int64_t cpp_wall_clock_duration_in_us = -1;
50
+ };
51
+
52
+ struct GarbageCollectionFullMainThreadBatchedIncrementalMark {
53
+ std::vector<GarbageCollectionFullMainThreadIncrementalMark> events;
54
+ };
55
+
56
+ struct GarbageCollectionFullMainThreadIncrementalSweep {
57
+ int64_t wall_clock_duration_in_us = -1;
58
+ int64_t cpp_wall_clock_duration_in_us = -1;
59
+ };
60
+
61
+ struct GarbageCollectionFullMainThreadBatchedIncrementalSweep {
62
+ std::vector<GarbageCollectionFullMainThreadIncrementalSweep> events;
63
+ };
64
+
65
+ struct GarbageCollectionYoungCycle {
66
+ int64_t total_wall_clock_duration_in_us = -1;
67
+ int64_t main_thread_wall_clock_duration_in_us = -1;
68
+ double collection_rate_in_percent;
69
+ double efficiency_in_bytes_per_us;
70
+ double main_thread_efficiency_in_bytes_per_us;
71
+ };
72
+
13
73
  struct WasmModuleDecoded {
14
74
  bool async = false;
15
75
  bool streamed = false;
16
76
  bool success = false;
17
77
  size_t module_size_in_bytes = 0;
18
78
  size_t function_count = 0;
19
- int64_t wall_clock_time_in_us = 0;
79
+ int64_t wall_clock_duration_in_us = -1;
80
+ int64_t cpu_duration_in_us = -1;
20
81
  };
21
82
 
22
83
  struct WasmModuleCompiled {
@@ -28,30 +89,38 @@ struct WasmModuleCompiled {
28
89
  bool success = false;
29
90
  size_t code_size_in_bytes = 0;
30
91
  size_t liftoff_bailout_count = 0;
31
- int64_t wall_clock_time_in_us = 0;
92
+ int64_t wall_clock_duration_in_us = -1;
93
+ int64_t cpu_duration_in_us = -1;
32
94
  };
33
95
 
34
96
  struct WasmModuleInstantiated {
35
97
  bool async = false;
36
98
  bool success = false;
37
99
  size_t imported_function_count = 0;
38
- int64_t wall_clock_time_in_us = 0;
100
+ int64_t wall_clock_duration_in_us = -1;
39
101
  };
40
102
 
41
103
  struct WasmModuleTieredUp {
42
104
  bool lazy = false;
43
105
  size_t code_size_in_bytes = 0;
44
- int64_t wall_clock_time_in_us = 0;
106
+ int64_t wall_clock_duration_in_us = -1;
107
+ int64_t cpu_duration_in_us = -1;
45
108
  };
46
109
 
47
110
  struct WasmModulesPerIsolate {
48
111
  size_t count = 0;
49
112
  };
50
113
 
51
- #define V8_MAIN_THREAD_METRICS_EVENTS(V) \
52
- V(WasmModuleDecoded) \
53
- V(WasmModuleCompiled) \
54
- V(WasmModuleInstantiated) \
114
+ #define V8_MAIN_THREAD_METRICS_EVENTS(V) \
115
+ V(GarbageCollectionFullCycle) \
116
+ V(GarbageCollectionFullMainThreadIncrementalMark) \
117
+ V(GarbageCollectionFullMainThreadBatchedIncrementalMark) \
118
+ V(GarbageCollectionFullMainThreadIncrementalSweep) \
119
+ V(GarbageCollectionFullMainThreadBatchedIncrementalSweep) \
120
+ V(GarbageCollectionYoungCycle) \
121
+ V(WasmModuleDecoded) \
122
+ V(WasmModuleCompiled) \
123
+ V(WasmModuleInstantiated) \
55
124
  V(WasmModuleTieredUp)
56
125
 
57
126
  #define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
@@ -175,9 +175,15 @@ class JobDelegate {
175
175
  * Returns a task_id unique among threads currently running this job, such
176
176
  * that GetTaskId() < worker count. To achieve this, the same task_id may be
177
177
  * reused by a different thread after a worker_task returns.
178
+ */
179
+ virtual uint8_t GetTaskId() = 0;
180
+
181
+ /**
182
+ * Returns true if the current task is called from the thread currently
183
+ * running JobHandle::Join().
178
184
  * TODO(etiennep): Make pure virtual once custom embedders implement it.
179
185
  */
180
- virtual uint8_t GetTaskId() { return 0; }
186
+ virtual bool IsJoiningThread() const { return false; }
181
187
  };
182
188
 
183
189
  /**
@@ -210,17 +216,43 @@ class JobHandle {
210
216
  */
211
217
  virtual void Cancel() = 0;
212
218
 
219
+ /*
220
+ * Forces all existing workers to yield ASAP but doesn’t wait for them.
221
+ * Warning, this is dangerous if the Job's callback is bound to or has access
222
+ * to state which may be deleted after this call.
223
+ * TODO(etiennep): Cleanup once implemented by all embedders.
224
+ */
225
+ virtual void CancelAndDetach() { Cancel(); }
226
+
213
227
  /**
214
- * Returns true if there's no work pending and no worker running.
215
- * TODO(etiennep): Make pure virtual once custom embedders implement it.
228
+ * Returns true if there's any work pending or any worker running.
216
229
  */
217
- virtual bool IsCompleted() { return true; }
230
+ virtual bool IsActive() = 0;
231
+
232
+ // TODO(etiennep): Clean up once all overrides are removed.
233
+ V8_DEPRECATED("Use !IsActive() instead.")
234
+ virtual bool IsCompleted() { return !IsActive(); }
218
235
 
219
236
  /**
220
237
  * Returns true if associated with a Job and other methods may be called.
221
- * Returns false after Join() or Cancel() was called.
238
+ * Returns false after Join() or Cancel() was called. This may return true
239
+ * even if no workers are running and IsCompleted() returns true
222
240
  */
223
- virtual bool IsRunning() = 0;
241
+ virtual bool IsValid() = 0;
242
+
243
+ // TODO(etiennep): Clean up once all overrides are removed.
244
+ V8_DEPRECATED("Use IsValid() instead.")
245
+ virtual bool IsRunning() { return IsValid(); }
246
+
247
+ /**
248
+ * Returns true if job priority can be changed.
249
+ */
250
+ virtual bool UpdatePriorityEnabled() const { return false; }
251
+
252
+ /**
253
+ * Update this Job's priority.
254
+ */
255
+ virtual void UpdatePriority(TaskPriority new_priority) {}
224
256
  };
225
257
 
226
258
  /**
@@ -233,23 +265,17 @@ class JobTask {
233
265
  virtual void Run(JobDelegate* delegate) = 0;
234
266
 
235
267
  /**
236
- * Controls the maximum number of threads calling Run() concurrently. Run() is
237
- * only invoked if the number of threads previously running Run() was less
238
- * than the value returned. Since GetMaxConcurrency() is a leaf function, it
239
- * must not call back any JobHandle methods.
268
+ * Controls the maximum number of threads calling Run() concurrently, given
269
+ * the number of threads currently assigned to this job and executing Run().
270
+ * Run() is only invoked if the number of threads previously running Run() was
271
+ * less than the value returned. Since GetMaxConcurrency() is a leaf function,
272
+ * it must not call back any JobHandle methods.
240
273
  */
241
- virtual size_t GetMaxConcurrency() const = 0;
274
+ virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
242
275
 
243
- /*
244
- * Meant to replace the version above, given the number of threads currently
245
- * assigned to this job and executing Run(). This is useful when the result
246
- * must include local work items not visible globaly by other workers.
247
- * TODO(etiennep): Replace the version above by this once custom embedders are
248
- * migrated.
249
- */
250
- size_t GetMaxConcurrency(size_t worker_count) const {
251
- return GetMaxConcurrency();
252
- }
276
+ // TODO(1114823): Clean up once all overrides are removed.
277
+ V8_DEPRECATED("Use the version that takes |worker_count|.")
278
+ virtual size_t GetMaxConcurrency() const { return 0; }
253
279
  };
254
280
 
255
281
  /**
@@ -382,7 +408,6 @@ class PageAllocator {
382
408
  kNoAccess,
383
409
  kRead,
384
410
  kReadWrite,
385
- // TODO(hpayer): Remove this flag. Memory should never be rwx.
386
411
  kReadWriteExecute,
387
412
  kReadExecute,
388
413
  // Set this when reserving memory that will later require kReadWriteExecute