Skip to content

Commit 9065001

Browse files
addaleaxaddaleax
committed
src: prepare v8 platform for multi-isolate support
This splits the task queue used for asynchronous tasks scheduled by V8 in per-isolate queues, so that multiple threads can be supported. Original-PR-URL: ayojs/ayo#89 Original-Reviewed-By: Timothy Gu <timothygu99@gmail.com> PR-URL: nodejs#16700 Reviewed-By: James M Snell <jasnell@gmail.com>
1 parent 5b8e46d commit 9065001

File tree

11 files changed

+283
-103
lines changed

11 files changed

+283
-103
lines changed

‎src/env-inl.h‎

Lines changed: 7 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -37,41 +37,9 @@
3737

3838
namespace node {
3939

40-
inline IsolateData::IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,
41-
uint32_t* zero_fill_field) :
42-
43-
// Create string and private symbol properties as internalized one byte strings.
44-
//
45-
// Internalized because it makes property lookups a little faster and because
46-
// the string is created in the old space straight away. It's going to end up
47-
// in the old space sooner or later anyway but now it doesn't go through
48-
// v8::Eternal's new space handling first.
49-
//
50-
// One byte because our strings are ASCII and we can safely skip V8's UTF-8
51-
// decoding step. It's a one-time cost, but why pay it when you don't have to?
52-
#define V(PropertyName, StringValue) \
53-
PropertyName ## _( \
54-
isolate, \
55-
v8::Private::New( \
56-
isolate, \
57-
v8::String::NewFromOneByte( \
58-
isolate, \
59-
reinterpret_cast<const uint8_t*>(StringValue), \
60-
v8::NewStringType::kInternalized, \
61-
sizeof(StringValue) - 1).ToLocalChecked())),
62-
PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)
63-
#undef V
64-
#define V(PropertyName, StringValue) \
65-
PropertyName ## _( \
66-
isolate, \
67-
v8::String::NewFromOneByte( \
68-
isolate, \
69-
reinterpret_cast<const uint8_t*>(StringValue), \
70-
v8::NewStringType::kInternalized, \
71-
sizeof(StringValue) - 1).ToLocalChecked()),
72-
PER_ISOLATE_STRING_PROPERTIES(V)
73-
#undef V
74-
event_loop_(event_loop), zero_fill_field_(zero_fill_field) {}
40+
inline v8::Isolate* IsolateData::isolate() const {
41+
return isolate_;
42+
}
7543

