[Concurrency] Implement isIsolatingCurrentContext requirement and mode

Author: ktoso

include/swift/Runtime/Concurrency.h

@@ -773,8 +773,8 @@ void swift_task_enqueue(Job *job, SerialExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobal(Job *job);
 
-/// Invoke an executor's `checkIsolated` or otherwise equivalent API,
-/// that will crash if the current executor is NOT the passed executor.
+/// Invoke an executor's `checkIsolated` implementation;
+/// It will crash if the current executor is NOT the passed executor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_checkIsolated(SerialExecutorRef executor);
 
@@ -785,6 +785,15 @@ void swift_task_checkIsolated(SerialExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_invokeSwiftCheckIsolated(SerialExecutorRef executor);
 
+/// Invoke an executor's `isIsolatingCurrentContext` implementation;
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+bool swift_task_isIsolatingCurrentContext(SerialExecutorRef executor);
+
+/// Invoke a Swift executor's `isIsolatingCurrentContext` implementation; returns
+/// `true` if it invoked the Swift implementation, `false` otherwise.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+bool swift_task_invokeSwiftIsIsolatingCurrentContext(SerialExecutorRef executor);
+
 /// A count in nanoseconds.
 using JobDelay = unsigned long long;
 
@@ -1037,6 +1046,10 @@ enum swift_task_is_current_executor_flag : uint64_t {
 
   /// The routine should assert on failure.
   Assert = 0x8,
+
+  /// The routine should use 'isIsolatingCurrentContext' function on the
+  /// 'expected' executor instead of
+  HasIsIsolatingCurrentContext = 0x10,
 };
 
 SWIFT_EXPORT_FROM(swift_Concurrency)

include/swift/Runtime/ConcurrencyHooks.def

@@ -44,7 +44,11 @@ SWIFT_CONCURRENCY_HOOK(void, swift_task_enqueueGlobalWithDeadline,
     long long tnsec,
     int clock, Job *job);
 
-SWIFT_CONCURRENCY_HOOK(void, swift_task_checkIsolated, SerialExecutorRef executor);
+SWIFT_CONCURRENCY_HOOK(void, swift_task_checkIsolated,
+    SerialExecutorRef executor);
+
+SWIFT_CONCURRENCY_HOOK(bool, swift_task_isIsolatingCurrentContext,
+    SerialExecutorRef executor);
 
 SWIFT_CONCURRENCY_HOOK(bool, swift_task_isOnExecutor,
     HeapObject *executor,

stdlib/public/Concurrency/Actor.cpp

@@ -341,13 +341,15 @@ enum IsCurrentExecutorCheckMode : unsigned {
 
 // Shimming call to Swift runtime because Swift Embedded does not have
 // these symbols defined.
-bool __swift_bincompat_useLegacyNonCrashingExecutorChecks() {
+swift_task_is_current_executor_flag
+__swift_bincompat_useLegacyNonCrashingExecutorChecks() {
 #if !SWIFT_CONCURRENCY_EMBEDDED
-  return swift::runtime::bincompat::
-      swift_bincompat_useLegacyNonCrashingExecutorChecks();
-#else
-  return false;
+  if (swift::runtime::bincompat::
+      swift_bincompat_useLegacyNonCrashingExecutorChecks()) {
+    return swift_task_is_current_executor_flag::None;
+  }
 #endif
+  return swift_task_is_current_executor_flag::Assert;
 }
 
 // Shimming call to Swift runtime because Swift Embedded does not have
@@ -364,22 +366,40 @@ const char *__swift_runtime_env_useLegacyNonCrashingExecutorChecks() {
 
 // Done this way because of the interaction with the initial value of
 // 'unexpectedExecutorLogLevel'
-bool swift_bincompat_useLegacyNonCrashingExecutorChecks() {
-  bool legacyMode = __swift_bincompat_useLegacyNonCrashingExecutorChecks();
+swift_task_is_current_executor_flag swift_bincompat_useLegacyNonCrashingExecutorChecks() {
+  swift_task_is_current_executor_flag options =
+      __swift_bincompat_useLegacyNonCrashingExecutorChecks();
 
   // Potentially, override the platform detected mode, primarily used in tests.
   if (const char *modeStr =
           __swift_runtime_env_useLegacyNonCrashingExecutorChecks()) {
+    SWIFT_TASK_DEBUG_LOG("executor checking: SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE = '%s'", modeStr);
     if (strcmp(modeStr, "nocrash") == 0 ||
         strcmp(modeStr, "legacy") == 0) {
-      return true;
+        SWIFT_TASK_DEBUG_LOG("executor checking: SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE = %s => NONE; options = %d",
+                           modeStr, options);
+        options = swift_task_is_current_executor_flag(
+          swift_task_is_current_executor_flag::None);
+    }
+
+    if (strcmp(modeStr, "swift62") == 0) {
+      options = swift_task_is_current_executor_flag(
+        options | swift_task_is_current_executor_flag::HasIsIsolatingCurrentContext);
+      // When we're using the isIsolatingCurrentContext we don't want to use crashing APIs,
+      // so disable it explicitly.
+      options = swift_task_is_current_executor_flag(
+        options & ~swift_task_is_current_executor_flag::Assert);
+      SWIFT_TASK_DEBUG_LOG("executor checking: SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE = %s => 6.2; options = %d", modeStr, options);
     } else if (strcmp(modeStr, "crash") == 0 ||
                strcmp(modeStr, "swift6") == 0) {
-      return false; // don't use the legacy mode
+      options = swift_task_is_current_executor_flag(
+        options | swift_task_is_current_executor_flag::Assert);
+      SWIFT_TASK_DEBUG_LOG("executor checking: SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE = %s => 6.9; options = %d", modeStr, options);
     } // else, just use the platform detected mode
   } // no override, use the default mode
 
-  return legacyMode;
+  SWIFT_TASK_DEBUG_LOG("executor checking: options = %d", options);
+  return options;
 }
 
 // Implemented in Swift to avoid some annoying hard-coding about
@@ -407,6 +427,13 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
     swift_task_is_current_executor_flag flags) {
   auto options = SwiftTaskIsCurrentExecutorOptions(flags);
   auto current = ExecutorTrackingInfo::current();
+  SWIFT_TASK_DEBUG_LOG("executor checking: current task %p", current);
+#ifndef NDEBUG
+  if (options.contains(swift_task_is_current_executor_flag::Assert))
+    SWIFT_TASK_DEBUG_LOG("executor checking: active option = Assert (%d)", flags);
+  if (options.contains(swift_task_is_current_executor_flag::HasIsIsolatingCurrentContext))
+    SWIFT_TASK_DEBUG_LOG("executor checking: active option = HasIsIsolatingCurrentContext (%d)", flags);
+#endif
 
   if (!current) {
     // We have no current executor, i.e. we are running "outside" of Swift
@@ -416,15 +443,30 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
 
     // Special handling the main executor by detecting the main thread.
     if (expectedExecutor.isMainExecutor() && isExecutingOnMainThread()) {
+      SWIFT_TASK_DEBUG_LOG("executor checking: expected is main executor & current thread is main thread => pass", nullptr);
       return true;
     }
 
     // We cannot use 'complexEquality' as it requires two executor instances,
     // and we do not have a 'current' executor here.
 
+    if (options.contains(swift_task_is_current_executor_flag::HasIsIsolatingCurrentContext)) {
+      SWIFT_TASK_DEBUG_LOG("executor checking mode option: HasIsIsolatingCurrentContext; invoke (%p).isIsolatingCurrentContext",
+                           expectedExecutor.getIdentity());
+      // The executor has the most recent 'isIsolatingCurrentContext' API
+      // so available so we prefer calling that to 'checkIsolated'.
+      auto result = swift_task_isIsolatingCurrentContext(expectedExecutor);
+
+      SWIFT_TASK_DEBUG_LOG("executor checking mode option: HasIsIsolatingCurrentContext; invoke (%p).isIsolatingCurrentContext => %s",
+                     expectedExecutor.getIdentity(), result ? "pass" : "fail");
+      return result;
+    }
+
     // Otherwise, as last resort, let the expected executor check using
     // external means, as it may "know" this thread is managed by it etc.
     if (options.contains(swift_task_is_current_executor_flag::Assert)) {
+      SWIFT_TASK_DEBUG_LOG("executor checking mode option: Assert; invoke (%p).expectedExecutor",
+                           expectedExecutor.getIdentity());
       swift_task_checkIsolated(expectedExecutor); // will crash if not same context
 
       // checkIsolated did not crash, so we are on the right executor, after all!
@@ -436,16 +478,23 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
   }
 
   SerialExecutorRef currentExecutor = current->getActiveExecutor();
+  SWIFT_TASK_DEBUG_LOG("executor checking: current executor %p %s",
+                       currentExecutor.getIdentity(), currentExecutor.getIdentityDebugName());
 
   // Fast-path: the executor is exactly the same memory address;
   // We assume executors do not come-and-go appearing under the same address,
   // and treat pointer equality of executors as good enough to assume the executor.
   if (currentExecutor == expectedExecutor) {
+    SWIFT_TASK_DEBUG_LOG("executor checking: current executor %p, equal to expected executor => pass",
+                         currentExecutor.getIdentity());
     return true;
   }
 
   // Fast-path, specialize the common case of comparing two main executors.
   if (currentExecutor.isMainExecutor() && expectedExecutor.isMainExecutor()) {
+    SWIFT_TASK_DEBUG_LOG("executor checking: current executor %p is main executor, and expected executor (%p) is main executor => pass",
+                     currentExecutor.getIdentity(),
+                     expectedExecutor.getIdentity());
     return true;
   }
 
@@ -463,8 +512,16 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
   // or confirm we actually are on the main queue; or the custom expected
   // executor has a chance to implement a similar queue check.
   if (!options.contains(swift_task_is_current_executor_flag::Assert)) {
-    if ((expectedExecutor.isMainExecutor() && !currentExecutor.isMainExecutor()) ||
-        (!expectedExecutor.isMainExecutor() && currentExecutor.isMainExecutor())) {
+    if ((expectedExecutor.isMainExecutor() && !currentExecutor.isMainExecutor())) {
+      SWIFT_TASK_DEBUG_LOG("executor checking: expected executor %p%s is main executor, and current executor %p%s is NOT => fail",
+                 expectedExecutor.getIdentity(), expectedExecutor.getIdentityDebugName(),
+                 currentExecutor.getIdentity(), currentExecutor.getIdentityDebugName());
+      return false;
+    }
+    if ((!expectedExecutor.isMainExecutor() && currentExecutor.isMainExecutor())) {
+      SWIFT_TASK_DEBUG_LOG("executor checking: expected executor %p%s is NOT main executor, and current executor %p%s is => fail",
+           expectedExecutor.getIdentity(), expectedExecutor.getIdentityDebugName(),
+           currentExecutor.getIdentity(), currentExecutor.getIdentityDebugName());
       return false;
     }
   }
@@ -487,6 +544,8 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
                 currentExecutor.getSerialExecutorWitnessTable()),
             reinterpret_cast<const WitnessTable *>(
                 expectedExecutor.getSerialExecutorWitnessTable()))) {
+      SWIFT_TASK_DEBUG_LOG("executor checking: can check isComplexEquality (%p, and %p)",
+           expectedExecutor.getIdentity(), currentExecutor.getIdentity());
 
       auto isSameExclusiveExecutionContextResult =
           _task_serialExecutor_isSameExclusiveExecutionContext(
@@ -498,11 +557,25 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
       // it and return; if it was false, we need to give checkIsolated another
       // chance to check.
       if (isSameExclusiveExecutionContextResult) {
+        SWIFT_TASK_DEBUG_LOG("executor checking: isComplexEquality (%p, and %p) is true => pass",
+             expectedExecutor.getIdentity(), currentExecutor.getIdentity());
         return true;
       } // else, we must give 'checkIsolated' a last chance to verify isolation
     }
   }
 
+  if (options.contains(swift_task_is_current_executor_flag::HasIsIsolatingCurrentContext)) {
+    // We can invoke the 'isIsolatingCurrentContext' function.
+    SWIFT_TASK_DEBUG_LOG("executor checking: can call (%p).isIsolatingCurrentContext",
+    expectedExecutor.getIdentity());
+
+    bool checkResult = swift_task_isIsolatingCurrentContext(expectedExecutor);
+
+    SWIFT_TASK_DEBUG_LOG("executor checking: can call (%p).isIsolatingCurrentContext => %p",
+      expectedExecutor.getIdentity(), checkResult ? "pass" : "fail");
+    return checkResult;
+  }
+
   // This provides a last-resort check by giving the expected SerialExecutor the
   // chance to perform a check using some external knowledge if perhaps we are,
   // after all, on this executor, but the Swift concurrency runtime was just not
@@ -524,9 +597,13 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
   // synchronous, and will not cause suspensions, as that would require the
   // presence of a Task.
   if (options.contains(swift_task_is_current_executor_flag::Assert)) {
+    SWIFT_TASK_DEBUG_LOG("executor checking: call (%p).checkIsolated",
+      expectedExecutor.getIdentity());
     swift_task_checkIsolated(expectedExecutor); // will crash if not same context
 
     // The checkIsolated call did not crash, so we are on the right executor.
+    SWIFT_TASK_DEBUG_LOG("executor checking: call (%p).checkIsolated passed => pass",
+      expectedExecutor.getIdentity());
     return true;
   }
 
@@ -538,12 +615,23 @@ static bool swift_task_isCurrentExecutorWithFlagsImpl(
 
 // Check override of executor checking mode.
 static void swift_task_setDefaultExecutorCheckingFlags(void *context) {
-  bool useLegacyMode = swift_bincompat_useLegacyNonCrashingExecutorChecks();
-  auto checkMode = static_cast<swift_task_is_current_executor_flag *>(context);
-  if (!useLegacyMode) {
-    *checkMode = swift_task_is_current_executor_flag(
-        *checkMode | swift_task_is_current_executor_flag::Assert);
-  }
+  SWIFT_TASK_DEBUG_LOG("executor checking: swift_task_setDefaultExecutorCheckingFlags = %d", nullptr);
+  auto useLegacyMode = swift_bincompat_useLegacyNonCrashingExecutorChecks();
+  SWIFT_TASK_DEBUG_LOG("executor checking: use legacy mode = %d", useLegacyMode);
+  auto *options = static_cast<swift_task_is_current_executor_flag *>(context);
+  SWIFT_TASK_DEBUG_LOG("executor checking: options = %d", *options);
+//  if (!useLegacyMode) {
+//    *options = swift_task_is_current_executor_flag(
+//        *options | swift_task_is_current_executor_flag::Assert);
+//  }
+  *options = useLegacyMode;
+  SWIFT_TASK_DEBUG_LOG("executor checking: resulting options = %d", *options);
+  SWIFT_TASK_DEBUG_LOG("executor checking: option Assert = %d",
+                       SwiftTaskIsCurrentExecutorOptions(*options).
+                       contains(swift_task_is_current_executor_flag::Assert));
+  SWIFT_TASK_DEBUG_LOG("executor checking: option HasIsIsolatingCurrentContext = %d",
+                       SwiftTaskIsCurrentExecutorOptions(*options).
+                       contains(swift_task_is_current_executor_flag::HasIsIsolatingCurrentContext));
 }
 
 SWIFT_CC(swift)
@@ -2294,8 +2382,7 @@ static void swift_task_switchImpl(SWIFT_ASYNC_CONTEXT AsyncContext *resumeContex
                        currentTaskExecutor.getIdentity(),
                        currentTaskExecutor.isDefined() ? "" : " (undefined)",
                        newTaskExecutor.getIdentity(),
-                       newTaskExecutor.isDefined() ? "" : " (undefined)",
-                       trackingInfo->isSynchronousStart() ? "[synchronous start]" : "");
+                       newTaskExecutor.isDefined() ? "" : " (undefined)");
 
   // If the current executor is compatible with running the new executor,
   // we can just immediately continue running with the resume function

stdlib/public/Concurrency/ConcurrencyHooks.cpp

@@ -100,7 +100,8 @@ swift::swift_task_enqueueGlobalWithDeadline(
 
 SWIFT_CC(swift) static void
 swift_task_checkIsolatedOrig(SerialExecutorRef executor) {
-  swift_task_checkIsolatedImpl(*reinterpret_cast<SwiftExecutorRef *>(&executor));}
+  swift_task_checkIsolatedImpl(*reinterpret_cast<SwiftExecutorRef *>(&executor));
+}
 
 void
 swift::swift_task_checkIsolated(SerialExecutorRef executor) {
@@ -110,6 +111,20 @@ swift::swift_task_checkIsolated(SerialExecutorRef executor) {
     swift_task_checkIsolatedOrig(executor);
 }
 
+SWIFT_CC(swift) static bool
+swift_task_isIsolatingCurrentContextOrig(SerialExecutorRef executor) {
+  return swift_task_isIsolatingCurrentContextImpl(
+      *reinterpret_cast<SwiftExecutorRef *>(&executor));
+}
+
+bool
+swift::swift_task_isIsolatingCurrentContext(SerialExecutorRef executor) {
+  if (SWIFT_UNLIKELY(swift_task_isIsolatingCurrentContext_hook))
+    return swift_task_isIsolatingCurrentContext_hook(executor, swift_task_isIsolatingCurrentContextOrig);
+  else
+    return swift_task_isIsolatingCurrentContextOrig(executor);
+}
+
 // Implemented in Swift because we need to obtain the user-defined flags on the executor ref.
 //
 // We could inline this with effort, though.

stdlib/public/Concurrency/CooperativeGlobalExecutor.cpp

@@ -154,6 +154,11 @@ void swift_task_checkIsolatedImpl(SwiftExecutorRef executor) {
   swift_executor_invokeSwiftCheckIsolated(executor);
 }
 
+SWIFT_CC(swift)
+bool swift_task_isIsolatingCurrentContextImpl(SwiftExecutorRef executor) {
+  return swift_executor_invokeSwiftIsIsolatingCurrentContext(executor);
+}
+
 /// Insert a job into the cooperative global queue with a delay.
 SWIFT_CC(swift)
 void swift_task_enqueueGlobalWithDelayImpl(SwiftJobDelay delay,

stdlib/public/Concurrency/DispatchGlobalExecutor.cpp

@@ -448,6 +448,12 @@ void swift_task_checkIsolatedImpl(SwiftExecutorRef executor) {
   swift_Concurrency_fatalError(0, "Incorrect actor executor assumption");
 }
 
+SWIFT_CC(swift)
+bool swift_task_isIsolatingCurrentContextImpl(SwiftExecutorRef executor) {
+  return swift_executor_invokeSwiftIsIsolatingCurrentContext(executor);
+}
+
+
 SWIFT_CC(swift)
 SwiftExecutorRef swift_task_getMainExecutorImpl() {
   return swift_executor_ordinary(

stdlib/public/Concurrency/Executor.swift

@@ -195,6 +195,9 @@ public protocol SerialExecutor: Executor {
   @available(SwiftStdlib 6.0, *)
   func checkIsolated()
 
+  @available(SwiftStdlib 6.2, *)
+  func isIsolatingCurrentContext() -> Bool
+
 }
 
 @available(SwiftStdlib 6.0, *)
@@ -210,6 +213,16 @@ extension SerialExecutor {
   }
 }
 
+@available(SwiftStdlib 6.2, *)
+extension SerialExecutor {
+
+  @available(SwiftStdlib 6.2, *)
+  public func isIsolatingCurrentContext() -> Bool {
+    self.checkIsolated()
+    return true
+  }
+}
+
 /// An executor that may be used as preferred executor by a task.
 ///
 /// ### Impact of setting a task executor preference
@@ -467,6 +480,13 @@ internal func _task_serialExecutor_checkIsolated<E>(executor: E)
   executor.checkIsolated()
 }
 
+@available(SwiftStdlib 6.2, *)
+@_silgen_name("_task_serialExecutor_isIsolatingCurrentContext")
+internal func _task_serialExecutor_isIsolatingCurrentContext<E>(executor: E) -> Bool
+    where E: SerialExecutor {
+  return executor.isIsolatingCurrentContext()
+}
+
 /// Obtain the executor ref by calling the executor's `asUnownedSerialExecutor()`.
 /// The obtained executor ref will have all the user-defined flags set on the executor.
 @available(SwiftStdlib 5.9, *)