libv8-node 15.14.0.1-arm64-darwin-21

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 (56) hide show
  1. checksums.yaml +7 -0
  2. data/ext/libv8-node/.location.yml +1 -0
  3. data/ext/libv8-node/location.rb +76 -0
  4. data/ext/libv8-node/paths.rb +30 -0
  5. data/lib/libv8/node/version.rb +7 -0
  6. data/lib/libv8/node.rb +11 -0
  7. data/lib/libv8-node.rb +1 -0
  8. data/vendor/v8/include/cppgc/allocation.h +173 -0
  9. data/vendor/v8/include/cppgc/common.h +26 -0
  10. data/vendor/v8/include/cppgc/custom-space.h +62 -0
  11. data/vendor/v8/include/cppgc/default-platform.h +76 -0
  12. data/vendor/v8/include/cppgc/garbage-collected.h +116 -0
  13. data/vendor/v8/include/cppgc/heap.h +139 -0
  14. data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
  15. data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
  16. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +67 -0
  17. data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
  18. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  19. data/vendor/v8/include/cppgc/internal/gc-info.h +45 -0
  20. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  21. data/vendor/v8/include/cppgc/internal/persistent-node.h +116 -0
  22. data/vendor/v8/include/cppgc/internal/pointer-policies.h +134 -0
  23. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
  24. data/vendor/v8/include/cppgc/internal/process-heap.h +34 -0
  25. data/vendor/v8/include/cppgc/internal/write-barrier.h +78 -0
  26. data/vendor/v8/include/cppgc/liveness-broker.h +68 -0
  27. data/vendor/v8/include/cppgc/macros.h +24 -0
  28. data/vendor/v8/include/cppgc/member.h +226 -0
  29. data/vendor/v8/include/cppgc/persistent.h +341 -0
  30. data/vendor/v8/include/cppgc/platform.h +130 -0
  31. data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
  32. data/vendor/v8/include/cppgc/source-location.h +91 -0
  33. data/vendor/v8/include/cppgc/trace-trait.h +111 -0
  34. data/vendor/v8/include/cppgc/type-traits.h +109 -0
  35. data/vendor/v8/include/cppgc/visitor.h +213 -0
  36. data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
  37. data/vendor/v8/include/libplatform/libplatform.h +106 -0
  38. data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
  39. data/vendor/v8/include/v8-cppgc.h +226 -0
  40. data/vendor/v8/include/v8-fast-api-calls.h +388 -0
  41. data/vendor/v8/include/v8-inspector-protocol.h +13 -0
  42. data/vendor/v8/include/v8-inspector.h +327 -0
  43. data/vendor/v8/include/v8-internal.h +427 -0
  44. data/vendor/v8/include/v8-metrics.h +133 -0
  45. data/vendor/v8/include/v8-platform.h +684 -0
  46. data/vendor/v8/include/v8-profiler.h +1059 -0
  47. data/vendor/v8/include/v8-util.h +652 -0
  48. data/vendor/v8/include/v8-value-serializer-version.h +24 -0
  49. data/vendor/v8/include/v8-version-string.h +38 -0
  50. data/vendor/v8/include/v8-version.h +20 -0
  51. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
  52. data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
  53. data/vendor/v8/include/v8.h +12098 -0
  54. data/vendor/v8/include/v8config.h +484 -0
  55. data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
  56. metadata +126 -0