7644
inline uv_loop_t* IsolateData::event_loop() const {
7745
return event_loop_;
@@ -81,6 +49,10 @@ inline uint32_t* IsolateData::zero_fill_field() const {
8149
return zero_fill_field_;
8250
}
8351

52+
inline MultiIsolatePlatform* IsolateData::platform() const {
53+
return platform_;
54+
}
55+
8456
inline Environment::AsyncHooks::AsyncHooks()
8557
: async_ids_stack_(env()->isolate(), 16 * 2),
8658
fields_(env()->isolate(), kFieldsCount),
@@ -93,10 +65,6 @@ inline Environment::AsyncHooks::AsyncHooks()
9365
// which is different from a default context.
9466
async_id_fields_[AsyncHooks::kDefaultTriggerAsyncId] = -1;
9567

96-
// kAsyncIdCounter should start at 1 because that'll be the id the execution
97-
// context during bootstrap (code that runs before entering uv_run()).
98-
async_id_fields_[AsyncHooks::kAsyncIdCounter] = 1;
99-
10068
// Create all the provider strings that will be passed to JS. Place them in
10169
// an array so the array index matches the PROVIDER id offset. This way the
10270
// strings can be retrieved quickly.

‎src/env.cc‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,15 @@
11
#include "node_internals.h"
22
#include "async_wrap.h"
33
#include "v8-profiler.h"
4+
#include "node_buffer.h"
5+
#include "req-wrap-inl.h"
6+
#include "node_platform.h"
7+
8+
#if defined(_MSC_VER)
9+
#define getpid GetCurrentProcessId
10+
#else
11+
#include <unistd.h>
12+
#endif
413

514
#include <stdio.h>
615
#include <algorithm>
@@ -10,10 +19,62 @@ namespace node {
1019
using v8::Context;
1120
using v8::FunctionTemplate;
1221
using v8::HandleScope;
22+
using v8::Isolate;
1323
using v8::Local;
1424
using v8::Message;
25+
using v8::Private;
1526
using v8::StackFrame;
1627
using v8::StackTrace;
28+
using v8::String;
29+
30+
IsolateData::IsolateData(Isolate* isolate,
31+
uv_loop_t* event_loop,
32+
MultiIsolatePlatform* platform,
33+
uint32_t* zero_fill_field) :
34+
35+
// Create string and private symbol properties as internalized one byte strings.
36+
//
37+
// Internalized because it makes property lookups a little faster and because
38+
// the string is created in the old space straight away. It's going to end up
39+
// in the old space sooner or later anyway but now it doesn't go through
40+
// v8::Eternal's new space handling first.
41+
//
42+
// One byte because our strings are ASCII and we can safely skip V8's UTF-8
43+
// decoding step. It's a one-time cost, but why pay it when you don't have to?
44+
#define V(PropertyName, StringValue) \
45+
PropertyName ## _( \
46+
isolate, \
47+
Private::New( \
48+
isolate, \
49+
String::NewFromOneByte( \
50+
isolate, \
51+
reinterpret_cast<const uint8_t*>(StringValue), \
52+
v8::NewStringType::kInternalized, \
53+
sizeof(StringValue) - 1).ToLocalChecked())),
54+
PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)
55+
#undef V
56+
#define V(PropertyName, StringValue) \
57+
PropertyName ## _( \
58+
isolate, \
59+
String::NewFromOneByte( \
60+
isolate, \
61+
reinterpret_cast<const uint8_t*>(StringValue), \
62+
v8::NewStringType::kInternalized, \
63+
sizeof(StringValue) - 1).ToLocalChecked()),
64+
PER_ISOLATE_STRING_PROPERTIES(V)
65+
#undef V
66+
isolate_(isolate),
67+
event_loop_(event_loop),
68+
zero_fill_field_(zero_fill_field),
69+
platform_(platform) {
70+
if (platform_ != nullptr)
71+
platform_->RegisterIsolate(this, event_loop);
72+
}
73+
74+
IsolateData::~IsolateData() {
75+
if (platform_ != nullptr)
76+
platform_->UnregisterIsolate(this);
77+
}
1778

1879
void Environment::Start(int argc,
1980
const char* const* argv,

‎src/env.h‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -346,10 +346,13 @@ class Environment;
346346

347347
class IsolateData {
348348
public:
349-
inline IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,
350-
uint32_t* zero_fill_field = nullptr);
349+
IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,
350+
MultiIsolatePlatform* platform = nullptr,
351+
uint32_t* zero_fill_field = nullptr);
352+
~IsolateData();
351353
inline uv_loop_t* event_loop() const;
352354
inline uint32_t* zero_fill_field() const;
355+
inline MultiIsolatePlatform* platform() const;
353356

