From 609b29ad63ce0224f5734e1ef96503c867b04df0 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sat, 15 Oct 2022 13:33:30 -0700 Subject: [PATCH] fixup! worker: add experimental SynchronousWorker implementation --- src/node_worker.cc | 76 ++++++++++++++++++++-------------------------- 1 file changed, 33 insertions(+), 43 deletions(-) diff --git a/src/node_worker.cc b/src/node_worker.cc index 9c5c0b91f13e54..3d05cecf6f9b7c 100644 --- a/src/node_worker.cc +++ b/src/node_worker.cc @@ -1,17 +1,17 @@ #include "node_worker.h" +#include "async_wrap-inl.h" #include "base_object.h" #include "debug_utils-inl.h" #include "histogram-inl.h" #include "memory_tracker-inl.h" #include "node.h" +#include "node_buffer.h" #include "node_errors.h" #include "node_external_reference.h" -#include "node_buffer.h" #include "node_options-inl.h" #include "node_perf.h" #include "node_snapshot_builder.h" #include "util-inl.h" -#include "async_wrap-inl.h" #include "v8-local-handle.h" #include "v8-microtask-queue.h" #include "v8-snapshot.h" @@ -884,11 +884,8 @@ class SynchronousWorker final : public MemoryRetainer { static bool HasInstance(Environment* env, v8::Local value); static v8::Local GetConstructorTemplate( Environment* env); - static void Initialize( - Environment* env, - v8::Local target); - static void RegisterExternalReferences( - ExternalReferenceRegistry* registry); + static void Initialize(Environment* env, v8::Local target); + static void RegisterExternalReferences(ExternalReferenceRegistry* registry); SynchronousWorker(Environment* env, v8::Local obj); @@ -974,15 +971,13 @@ Local SynchronousWorker::GetConstructorTemplate( return tmpl; } -void SynchronousWorker::Initialize( - Environment* env, - v8::Local target) { - SetConstructorFunction( - env->context(), - target, - "SynchronousWorker", - GetConstructorTemplate(env), - SetConstructorFunctionFlag::NONE); +void SynchronousWorker::Initialize(Environment* env, + v8::Local target) { + SetConstructorFunction(env->context(), + target, + "SynchronousWorker", + GetConstructorTemplate(env), + SetConstructorFunctionFlag::NONE); NODE_DEFINE_CONSTANT(target, UV_RUN_DEFAULT); NODE_DEFINE_CONSTANT(target, UV_RUN_ONCE); @@ -1048,9 +1043,8 @@ void SynchronousWorker::New(const FunctionCallbackInfo& args) { void SynchronousWorker::Start(const FunctionCallbackInfo& args) { SynchronousWorker* self = Unwrap(args); if (self == nullptr) return; - self->Start( - args[0]->BooleanValue(args.GetIsolate()), - args[1]->BooleanValue(args.GetIsolate())); + self->Start(args[0]->BooleanValue(args.GetIsolate()), + args[1]->BooleanValue(args.GetIsolate())); } void SynchronousWorker::Stop(const FunctionCallbackInfo& args) { @@ -1118,7 +1112,7 @@ MaybeLocal SynchronousWorker::RunInCallbackScope(Local fn) { } SynchronousWorkerScope worker_scope(this); v8::Isolate* isolate = isolate_; - CallbackScope callback_scope(isolate, wrap_.Get(isolate_), { 1, 0 }); + CallbackScope callback_scope(isolate, wrap_.Get(isolate_), {1, 0}); MaybeLocal ret = fn->Call(context(), Null(isolate), 0, nullptr); if (signaled_stop_) { isolate->CancelTerminateExecution(); @@ -1145,10 +1139,10 @@ void SynchronousWorker::Start(bool own_loop, bool own_microtaskqueue) { } MicrotaskQueue* microtask_queue = - own_microtaskqueue ? - (microtask_queue_ = v8::MicrotaskQueue::New( - isolate_, v8::MicrotasksPolicy::kExplicit)).get() : - outer_context_.Get(isolate_)->GetMicrotaskQueue(); + own_microtaskqueue ? (microtask_queue_ = v8::MicrotaskQueue::New( + isolate_, v8::MicrotasksPolicy::kExplicit)) + .get() + : outer_context_.Get(isolate_)->GetMicrotaskQueue(); uv_loop_t* loop = own_loop ? &loop_ : GetCurrentEventLoop(isolate_); Local context = Context::New( @@ -1174,20 +1168,18 @@ void SynchronousWorker::Start(bool own_loop, bool own_microtaskqueue) { ThreadId thread_id = AllocateEnvironmentThreadId(); auto inspector_parent_handle = GetInspectorParentHandle( outer_env, thread_id, "file:///synchronous-worker.js"); - env_ = CreateEnvironment( - isolate_data_, - context, - {}, - {}, - static_cast( - EnvironmentFlags::kTrackUnmanagedFds | - EnvironmentFlags::kNoRegisterESMLoader), - thread_id, - std::move(inspector_parent_handle)); + env_ = CreateEnvironment(isolate_data_, + context, + {}, + {}, + static_cast( + EnvironmentFlags::kTrackUnmanagedFds | + EnvironmentFlags::kNoRegisterESMLoader), + thread_id, + std::move(inspector_parent_handle)); assert(env_ != nullptr); - SetProcessExitHandler(env_, [this](Environment* env, int code) { - OnExit(code); - }); + SetProcessExitHandler(env_, + [this](Environment* env, int code) { OnExit(code); }); } void SynchronousWorker::OnExit(int code) { @@ -1198,10 +1190,11 @@ void SynchronousWorker::OnExit(int code) { Isolate::SafeForTerminationScope termination_scope(isolate_); Local onexit_v; if (!self->Get(outer_context, String::NewFromUtf8Literal(isolate_, "onexit")) - .ToLocal(&onexit_v) || !onexit_v->IsFunction()) { + .ToLocal(&onexit_v) || + !onexit_v->IsFunction()) { return; } - Local args[] = { Integer::New(isolate_, code) }; + Local args[] = {Integer::New(isolate_, code)}; USE(onexit_v.As()->Call(outer_context, self, 1, args)); SignalStop(); } @@ -1266,10 +1259,7 @@ MaybeLocal SynchronousWorker::Load(Local callback) { return worker_scope.EscapeMaybe( LoadEnvironment(env_, [&](const StartExecutionCallbackInfo& info) { Local argv[] = { - info.process_object, - info.native_require, - context()->Global() - }; + info.process_object, info.native_require, context()->Global()}; return callback->Call(context(), Null(isolate_), 3, argv); })); }