@@ -0,0 +1,684 @@
1
+ // Copyright 2013 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 V8_V8_PLATFORM_H_
6
+ #define V8_V8_PLATFORM_H_
7
+
8
+ #include <stddef.h>
9
+ #include <stdint.h>
10
+ #include <stdlib.h> // For abort.
11
+ #include <memory>
12
+ #include <string>
13
+
14
+ #include "v8config.h" // NOLINT(build/include_directory)
15
+
16
+ namespace v8 {
17
+
18
+ class Isolate;
19
+
20
+ // Valid priorities supported by the task scheduling infrastructure.
21
+ enum class TaskPriority : uint8_t {
22
+ /**
23
+ * Best effort tasks are not critical for performance of the application. The
24
+ * platform implementation should preempt such tasks if higher priority tasks
25
+ * arrive.
26
+ */
27
+ kBestEffort,
28
+ /**
29
+ * User visible tasks are long running background tasks that will
30
+ * improve performance and memory usage of the application upon completion.
31
+ * Example: background compilation and garbage collection.
32
+ */
33
+ kUserVisible,
34
+ /**
35
+ * User blocking tasks are highest priority tasks that block the execution
36
+ * thread (e.g. major garbage collection). They must be finished as soon as
37
+ * possible.
38
+ */
39
+ kUserBlocking,
40
+ };
41
+
42
+ /**
43
+ * A Task represents a unit of work.
44
+ */
45
+ class Task {
46
+ public:
47
+ virtual ~Task() = default;
48
+
49
+ virtual void Run() = 0;
50
+ };
51
+
52
+ /**
53
+ * An IdleTask represents a unit of work to be performed in idle time.
54
+ * The Run method is invoked with an argument that specifies the deadline in
55
+ * seconds returned by MonotonicallyIncreasingTime().
56
+ * The idle task is expected to complete by this deadline.
57
+ */
58
+ class IdleTask {
59
+ public:
60
+ virtual ~IdleTask() = default;
61
+ virtual void Run(double deadline_in_seconds) = 0;
62
+ };
63
+
64
+ /**
65
+ * A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to
66
+ * post tasks after the isolate gets destructed, but these tasks may not get
67
+ * executed anymore. All tasks posted to a given TaskRunner will be invoked in
68
+ * sequence. Tasks can be posted from any thread.
69
+ */
70
+ class TaskRunner {
71
+ public:
72
+ /**
73
+ * Schedules a task to be invoked by this TaskRunner. The TaskRunner
74
+ * implementation takes ownership of |task|.
75
+ */
76
+ virtual void PostTask(std::unique_ptr<Task> task) = 0;
77
+
78
+ /**
79
+ * Schedules a task to be invoked by this TaskRunner. The TaskRunner
80
+ * implementation takes ownership of |task|. The |task| cannot be nested
81
+ * within other task executions.
82
+ *
83
+ * Tasks which shouldn't be interleaved with JS execution must be posted with
84
+ * |PostNonNestableTask| or |PostNonNestableDelayedTask|. This is because the
85
+ * embedder may process tasks in a callback which is called during JS
86
+ * execution.
87
+ *
88
+ * In particular, tasks which execute JS must be non-nestable, since JS
89
+ * execution is not allowed to nest.
90
+ *
91
+ * Requires that |TaskRunner::NonNestableTasksEnabled()| is true.
92
+ */
93
+ virtual void PostNonNestableTask(std::unique_ptr<Task> task) {}
94
+
95
+ /**
96
+ * Schedules a task to be invoked by this TaskRunner. The task is scheduled
97
+ * after the given number of seconds |delay_in_seconds|. The TaskRunner
98
+ * implementation takes ownership of |task|.
99
+ */
100
+ virtual void PostDelayedTask(std::unique_ptr<Task> task,
101
+ double delay_in_seconds) = 0;
102
+
103
+ /**
104
+ * Schedules a task to be invoked by this TaskRunner. The task is scheduled
105
+ * after the given number of seconds |delay_in_seconds|. The TaskRunner
106
+ * implementation takes ownership of |task|. The |task| cannot be nested
107
+ * within other task executions.
108
+ *
109
+ * Tasks which shouldn't be interleaved with JS execution must be posted with
110
+ * |PostNonNestableTask| or |PostNonNestableDelayedTask|. This is because the
111
+ * embedder may process tasks in a callback which is called during JS
112
+ * execution.
113
+ *
114
+ * In particular, tasks which execute JS must be non-nestable, since JS
115
+ * execution is not allowed to nest.
116
+ *
117
+ * Requires that |TaskRunner::NonNestableDelayedTasksEnabled()| is true.
118
+ */
119
+ virtual void PostNonNestableDelayedTask(std::unique_ptr<Task> task,
120
+ double delay_in_seconds) {}
121
+
122
+ /**
123
+ * Schedules an idle task to be invoked by this TaskRunner. The task is
124
+ * scheduled when the embedder is idle. Requires that
125
+ * |TaskRunner::IdleTasksEnabled()| is true. Idle tasks may be reordered
126
+ * relative to other task types and may be starved for an arbitrarily long
127
+ * time if no idle time is available. The TaskRunner implementation takes
128
+ * ownership of |task|.
129
+ */
130
+ virtual void PostIdleTask(std::unique_ptr<IdleTask> task) = 0;
131
+
132
+ /**
133
+ * Returns true if idle tasks are enabled for this TaskRunner.
134
+ */
135
+ virtual bool IdleTasksEnabled() = 0;
136
+
137
+ /**
138
+ * Returns true if non-nestable tasks are enabled for this TaskRunner.
139
+ */
140
+ virtual bool NonNestableTasksEnabled() const { return false; }
141
+
142
+ /**
143
+ * Returns true if non-nestable delayed tasks are enabled for this TaskRunner.
144
+ */
145
+ virtual bool NonNestableDelayedTasksEnabled() const { return false; }
146
+
147
+ TaskRunner() = default;
148
+ virtual ~TaskRunner() = default;
149
+
150
+ TaskRunner(const TaskRunner&) = delete;
151
+ TaskRunner& operator=(const TaskRunner&) = delete;
152
+ };
153
+
154
+ /**
155
+ * Delegate that's passed to Job's worker task, providing an entry point to
156
+ * communicate with the scheduler.
157
+ */
158
+ class JobDelegate {
159
+ public:
160
+ /**
161
+ * Returns true if this thread should return from the worker task on the
162
+ * current thread ASAP. Workers should periodically invoke ShouldYield (or
163
+ * YieldIfNeeded()) as often as is reasonable.
164
+ */
165
+ virtual bool ShouldYield() = 0;
166
+
167
+ /**
168
+ * Notifies the scheduler that max concurrency was increased, and the number
169
+ * of worker should be adjusted accordingly. See Platform::PostJob() for more
170
+ * details.
171
+ */
172
+ virtual void NotifyConcurrencyIncrease() = 0;
173
+
174
+ /**
175
+ * Returns a task_id unique among threads currently running this job, such
176
+ * that GetTaskId() < worker count. To achieve this, the same task_id may be
177
+ * reused by a different thread after a worker_task returns.
178
+ * TODO(etiennep): Make pure virtual once custom embedders implement it.
179
+ */
180
+ virtual uint8_t GetTaskId() { return 0; }
181
+ };
182
+
183
+ /**
184
+ * Handle returned when posting a Job. Provides methods to control execution of
185
+ * the posted Job.
186
+ */
187
+ class JobHandle {
188
+ public:
189
+ virtual ~JobHandle() = default;
190
+
191
+ /**
192
+ * Notifies the scheduler that max concurrency was increased, and the number
193
+ * of worker should be adjusted accordingly. See Platform::PostJob() for more
194
+ * details.
195
+ */
196
+ virtual void NotifyConcurrencyIncrease() = 0;
197
+
198
+ /**
199
+ * Contributes to the job on this thread. Doesn't return until all tasks have
200
+ * completed and max concurrency becomes 0. When Join() is called and max
201
+ * concurrency reaches 0, it should not increase again. This also promotes
202
+ * this Job's priority to be at least as high as the calling thread's
203
+ * priority.
204
+ */
205
+ virtual void Join() = 0;
206
+
207
+ /**
208
+ * Forces all existing workers to yield ASAP. Waits until they have all
209
+ * returned from the Job's callback before returning.
210
+ */
211
+ virtual void Cancel() = 0;
212
+
213
+ /**
214
+ * Returns true if there's no work pending and no worker running.
215
+ * TODO(etiennep): Make pure virtual once custom embedders implement it.
216
+ */
217
+ virtual bool IsCompleted() { return true; }
218
+
219
+ /**
220
+ * Returns true if associated with a Job and other methods may be called.
221
+ * Returns false after Join() or Cancel() was called.
222
+ */
223
+ virtual bool IsRunning() = 0;
224
+ };
225
+
226
+ /**
227
+ * A JobTask represents work to run in parallel from Platform::PostJob().
228
+ */
229
+ class JobTask {
230
+ public:
231
+ virtual ~JobTask() = default;
232
+
233
+ virtual void Run(JobDelegate* delegate) = 0;
234
+
235
+ /**
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.
240
+ */
241
+ virtual size_t GetMaxConcurrency() const = 0;
242
+
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
+ }
253
+ };
254
+
255
+ /**
256
+ * The interface represents complex arguments to trace events.
257
+ */
258
+ class ConvertableToTraceFormat {
259
+ public:
260
+ virtual ~ConvertableToTraceFormat() = default;
261
+
262
+ /**
263
+ * Append the class info to the provided |out| string. The appended
264
+ * data must be a valid JSON object. Strings must be properly quoted, and
265
+ * escaped. There is no processing applied to the content after it is
266
+ * appended.
267
+ */
268
+ virtual void AppendAsTraceFormat(std::string* out) const = 0;
269
+ };
270
+
271
+ /**
272
+ * V8 Tracing controller.
273
+ *
274
+ * Can be implemented by an embedder to record trace events from V8.
275
+ */
276
+ class TracingController {
277
+ public:
278
+ virtual ~TracingController() = default;
279
+
280
+ // In Perfetto mode, trace events are written using Perfetto's Track Event
281
+ // API directly without going through the embedder. However, it is still
282
+ // possible to observe tracing being enabled and disabled.
283
+ #if !defined(V8_USE_PERFETTO)
284
+ /**
285
+ * Called by TRACE_EVENT* macros, don't call this directly.
286
+ * The name parameter is a category group for example:
287
+ * TRACE_EVENT0("v8,parse", "V8.Parse")
288
+ * The pointer returned points to a value with zero or more of the bits
289
+ * defined in CategoryGroupEnabledFlags.
290
+ **/
291
+ virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
292
+ static uint8_t no = 0;
293
+ return &no;
294
+ }
295
+
296
+ /**
297
+ * Adds a trace event to the platform tracing system. These function calls are
298
+ * usually the result of a TRACE_* macro from trace_event_common.h when
299
+ * tracing and the category of the particular trace are enabled. It is not
300
+ * advisable to call these functions on their own; they are really only meant
301
+ * to be used by the trace macros. The returned handle can be used by
302
+ * UpdateTraceEventDuration to update the duration of COMPLETE events.
303
+ */
304
+ virtual uint64_t AddTraceEvent(
305
+ char phase, const uint8_t* category_enabled_flag, const char* name,
306
+ const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
307
+ const char** arg_names, const uint8_t* arg_types,
308
+ const uint64_t* arg_values,
309
+ std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
310
+ unsigned int flags) {
311
+ return 0;
312
+ }
313
+ virtual uint64_t AddTraceEventWithTimestamp(
314
+ char phase, const uint8_t* category_enabled_flag, const char* name,
315
+ const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
316
+ const char** arg_names, const uint8_t* arg_types,
317
+ const uint64_t* arg_values,
318
+ std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
319
+ unsigned int flags, int64_t timestamp) {
320
+ return 0;
321
+ }
322
+
323
+ /**
324
+ * Sets the duration field of a COMPLETE trace event. It must be called with
325
+ * the handle returned from AddTraceEvent().
326
+ **/
327
+ virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
328
+ const char* name, uint64_t handle) {}
329
+ #endif // !defined(V8_USE_PERFETTO)
330
+
331
+ class TraceStateObserver {
332
+ public:
333
+ virtual ~TraceStateObserver() = default;
334
+ virtual void OnTraceEnabled() = 0;
335
+ virtual void OnTraceDisabled() = 0;
336
+ };
337
+
338
+ /** Adds tracing state change observer. */
339
+ virtual void AddTraceStateObserver(TraceStateObserver*) {}
340
+
341
+ /** Removes tracing state change observer. */
342
+ virtual void RemoveTraceStateObserver(TraceStateObserver*) {}
343
+ };
344
+
345
+ /**
346
+ * A V8 memory page allocator.
347
+ *
348
+ * Can be implemented by an embedder to manage large host OS allocations.
349
+ */
350
+ class PageAllocator {
351
+ public:
352
+ virtual ~PageAllocator() = default;
353
+
354
+ /**
355
+ * Gets the page granularity for AllocatePages and FreePages. Addresses and
356
+ * lengths for those calls should be multiples of AllocatePageSize().
357
+ */
358
+ virtual size_t AllocatePageSize() = 0;
359
+
360
+ /**
361
+ * Gets the page granularity for SetPermissions and ReleasePages. Addresses
362
+ * and lengths for those calls should be multiples of CommitPageSize().
363
+ */
364
+ virtual size_t CommitPageSize() = 0;
365
+
366
+ /**
367
+ * Sets the random seed so that GetRandomMmapAddr() will generate repeatable
368
+ * sequences of random mmap addresses.
369
+ */
370
+ virtual void SetRandomMmapSeed(int64_t seed) = 0;
371
+
372
+ /**
373
+ * Returns a randomized address, suitable for memory allocation under ASLR.
374
+ * The address will be aligned to AllocatePageSize.
375
+ */
376
+ virtual void* GetRandomMmapAddr() = 0;
377
+
378
+ /**
379
+ * Memory permissions.
380
+ */
381
+ enum Permission {
382
+ kNoAccess,
383
+ kRead,
384
+ kReadWrite,
385
+ // TODO(hpayer): Remove this flag. Memory should never be rwx.
386
+ kReadWriteExecute,
387
+ kReadExecute,
388
+ // Set this when reserving memory that will later require kReadWriteExecute
389
+ // permissions. The resulting behavior is platform-specific, currently
390
+ // this is used to set the MAP_JIT flag on Apple Silicon.
391
+ // TODO(jkummerow): Remove this when Wasm has a platform-independent
392
+ // w^x implementation.
393
+ kNoAccessWillJitLater
394
+ };
395
+
396
+ /**
397
+ * Allocates memory in range with the given alignment and permission.
398
+ */
399
+ virtual void* AllocatePages(void* address, size_t length, size_t alignment,
400
+ Permission permissions) = 0;
401
+
402
+ /**
403
+ * Frees memory in a range that was allocated by a call to AllocatePages.
404
+ */
405
+ virtual bool FreePages(void* address, size_t length) = 0;
406
+
407
+ /**
408
+ * Releases memory in a range that was allocated by a call to AllocatePages.
409
+ */
410
+ virtual bool ReleasePages(void* address, size_t length,
411
+ size_t new_length) = 0;
412
+
413
+ /**
414
+ * Sets permissions on pages in an allocated range.
415
+ */
416
+ virtual bool SetPermissions(void* address, size_t length,
417
+ Permission permissions) = 0;
418
+
419
+ /**
420
+ * Frees memory in the given [address, address + size) range. address and size
421
+ * should be operating system page-aligned. The next write to this
422
+ * memory area brings the memory transparently back.
423
+ */
424
+ virtual bool DiscardSystemPages(void* address, size_t size) { return true; }
425
+
426
+ /**
427
+ * INTERNAL ONLY: This interface has not been stabilised and may change
428
+ * without notice from one release to another without being deprecated first.
429
+ */
430
+ class SharedMemoryMapping {
431
+ public:
432
+ // Implementations are expected to free the shared memory mapping in the
433
+ // destructor.
434
+ virtual ~SharedMemoryMapping() = default;
435
+ virtual void* GetMemory() const = 0;
436
+ };
437
+
438
+ /**
439
+ * INTERNAL ONLY: This interface has not been stabilised and may change
440
+ * without notice from one release to another without being deprecated first.
441
+ */
442
+ class SharedMemory {
443
+ public:
444
+ // Implementations are expected to free the shared memory in the destructor.
445
+ virtual ~SharedMemory() = default;
446
+ virtual std::unique_ptr<SharedMemoryMapping> RemapTo(
447
+ void* new_address) const = 0;
448
+ virtual void* GetMemory() const = 0;
449
+ virtual size_t GetSize() const = 0;
450
+ };
451
+
452
+ /**
453
+ * INTERNAL ONLY: This interface has not been stabilised and may change
454
+ * without notice from one release to another without being deprecated first.
455
+ *
456
+ * Reserve pages at a fixed address returning whether the reservation is
457
+ * possible. The reserved memory is detached from the PageAllocator and so
458
+ * should not be freed by it. It's intended for use with
459
+ * SharedMemory::RemapTo, where ~SharedMemoryMapping would free the memory.
460
+ */
461
+ virtual bool ReserveForSharedMemoryMapping(void* address, size_t size) {
462
+ return false;
463
+ }
464
+
465
+ /**
466
+ * INTERNAL ONLY: This interface has not been stabilised and may change
467
+ * without notice from one release to another without being deprecated first.
468
+ *
469
+ * Allocates shared memory pages. Not all PageAllocators need support this and
470
+ * so this method need not be overridden.
471
+ * Allocates a new read-only shared memory region of size |length| and copies
472
+ * the memory at |original_address| into it.
473
+ */
474
+ virtual std::unique_ptr<SharedMemory> AllocateSharedPages(
475
+ size_t length, const void* original_address) {
476
+ return {};
477
+ }
478
+
479
+ /**
480
+ * INTERNAL ONLY: This interface has not been stabilised and may change
481
+ * without notice from one release to another without being deprecated first.
482
+ *
483
+ * If not overridden and changed to return true, V8 will not attempt to call
484
+ * AllocateSharedPages or RemapSharedPages. If overridden, AllocateSharedPages
485
+ * and RemapSharedPages must also be overridden.
486
+ */
487
+ virtual bool CanAllocateSharedPages() { return false; }
488
+ };
489
+
490
+ /**
491
+ * V8 Platform abstraction layer.
492
+ *
493
+ * The embedder has to provide an implementation of this interface before
494
+ * initializing the rest of V8.
495
+ */
496
+ class Platform {
497
+ public:
498
+ virtual ~Platform() = default;
499
+
500
+ /**
501
+ * Allows the embedder to manage memory page allocations.
502
+ */
503
+ virtual PageAllocator* GetPageAllocator() {
504
+ // TODO(bbudge) Make this abstract after all embedders implement this.
505
+ return nullptr;
506
+ }
507
+
508
+ /**
509
+ * Enables the embedder to respond in cases where V8 can't allocate large
510
+ * blocks of memory. V8 retries the failed allocation once after calling this
511
+ * method. On success, execution continues; otherwise V8 exits with a fatal
512
+ * error.
513
+ * Embedder overrides of this function must NOT call back into V8.
514
+ */
515
+ virtual void OnCriticalMemoryPressure() {
516
+ // TODO(bbudge) Remove this when embedders override the following method.
517
+ // See crbug.com/634547.
518
+ }
519
+
520
+ /**
521
+ * Enables the embedder to respond in cases where V8 can't allocate large
522
+ * memory regions. The |length| parameter is the amount of memory needed.
523
+ * Returns true if memory is now available. Returns false if no memory could
524
+ * be made available. V8 will retry allocations until this method returns
525
+ * false.
526
+ *
527
+ * Embedder overrides of this function must NOT call back into V8.
528
+ */
529
+ virtual bool OnCriticalMemoryPressure(size_t length) { return false; }
530
+
531
+ /**
532
+ * Gets the number of worker threads used by
533
+ * Call(BlockingTask)OnWorkerThread(). This can be used to estimate the number
534
+ * of tasks a work package should be split into. A return value of 0 means
535
+ * that there are no worker threads available. Note that a value of 0 won't
536
+ * prohibit V8 from posting tasks using |CallOnWorkerThread|.
537
+ */
538
+ virtual int NumberOfWorkerThreads() = 0;
539
+
540
+ /**
541
+ * Returns a TaskRunner which can be used to post a task on the foreground.
542
+ * The TaskRunner's NonNestableTasksEnabled() must be true. This function
543
+ * should only be called from a foreground thread.
544
+ */
545
+ virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
546
+ Isolate* isolate) = 0;
547
+
548
+ /**
549
+ * Schedules a task to be invoked on a worker thread.
550
+ */
551
+ virtual void CallOnWorkerThread(std::unique_ptr<Task> task) = 0;
552
+
553
+ /**
554
+ * Schedules a task that blocks the main thread to be invoked with
555
+ * high-priority on a worker thread.
556
+ */
557
+ virtual void CallBlockingTaskOnWorkerThread(std::unique_ptr<Task> task) {
558
+ // Embedders may optionally override this to process these tasks in a high
559
+ // priority pool.
560
+ CallOnWorkerThread(std::move(task));
561
+ }
562
+
563
+ /**
564
+ * Schedules a task to be invoked with low-priority on a worker thread.
565
+ */
566
+ virtual void CallLowPriorityTaskOnWorkerThread(std::unique_ptr<Task> task) {
567
+ // Embedders may optionally override this to process these tasks in a low
568
+ // priority pool.
569
+ CallOnWorkerThread(std::move(task));
570
+ }
571
+
572
+ /**
573
+ * Schedules a task to be invoked on a worker thread after |delay_in_seconds|
574
+ * expires.
575
+ */
576
+ virtual void CallDelayedOnWorkerThread(std::unique_ptr<Task> task,
577
+ double delay_in_seconds) = 0;
578
+
579
+ /**
580
+ * Returns true if idle tasks are enabled for the given |isolate|.
581
+ */
582
+ virtual bool IdleTasksEnabled(Isolate* isolate) { return false; }
583
+
584
+ /**
585
+ * Posts |job_task| to run in parallel. Returns a JobHandle associated with
586
+ * the Job, which can be joined or canceled.
587
+ * This avoids degenerate cases:
588
+ * - Calling CallOnWorkerThread() for each work item, causing significant
589
+ * overhead.
590
+ * - Fixed number of CallOnWorkerThread() calls that split the work and might
591
+ * run for a long time. This is problematic when many components post
592
+ * "num cores" tasks and all expect to use all the cores. In these cases,
593
+ * the scheduler lacks context to be fair to multiple same-priority requests
594
+ * and/or ability to request lower priority work to yield when high priority
595
+ * work comes in.
596
+ * A canonical implementation of |job_task| looks like:
597
+ * class MyJobTask : public JobTask {
598
+ * public:
599
+ * MyJobTask(...) : worker_queue_(...) {}
600
+ * // JobTask:
601
+ * void Run(JobDelegate* delegate) override {
602
+ * while (!delegate->ShouldYield()) {
603
+ * // Smallest unit of work.
604
+ * auto work_item = worker_queue_.TakeWorkItem(); // Thread safe.
605
+ * if (!work_item) return;
606
+ * ProcessWork(work_item);
607
+ * }
608
+ * }
609
+ *
610
+ * size_t GetMaxConcurrency() const override {
611
+ * return worker_queue_.GetSize(); // Thread safe.
612
+ * }
613
+ * };
614
+ * auto handle = PostJob(TaskPriority::kUserVisible,
615
+ * std::make_unique<MyJobTask>(...));
616
+ * handle->Join();
617
+ *
618
+ * PostJob() and methods of the returned JobHandle/JobDelegate, must never be
619
+ * called while holding a lock that could be acquired by JobTask::Run or
620
+ * JobTask::GetMaxConcurrency -- that could result in a deadlock. This is
621
+ * because [1] JobTask::GetMaxConcurrency may be invoked while holding
622
+ * internal lock (A), hence JobTask::GetMaxConcurrency can only use a lock (B)
623
+ * if that lock is *never* held while calling back into JobHandle from any
624
+ * thread (A=>B/B=>A deadlock) and [2] JobTask::Run or
625
+ * JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle
626
+ * (B=>JobHandle::foo=>B deadlock).
627
+ *
628
+ * A sufficient PostJob() implementation that uses the default Job provided in
629
+ * libplatform looks like:
630
+ * std::unique_ptr<JobHandle> PostJob(
631
+ * TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
632
+ * return v8::platform::NewDefaultJobHandle(
633
+ * this, priority, std::move(job_task), NumberOfWorkerThreads());
634
+ * }
635
+ */
636
+ virtual std::unique_ptr<JobHandle> PostJob(
637
+ TaskPriority priority, std::unique_ptr<JobTask> job_task) = 0;
638
+
639
+ /**
640
+ * Monotonically increasing time in seconds from an arbitrary fixed point in
641
+ * the past. This function is expected to return at least
642
+ * millisecond-precision values. For this reason,
643
+ * it is recommended that the fixed point be no further in the past than
644
+ * the epoch.
645
+ **/
646
+ virtual double MonotonicallyIncreasingTime() = 0;
647
+
648
+ /**
649
+ * Current wall-clock time in milliseconds since epoch.
650
+ * This function is expected to return at least millisecond-precision values.
651
+ */
652
+ virtual double CurrentClockTimeMillis() = 0;
653
+
654
+ typedef void (*StackTracePrinter)();
655
+
656
+ /**
657
+ * Returns a function pointer that print a stack trace of the current stack
658
+ * on invocation. Disables printing of the stack trace if nullptr.
659
+ */
660
+ virtual StackTracePrinter GetStackTracePrinter() { return nullptr; }
661
+
662
+ /**
663
+ * Returns an instance of a v8::TracingController. This must be non-nullptr.
664
+ */
665
+ virtual TracingController* GetTracingController() = 0;
666
+
667
+ /**
668
+ * Tells the embedder to generate and upload a crashdump during an unexpected
669
+ * but non-critical scenario.
670
+ */
671
+ virtual void DumpWithoutCrashing() {}
672
+
673
+ protected:
674
+ /**
675
+ * Default implementation of current wall-clock time in milliseconds
676
+ * since epoch. Useful for implementing |CurrentClockTimeMillis| if
677
+ * nothing special needed.
678
+ */
679
+ V8_EXPORT static double SystemClockTimeMillis();
680
+ };
681
+
682
+ } // namespace v8
683
+
684
+ #endif // V8_V8_PLATFORM_H_