354357
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
355358
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
@@ -362,6 +365,7 @@ class IsolateData {
362365
#undef VP
363366

364367
std::unordered_map<nghttp2_rcbuf*, v8::Eternal<v8::String>> http2_static_strs;
368+
inline v8::Isolate* isolate() const;
365369

366370
private:
367371
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
@@ -374,8 +378,10 @@ class IsolateData {
374378
#undef VS
375379
#undef VP
376380

381+
v8::Isolate* const isolate_;
377382
uv_loop_t* const event_loop_;
378383
uint32_t* const zero_fill_field_;
384+
MultiIsolatePlatform* platform_;
379385

380386
DISALLOW_COPY_AND_ASSIGN(IsolateData);
381387
};

‎src/inspector_agent.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -314,7 +314,7 @@ class NodeInspectorClient : public V8InspectorClient {
314314
terminated_ = false;
315315
running_nested_loop_ = true;
316316
while (!terminated_ && channel_->waitForFrontendMessage()) {
317-
platform_->FlushForegroundTasksInternal();
317+
platform_->FlushForegroundTasks(env_->isolate());
318318
}
319319
terminated_ = false;
320320
running_nested_loop_ = false;

‎src/node.cc‎

Lines changed: 31 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -273,17 +273,17 @@ node::DebugOptions debug_options;
273273

274274
static struct {
275275
#if NODE_USE_V8_PLATFORM
276-
void Initialize(int thread_pool_size, uv_loop_t* loop) {
276+
void Initialize(int thread_pool_size) {
277277
if (trace_enabled) {
278278
tracing_agent_.reset(new tracing::Agent(trace_file_pattern));
279-
platform_ = new NodePlatform(thread_pool_size, loop,
279+
platform_ = new NodePlatform(thread_pool_size,
280280
tracing_agent_->GetTracingController());
281281
V8::InitializePlatform(platform_);
282282
tracing::TraceEventHelper::SetTracingController(
283283
tracing_agent_->GetTracingController());
284284
} else {
285285
tracing_agent_.reset(nullptr);
286-
platform_ = new NodePlatform(thread_pool_size, loop, nullptr);
286+
platform_ = new NodePlatform(thread_pool_size, nullptr);
287287
V8::InitializePlatform(platform_);
288288
tracing::TraceEventHelper::SetTracingController(
289289
new v8::TracingController());
@@ -297,8 +297,8 @@ static struct {
297297
tracing_agent_.reset(nullptr);
298298
}
299299

300-
void DrainVMTasks() {
301-
platform_->DrainBackgroundTasks();
300+
void DrainVMTasks(Isolate* isolate) {
301+
platform_->DrainBackgroundTasks(isolate);
302302
}
303303

304304
#if HAVE_INSPECTOR
@@ -323,12 +323,16 @@ static struct {
323323
tracing_agent_->Stop();
324324
}
325325

326+
NodePlatform* Platform() {
327+
return platform_;
328+
}
329+
326330
std::unique_ptr<tracing::Agent> tracing_agent_;
327331
NodePlatform* platform_;
328332
#else // !NODE_USE_V8_PLATFORM
329-
void Initialize(int thread_pool_size, uv_loop_t* loop) {}
333+
void Initialize(int thread_pool_size) {}
330334
void Dispose() {}
331-
void DrainVMTasks() {}
335+
void DrainVMTasks(Isolate* isolate) {}
332336
bool StartInspector(Environment *env, const char* script_path,
333337
const node::DebugOptions& options) {
334338
env->ThrowError("Node compiled with NODE_USE_V8_PLATFORM=0");
@@ -340,6 +344,10 @@ static struct {
340344
"so event tracing is not available.\n");
341345
}
342346
void StopTracingAgent() {}
347+
348+
NodePlatform* Platform() {
349+
return nullptr;
350+
}
343351
#endif // !NODE_USE_V8_PLATFORM
344352

345353
#if !NODE_USE_V8_PLATFORM || !HAVE_INSPECTOR
@@ -4734,7 +4742,14 @@ int EmitExit(Environment* env) {
47344742

47354743

47364744
IsolateData* CreateIsolateData(Isolate* isolate, uv_loop_t* loop) {
4737-
return new IsolateData(isolate, loop);
4745+
return new IsolateData(isolate, loop, nullptr);
4746+
}
4747+
4748+
IsolateData* CreateIsolateData(
4749+
Isolate* isolate,
4750+
uv_loop_t* loop,
4751+
MultiIsolatePlatform* platform) {
4752+
return new IsolateData(isolate, loop, platform);
47384753
}
47394754

47404755

@@ -4802,7 +4817,7 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
48024817
do {
48034818
uv_run(env.event_loop(), UV_RUN_DEFAULT);
48044819

4805-
v8_platform.DrainVMTasks();
4820+
v8_platform.DrainVMTasks(isolate);
48064821

48074822
more = uv_loop_alive(env.event_loop());
48084823
if (more)
@@ -4823,7 +4838,7 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
48234838
RunAtExit(&env);
48244839
uv_key_delete(&thread_local_env);
48254840

4826-
v8_platform.DrainVMTasks();
4841+
v8_platform.DrainVMTasks(isolate);
48274842
WaitForInspectorDisconnect(&env);
48284843
#if defined(LEAK_SANITIZER)
48294844
__lsan_do_leak_check();
@@ -4866,7 +4881,11 @@ inline int Start(uv_loop_t* event_loop,
48664881
Locker locker(isolate);
48674882
Isolate::Scope isolate_scope(isolate);
48684883
HandleScope handle_scope(isolate);
4869-
IsolateData isolate_data(isolate, event_loop, allocator.zero_fill_field());
4884+
IsolateData isolate_data(
4885+
isolate,
4886+
event_loop,
4887+
v8_platform.Platform(),
4888+
allocator.zero_fill_field());
48704889
exit_code = Start(isolate, &isolate_data, argc, argv, exec_argc, exec_argv);
48714890
}
48724891

@@ -4913,7 +4932,7 @@ int Start(int argc, char** argv) {
49134932
V8::SetEntropySource(crypto::EntropySource);
49144933
#endif // HAVE_OPENSSL
49154934

4916-
v8_platform.Initialize(v8_thread_pool_size, uv_default_loop());
4935+
v8_platform.Initialize(v8_thread_pool_size);
49174936
// Enable tracing when argv has --trace-events-enabled.
49184937
if (trace_enabled) {
49194938
fprintf(stderr, "Warning: Trace event is an experimental feature "

‎src/node.h‎

Lines changed: 22 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@
6161
#endif
6262

6363
#include "v8.h" // NOLINT(build/include_order)
64+
#include "v8-platform.h" // NOLINT(build/include_order)
6465
#include "node_version.h" // NODE_MODULE_VERSION
6566

6667
#define NODE_MAKE_VERSION(major, minor, patch) \
@@ -208,8 +209,27 @@ NODE_EXTERN void Init(int* argc,
208209
class IsolateData;
209210
class Environment;
210211

211-
NODE_EXTERN IsolateData* CreateIsolateData(v8::Isolate* isolate,
212-
struct uv_loop_s* loop);
212+
class MultiIsolatePlatform : public v8::Platform {
213+
public:
214+
virtual ~MultiIsolatePlatform() { }
215+
virtual void DrainBackgroundTasks(v8::Isolate* isolate) = 0;
216+
217+
// These will be called by the `IsolateData` creation/destruction functions.
218+
virtual void RegisterIsolate(IsolateData* isolate_data,
219+
struct uv_loop_s* loop) = 0;
220+
virtual void UnregisterIsolate(IsolateData* isolate_data) = 0;
221+
};
222+
223+
// If `platform` is passed, it will be used to register new Worker instances.
224+
// It can be `nullptr`, in which case creating new Workers inside of
225+
// Environments that use this `IsolateData` will not work.
226+
NODE_EXTERN IsolateData* CreateIsolateData(
227+
v8::Isolate* isolate,
228+
struct uv_loop_s* loop);
229+
NODE_EXTERN IsolateData* CreateIsolateData(
230+
v8::Isolate* isolate,
231+
struct uv_loop_s* loop,
232+
MultiIsolatePlatform* platform);
213233
NODE_EXTERN void FreeIsolateData(IsolateData* isolate_data);
214234

215235
NODE_EXTERN Environment* CreateEnvironment(IsolateData* isolate_data,

0 commit comments

Comments
 (0)