[vm/shared] Introduce NativeCallable.isolateGroupShared

This method allows for synchronous execution of dart callbacks from native code. The execution happens on dart mutator thread, from which dart code can only access isolate-group variables - those which are tagged with .

Bug: #54530
Bug: #56841
Change-Id: Ia1a6b01327be493f003f1eea82e558bb6b147dd3
CoreLibraryReviewExempt: only internal library change
TEST=isolate_group_shared_callback_test
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/422920
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Aprelev <[email protected]>

Author: aam

BUILD.gn

@@ -49,6 +49,7 @@ group("runtime") {
     "runtime/vm:kernel_platform_files($host_toolchain)",
     "samples/embedder:kernel",
     "samples/ffi/http:fake_http",
+    "samples/ffi/httpIG:fake_httpIG",
     "utils/dartdev:dartdev",
     "utils/kernel-service:kernel-service",
   ]
@@ -308,6 +309,7 @@ if (is_fuchsia) {
     "tests/ffi/inline_array_test.dart",
     "tests/ffi/inline_array_variable_length_test.dart",
     "tests/ffi/invoke_callback_after_suspension_test.dart",
+    "tests/ffi/isolate_group_shared_callback_test.dart",
     "tests/ffi/isolate_local_function_callbacks_test.dart",
     "tests/ffi/msan_test.dart",
     "tests/ffi/native_assets/asset_absolute_test.dart",

pkg/vm/lib/modular/transformations/ffi/common.dart

@@ -313,7 +313,10 @@ class FfiTransformer extends Transformer {
   final Procedure nativeCallbackFunctionProcedure;
   final Procedure nativeAsyncCallbackFunctionProcedure;
   final Procedure createNativeCallableIsolateLocalProcedure;
+  final Procedure createNativeCallableIsolateGroupSharedProcedure;
   final Procedure nativeIsolateLocalCallbackFunctionProcedure;
+  final Procedure nativeIsolateGroupSharedCallbackFunctionProcedure;
+  final Procedure nativeIsolateGroupSharedClosureFunctionProcedure;
   final Map<NativeType, Procedure> loadMethods;
   final Map<NativeType, Procedure> loadUnalignedMethods;
   final Map<NativeType, Procedure> storeMethods;
@@ -337,7 +340,9 @@ class FfiTransformer extends Transformer {
   final Class rawRecvPortClass;
   final Class nativeCallableClass;
   final Procedure nativeCallableIsolateLocalConstructor;
+  final Procedure nativeCallableIsolateGroupSharedConstructor;
   final Constructor nativeCallablePrivateIsolateLocalConstructor;
+  final Constructor nativeCallablePrivateIsolateGroupSharedConstructor;
   final Procedure nativeCallableListenerConstructor;
   final Constructor nativeCallablePrivateListenerConstructor;
   final Field nativeCallablePortField;
@@ -821,6 +826,11 @@ class FfiTransformer extends Transformer {
         'dart:ffi',
         '_createNativeCallableIsolateLocal',
       ),
+      createNativeCallableIsolateGroupSharedProcedure = index
+          .getTopLevelProcedure(
+            'dart:ffi',
+            '_createNativeCallableIsolateGroupShared',
+          ),
       nativeCallbackFunctionProcedure = index.getTopLevelProcedure(
         'dart:ffi',
         '_nativeCallbackFunction',
@@ -833,6 +843,16 @@ class FfiTransformer extends Transformer {
         'dart:ffi',
         '_nativeIsolateLocalCallbackFunction',
       ),
+      nativeIsolateGroupSharedCallbackFunctionProcedure = index
+          .getTopLevelProcedure(
+            'dart:ffi',
+            '_nativeIsolateGroupSharedCallbackFunction',
+          ),
+      nativeIsolateGroupSharedClosureFunctionProcedure = index
+          .getTopLevelProcedure(
+            'dart:ffi',
+            '_nativeIsolateGroupSharedClosureFunction',
+          ),
       nativeTypesClasses = nativeTypeClassNames.map(
         (nativeType, name) =>
             MapEntry(nativeType, index.getClass('dart:ffi', name)),
@@ -937,6 +957,11 @@ class FfiTransformer extends Transformer {
         'NativeCallable',
         'isolateLocal',
       ),
+      nativeCallableIsolateGroupSharedConstructor = index.getProcedure(
+        'dart:ffi',
+        'NativeCallable',
+        'isolateGroupShared',
+      ),
       nativeCallablePrivateIsolateLocalConstructor = index.getConstructor(
         'dart:ffi',
         '_NativeCallableIsolateLocal',
@@ -952,6 +977,11 @@ class FfiTransformer extends Transformer {
         '_NativeCallableListener',
         '',
       ),
+      nativeCallablePrivateIsolateGroupSharedConstructor = index.getConstructor(
+        'dart:ffi',
+        '_NativeCallableIsolateGroupShared',
+        '',
+      ),
       nativeCallablePortField = index.getField(
         'dart:ffi',
         '_NativeCallableListener',

pkg/vm/lib/modular/transformations/ffi/use_sites.dart

@@ -570,6 +570,11 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
         );
       } else if (target == nativeCallableIsolateLocalConstructor) {
         return _verifyAndReplaceNativeCallableIsolateLocal(node);
+      } else if (target == nativeCallableIsolateGroupSharedConstructor) {
+        return _verifyAndReplaceNativeCallable(
+          node,
+          replacement: _replaceNativeCallableIsolateGroupSharedConstructor,
+        );
       } else if (target == nativeCallableListenerConstructor) {
         final DartType nativeType = InterfaceType(
           nativeFunctionClass,
@@ -881,18 +886,18 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
   }
 
   // NativeCallable<T>.isolateLocal(target, exceptionalReturn) calls become:
-  // isStaticFunction is false:
-  //   _NativeCallableIsolateLocal<T>(
-  //       _createNativeCallableIsolateLocal<NativeFunction<T>>(
-  //           _nativeIsolateLocalCallbackFunction<T>(exceptionalReturn),
-  //           target,
-  //           true));
   // isStaticFunction is true:
   //   _NativeCallableIsolateLocal<T>(
   //       _createNativeCallableIsolateLocal<NativeFunction<T>>(
   //           _nativeCallbackFunction<T>(target, exceptionalReturn),
   //           null,
   //           true);
+  // isStaticFunction is false:
+  //   _NativeCallableIsolateLocal<T>(
+  //       _createNativeCallableIsolateLocal<NativeFunction<T>>(
+  //           _nativeIsolateLocalCallbackFunction<T>(exceptionalReturn),
+  //           target,
+  //           true));
   Expression _replaceNativeCallableIsolateLocalConstructor(
     StaticInvocation node,
     Expression exceptionalReturn,
@@ -949,7 +954,7 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
   // void _handler(List args) => target(args[0], args[1], ...)
   // final _callback = _NativeCallableListener<T>(_handler, debugName);
   // _callback._pointer = _createNativeCallableListener<NativeFunction<T>>(
-  //       _nativeAsyncCallbackFunction<T>(), _callback._rawPort);
+  //       _nativeAsyncCallbackFunction<T>(), _callback._port);
   // expression result: _callback;
   Expression _replaceNativeCallableListenerConstructor(StaticInvocation node) {
     final nativeFunctionType = InterfaceType(
@@ -1017,7 +1022,7 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
     )..fileOffset = node.fileOffset;
 
     // _callback._pointer = _createNativeCallableListener<NativeFunction<T>>(
-    //       _nativeAsyncCallbackFunction<T>(), _callback._rawPort);
+    //       _nativeAsyncCallbackFunction<T>(), _callback._port);
     final pointerValue = StaticInvocation(
       createNativeCallableListenerProcedure,
       Arguments(
@@ -1054,9 +1059,73 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
     );
   }
 
-  Expression _verifyAndReplaceNativeCallableIsolateLocal(
+  // NativeCallable<T>.isolateGroupShared(target, exceptionalReturn) calls become:
+  // isStaticFunction is true:
+  //   _NativeCallableIsolateGroupShared<T>(
+  //       _createNativeCallableIsolateGroupShared<NativeFunction<T>>(
+  //           _nativeIsolateGroupSharedCallbackFunction<T>(target, exceptionalReturn),
+  //           null);
+  // isStaticFunction is false:
+  //   _NativeCallableIsolateGroupShared<T>(
+  //       _createNativeCallableIsolateGroupShared<NativeFunction<T>>(
+  //           _nativeIsolateGroupSharedClosureFunction<T>(exceptionalReturn),
+  //           target));
+  Expression _replaceNativeCallableIsolateGroupSharedConstructor(
+    StaticInvocation node,
+    Expression exceptionalReturn,
+    bool isStaticFunction,
+  ) {
+    final nativeFunctionType = InterfaceType(
+      nativeFunctionClass,
+      currentLibrary.nonNullable,
+      node.arguments.types,
+    );
+    final target = node.arguments.positional[0];
+    late StaticInvocation pointerValue;
+    if (isStaticFunction) {
+      pointerValue = StaticInvocation(
+        createNativeCallableIsolateGroupSharedProcedure,
+        Arguments(
+          [
+            StaticInvocation(
+              nativeIsolateGroupSharedCallbackFunctionProcedure,
+              Arguments([
+                target,
+                exceptionalReturn,
+              ], types: node.arguments.types),
+            ),
+            NullLiteral(),
+          ],
+          types: [nativeFunctionType],
+        ),
+      );
+    } else {
+      pointerValue = StaticInvocation(
+        createNativeCallableIsolateGroupSharedProcedure,
+        Arguments(
+          [
+            StaticInvocation(
+              nativeIsolateGroupSharedClosureFunctionProcedure,
+              Arguments([exceptionalReturn], types: node.arguments.types),
+            ),
+            target,
+          ],
+          types: [nativeFunctionType],
+        ),
+      );
+    }
+
+    return ConstructorInvocation(
+      nativeCallablePrivateIsolateGroupSharedConstructor,
+      Arguments([pointerValue], types: node.arguments.types),
+    );
+  }
+
+  Expression _verifyAndReplaceNativeCallable(
     StaticInvocation node, {
     bool fromFunction = false,
+    required Expression Function(StaticInvocation, Expression, bool)
+    replacement,
   }) {
     final DartType nativeType = InterfaceType(
       nativeFunctionClass,
@@ -1188,15 +1257,6 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
       }
     }
 
-    final replacement =
-        fromFunction
-            ? _replaceFromFunction(node, exceptionalReturn)
-            : _replaceNativeCallableIsolateLocalConstructor(
-              node,
-              exceptionalReturn,
-              isStaticFunction,
-            );
-
     final compoundClasses =
         funcType.positionalParameters
             .whereType<InterfaceType>()
@@ -1205,7 +1265,25 @@ mixin _FfiUseSiteTransformer on FfiTransformer {
               (c) => c.superclass == structClass || c.superclass == unionClass,
             )
             .toList();
-    return invokeCompoundConstructors(replacement, compoundClasses);
+    return invokeCompoundConstructors(
+      replacement(node, exceptionalReturn, isStaticFunction),
+      compoundClasses,
+    );
+  }
+
+  Expression _verifyAndReplaceNativeCallableIsolateLocal(
+    StaticInvocation node, {
+    bool fromFunction = false,
+  }) {
+    return _verifyAndReplaceNativeCallable(
+      node,
+      fromFunction: fromFunction,
+      replacement:
+          fromFunction
+              ? (node, exceptionalReturn, _) =>
+                  _replaceFromFunction(node, exceptionalReturn)
+              : _replaceNativeCallableIsolateLocalConstructor,
+    );
   }
 
   Expression _replaceGetRef(StaticInvocation node) {

pubspec.yaml

@@ -78,6 +78,7 @@ workspace:
   - pkg/wasm_builder
   - runtime/tools/profiling
   - samples/ffi/http
+  - samples/ffi/httpIG
   # dap and language_server_protocol are checked in to and
   # developed in the SDK repo, though they are located in `third_party/`.
   - third_party/pkg/dap

runtime/bin/ffi_test/ffi_test_functions.cc

@@ -66,6 +66,12 @@ DART_EXPORT Coord GetGlobalStruct() {
   return globalStruct;
 }
 
+DART_EXPORT void SleepFor(int32_t ms) {
+  std::cout << "Sleeping for " << ms << " milliseconds...\n";
+  std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+  std::cout << "done\n";
+}
+
 // Sums two ints and adds 42.
 // Simple function to test trampolines.
 // Also used for testing argument exception on passing null instead of a Dart

runtime/lib/ffi.cc

@@ -46,6 +46,14 @@ DEFINE_NATIVE_ENTRY(Ffi_createNativeCallableIsolateLocal, 1, 3) {
       zone, trampoline, target, keep_isolate_alive));
 }
 
+DEFINE_NATIVE_ENTRY(Ffi_createNativeCallableIsolateGroupShared, 1, 2) {
+  const auto& trampoline =
+      Function::CheckedHandle(zone, arguments->NativeArg0());
+  const auto& target = Closure::CheckedHandle(zone, arguments->NativeArgAt(1));
+  return Pointer::New(
+      isolate->CreateIsolateGroupSharedFfiCallback(zone, trampoline, target));
+}
+
 DEFINE_NATIVE_ENTRY(Ffi_deleteNativeCallable, 1, 1) {
   const auto& pointer = Pointer::CheckedHandle(zone, arguments->NativeArg0());
   isolate->DeleteFfiCallback(pointer.NativeAddress());

runtime/vm/bootstrap_natives.h

@@ -300,6 +300,7 @@ namespace dart {
   V(VMService_RemoveUserTagsFromStreamableSampleList, 1)                       \
   V(Ffi_createNativeCallableListener, 2)                                       \
   V(Ffi_createNativeCallableIsolateLocal, 3)                                   \
+  V(Ffi_createNativeCallableIsolateGroupShared, 2)                             \
   V(Ffi_deleteNativeCallable, 1)                                               \
   V(Ffi_updateNativeCallableKeepIsolateAliveCounter, 1)                        \
   V(Ffi_dl_open, 1)                                                            \

runtime/vm/bss_relocs.cc

@@ -35,6 +35,9 @@ void BSS::Initialize(Thread* current, uword* bss_start, bool vm) {
   InitializeBSSEntry(Relocation::DLRT_ExitTemporaryIsolate,
                      reinterpret_cast<uword>(DLRT_ExitTemporaryIsolate),
                      bss_start);
+  InitializeBSSEntry(
+      Relocation::DLRT_ExitIsolateGroupSharedIsolate,
+      reinterpret_cast<uword>(DLRT_ExitIsolateGroupSharedIsolate), bss_start);
 }
 
 }  // namespace dart

runtime/vm/bss_relocs.h

@@ -18,6 +18,7 @@ class BSS : public AllStatic {
   enum class Relocation : intptr_t {
     DLRT_GetFfiCallbackMetadata,  // TODO(https://dartbug.com/52579): Remove.
     DLRT_ExitTemporaryIsolate,    // TODO(https://dartbug.com/52579): Remove.
+    DLRT_ExitIsolateGroupSharedIsolate,  // TODO(https://dartbug.com/52579)
     EndOfVmEntries,
 
     // We don't have any isolate group specific entries at the moment.

runtime/vm/compiler/ffi/callback.cc

@@ -28,6 +28,12 @@ const String& NativeCallbackFunctionName(Thread* thread,
       return String::Handle(
           zone, Symbols::FromConcat(thread, Symbols::FfiCallback(),
                                     String::Handle(zone, dart_target.name())));
+    case FfiCallbackKind::kIsolateGroupSharedClosureCallback:
+      return Symbols::FfiIsolateGroupSharedCallback();
+    case FfiCallbackKind::kIsolateGroupSharedStaticCallback:
+      return String::Handle(
+          zone, Symbols::FromConcat(thread, Symbols::FfiCallback(),
+                                    String::Handle(zone, dart_target.name())));
     default:
       UNREACHABLE();
   }

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -3390,6 +3390,12 @@ Fragment StreamingFlowGraphBuilder::BuildStaticInvocation(TokenPosition* p) {
     case MethodRecognizer::kFfiNativeIsolateLocalCallbackFunction:
       return BuildFfiNativeCallbackFunction(
           FfiCallbackKind::kIsolateLocalClosureCallback);
+    case MethodRecognizer::kFfiNativeIsolateGroupSharedCallbackFunction:
+      return BuildFfiNativeCallbackFunction(
+          FfiCallbackKind::kIsolateGroupSharedStaticCallback);
+    case MethodRecognizer::kFfiNativeIsolateGroupSharedClosureFunction:
+      return BuildFfiNativeCallbackFunction(
+          FfiCallbackKind::kIsolateGroupSharedClosureCallback);
     case MethodRecognizer::kFfiNativeAsyncCallbackFunction:
       return BuildFfiNativeCallbackFunction(FfiCallbackKind::kAsyncCallback);
     case MethodRecognizer::kFfiLoadAbiSpecificInt:
@@ -6210,16 +6216,25 @@ Fragment StreamingFlowGraphBuilder::BuildFfiNativeCallbackFunction(
   // FfiCallbackKind::kIsolateLocalStaticCallback:
   //   _nativeCallbackFunction<NativeSignatureType>(target, exceptionalReturn)
   //
+  // FfiCallbackKind::kIsolateGroupSharedStaticCallback:
+  //   _nativeCallbackFunction<NativeSignatureType>(target, exceptionalReturn)
+  //
   // FfiCallbackKind::kAsyncCallback:
   //   _nativeAsyncCallbackFunction<NativeSignatureType>()
   //
   // FfiCallbackKind::kIsolateLocalClosureCallback:
   //   _nativeIsolateLocalCallbackFunction<NativeSignatureType>(
   //       exceptionalReturn)
   //
+  // FfiCallbackKind::kIsolateGroupSharedClosureCallback:
+  //   _nativeIsolateGroupSharedCallbackFunction<NativeSignatureType>(
+  //       exceptionalReturn)
+  //
   // The FE also guarantees that the arguments are constants.
 
-  const bool has_target = kind == FfiCallbackKind::kIsolateLocalStaticCallback;
+  const bool has_target =
+      kind == FfiCallbackKind::kIsolateLocalStaticCallback ||
+      kind == FfiCallbackKind::kIsolateGroupSharedStaticCallback;
   const bool has_exceptional_return = kind != FfiCallbackKind::kAsyncCallback;
   const intptr_t expected_argc =
       static_cast<int>(has_target) + static_cast<int>(has_exceptional_return);