src: fast path empty native immediate drain

Signed-off-by: Gürgün Dayıoğlu <[email protected]>

Author: gurgunday

src/env.cc

@@ -1414,6 +1414,15 @@ void Environment::RunAndClearInterrupts() {
 void Environment::RunAndClearNativeImmediates(bool only_refed) {
   TRACE_EVENT0(TRACING_CATEGORY_NODE1(environment),
                "RunAndClearNativeImmediates");
+  // Skip the callback scope on the common empty path. These are the only
+  // queues drained by this function. If a threadsafe immediate is queued
+  // concurrently after this check, uv_async_send() schedules another drain.
+  if (native_immediates_.size() == 0 &&
+      native_immediates_threadsafe_.size() == 0 &&
+      native_immediates_interrupts_.size() == 0) {
+    return;
+  }
+
   HandleScope handle_scope(isolate_);
   // In case the Isolate is no longer accessible just use an empty Local. This
   // is not an issue for InternalCallbackScope as this case is already handled

test/cctest/test_environment.cc

@@ -401,6 +401,69 @@ TEST_F(EnvironmentTest, SetImmediateCleanup) {
   EXPECT_EQ(called_unref, 0);
 }
 
+TEST_F(EnvironmentTest, RunAndClearNativeImmediatesSkipsEmptyScope) {
+  const v8::HandleScope handle_scope(isolate_);
+  const Argv argv;
+  Env env{handle_scope, argv};
+  v8::Local<v8::Context> context = env.context();
+
+  using IntVec = std::vector<int>;
+  IntVec callback_calls;
+  v8::Local<v8::Function> must_call =
+      v8::Function::New(
+          context,
+          [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+            IntVec* callback_calls =
+                static_cast<IntVec*>(info.Data().As<v8::External>()->Value(
+                    v8::kExternalPointerTypeTagDefault));
+            callback_calls->push_back(info[0].As<v8::Int32>()->Value());
+          },
+          v8::External::New(isolate_,
+                            static_cast<void*>(&callback_calls),
+                            v8::kExternalPointerTypeTagDefault))
+          .ToLocalChecked();
+  context->Global()
+      ->Set(context,
+            v8::String::NewFromUtf8Literal(isolate_, "mustCall"),
+            must_call)
+      .Check();
+
+  v8::Local<v8::Function> eval_in_env =
+      node::LoadEnvironment(*env, "return eval;")
+          .ToLocalChecked()
+          .As<v8::Function>();
+
+  v8::Local<v8::Value> queue_microtask = v8::String::NewFromUtf8Literal(
+      isolate_, "Promise.resolve().then(() => mustCall(1));");
+  eval_in_env->Call(context, v8::Null(isolate_), 1, &queue_microtask)
+      .ToLocalChecked();
+  EXPECT_TRUE(callback_calls.empty());
+  (*env)->RunAndClearNativeImmediates();
+  EXPECT_TRUE(callback_calls.empty());
+
+  context->GetMicrotaskQueue()->PerformCheckpoint(isolate_);
+  EXPECT_EQ(callback_calls, (IntVec{1}));
+  callback_calls.clear();
+
+  queue_microtask = v8::String::NewFromUtf8Literal(
+      isolate_, "Promise.resolve().then(() => mustCall(2));");
+  eval_in_env->Call(context, v8::Null(isolate_), 1, &queue_microtask)
+      .ToLocalChecked();
+  EXPECT_TRUE(callback_calls.empty());
+
+  bool native_immediate_called = false;
+  (*env)->SetImmediate(
+      [&](node::Environment* env_arg) {
+        EXPECT_EQ(env_arg, *env);
+        native_immediate_called = true;
+      },
+      node::CallbackFlags::kRefed);
+
+  (*env)->RunAndClearNativeImmediates();
+  EXPECT_TRUE(native_immediate_called);
+  EXPECT_EQ(callback_calls, (IntVec{2}));
+}
+
 static char hello[] = "hello";
 
 TEST_F(EnvironmentTest, BufferWithFreeCallbackIsDetached) {