[vm/sendport] Do port handler lookup and message dispatch in one dart call.

This improves performance of SendPort.Receive.Nop benchmark with isolate groups enabled on Intel Xeon by ~17%.
This benchmark emphasizes performance of handle message flow.

Issue #46752

TEST=ci

Change-Id: I3b9be3283047631e8989bb56f90af2b3b007afe8
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/209642
Commit-Queue: Alexander Aprelev <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: aam

runtime/vm/dart_entry.cc

@@ -727,7 +727,7 @@ ObjectPtr DartLibraryCalls::LookupOpenPorts() {
   return result.ptr();
 }
 
-ObjectPtr DartLibraryCalls::HandleMessage(const Object& handler,
+ObjectPtr DartLibraryCalls::HandleMessage(Dart_Port port_id,
                                           const Instance& message) {
   auto thread = Thread::Current();
   auto zone = thread->zone();
@@ -743,7 +743,7 @@ ObjectPtr DartLibraryCalls::HandleMessage(const Object& handler,
     args = Array::New(kNumArguments);
     isolate->isolate_object_store()->set_dart_args_2(args);
   }
-  args.SetAt(0, handler);
+  args.SetAt(0, Integer::Handle(zone, Integer::New(port_id)));
   args.SetAt(1, message);
 #if !defined(PRODUCT)
   if (isolate->debugger()->IsStepping()) {
@@ -753,10 +753,9 @@ ObjectPtr DartLibraryCalls::HandleMessage(const Object& handler,
     isolate->debugger()->SetResumeAction(Debugger::kStepInto);
   }
 #endif
-  const Object& result =
+  const Object& handler =
       Object::Handle(zone, DartEntry::InvokeFunction(function, args));
-  ASSERT(result.IsNull() || result.IsError());
-  return result.ptr();
+  return handler.ptr();
 }
 
 ObjectPtr DartLibraryCalls::DrainMicrotaskQueue() {

runtime/vm/dart_entry.h

@@ -291,12 +291,13 @@ class DartLibraryCalls : public AllStatic {
   // Returns the handler if one has been registered for this port id.
   static ObjectPtr LookupHandler(Dart_Port port_id);
 
+  // Returns handler on success, an ErrorPtr on failure, null if can't find
+  // handler for this port id.
+  static ObjectPtr HandleMessage(Dart_Port port_id, const Instance& message);
+
   // Returns a list of open ReceivePorts.
   static ObjectPtr LookupOpenPorts();
 
-  // Returns null on success, an ErrorPtr on failure.
-  static ObjectPtr HandleMessage(const Object& handler,
-                                 const Instance& dart_message);
 
   // Returns null on success, an ErrorPtr on failure.
   static ObjectPtr DrainMicrotaskQueue();

runtime/vm/isolate.cc

@@ -1307,26 +1307,6 @@ MessageHandler::MessageStatus IsolateMessageHandler::HandleMessage(
   tbes.CopyArgument(0, "isolateName", I->name());
 #endif
 
-  // If the message is in band we lookup the handler to dispatch to.  If the
-  // receive port was closed, we drop the message without deserializing it.
-  // Illegal port is a special case for artificially enqueued isolate library
-  // messages which are handled in C++ code below.
-  Object& msg_handler = Object::Handle(zone);
-  if (!message->IsOOB() && (message->dest_port() != Message::kIllegalPort)) {
-    msg_handler = DartLibraryCalls::LookupHandler(message->dest_port());
-    if (msg_handler.IsError()) {
-      return ProcessUnhandledException(Error::Cast(msg_handler));
-    }
-    if (msg_handler.IsNull()) {
-      // If the port has been closed then the message will be dropped at this
-      // point. Make sure to post to the delivery failure port in that case.
-      if (message->RedirectToDeliveryFailurePort()) {
-        PortMap::PostMessage(std::move(message));
-      }
-      return kOK;
-    }
-  }
-
   // Parse the message.
   Object& msg_obj = Object::Handle(zone, ReadMessage(thread, message.get()));
   if (msg_obj.IsError()) {
@@ -1414,12 +1394,18 @@ MessageHandler::MessageStatus IsolateMessageHandler::HandleMessage(
       tbes.CopyArgument(1, "mode", "basic");
     }
 #endif
-    const Object& result =
-        Object::Handle(zone, DartLibraryCalls::HandleMessage(msg_handler, msg));
-    if (result.IsError()) {
-      status = ProcessUnhandledException(Error::Cast(result));
+    const Object& msg_handler = Object::Handle(
+        zone, DartLibraryCalls::HandleMessage(message->dest_port(), msg));
+    if (msg_handler.IsError()) {
+      status = ProcessUnhandledException(Error::Cast(msg_handler));
+    } else if (msg_handler.IsNull()) {
+      // If the port has been closed then the message will be dropped at this
+      // point. Make sure to post to the delivery failure port in that case.
+      if (message->RedirectToDeliveryFailurePort()) {
+        PortMap::PostMessage(std::move(message));
+      }
     } else {
-      ASSERT(result.IsNull());
+      // The handler closure which was used to successfully handle the message.
     }
   }
   return status;

sdk/lib/_internal/vm/lib/isolate_patch.dart

@@ -175,14 +175,19 @@ class _RawReceivePortImpl implements RawReceivePort {
     return _portMap.values.map((e) => e['port']).toList();
   }
 
-  // Called from the VM to dispatch to the handler.
+  // Called from the VM to retrieve  the handler and handle a message.
   @pragma("vm:entry-point", "call")
-  static void _handleMessage(Function handler, var message) {
+  static _handleMessage(int id, var message) {
+    final handler = _portMap[id]?['handler'];
+    if (handler == null) {
+      return null;
+    }
     // TODO(floitsch): this relies on the fact that any exception aborts the
     // VM. Once we have non-fatal global exceptions we need to catch errors
     // so that we can run the immediate callbacks.
     handler(message);
     _runPendingImmediateCallback();
+    return handler;
   }
 
   // Call into the VM to close the VM maintained mappings.