Merge pull request #38819 from etcwilde/ewilde/remove-runAsyncAndBlock-internals

Remove run async and block internals

Author: etcwilde

include/swift/Runtime/Concurrency.h

@@ -618,19 +618,6 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 NearestTaskDeadline
 swift_task_getNearestDeadline(AsyncTask *task);
 
-/// Run the given async function and block the current thread until
-/// it returns.  This is a hack added for testing purposes; eventually
-/// top-level code will be an async context, and the need for this in
-/// tests should go away.  We *definitely* do not want this to be part
-/// of the standard feature set.
-///
-/// The argument is a `() async -> ()` function, whose ABI is currently
-/// quite complex.  Eventually this should use a different convention;
-/// that's rdar://72105841.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_runAndBlockThread(const void *function,
-                                  HeapObject *functionContext);
-
 /// Switch the current task to a new executor if we aren't already
 /// running on a compatible executor.
 ///

stdlib/public/Concurrency/AsyncCall.h

@@ -24,7 +24,6 @@
 #include "swift/Runtime/HeapObject.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "TaskPrivate.h"
-#include "AsyncCall.h"
 #include "Debug.h"
 
 #if !defined(_WIN32)

stdlib/public/Concurrency/AsyncLet.cpp

@@ -24,7 +24,6 @@
 #include "swift/Runtime/HeapObject.h"
 #include "TaskGroupPrivate.h"
 #include "TaskPrivate.h"
-#include "AsyncCall.h"
 #include "Debug.h"
 #include "Error.h"
 
@@ -857,126 +856,6 @@ void swift_task_future_wait_throwingImpl(
   }
 }
 
-namespace {
-
-#if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
-
-class RunAndBlockSemaphore {
-  bool Finished = false;
-public:
-  void wait() {
-    donateThreadToGlobalExecutorUntil([](void *context) {
-      return *reinterpret_cast<bool*>(context);
-    }, &Finished);
-
-    assert(Finished && "ran out of tasks before we were signalled");
-  }
-
-  void signal() {
-    Finished = true;
-  }
-};
-
-#else
-
-class RunAndBlockSemaphore {
-  ConditionVariable Queue;
-  ConditionVariable::Mutex Lock;
-  bool Finished = false;
-public:
-  /// Wait for a signal.
-  void wait() {
-    Lock.withLockOrWait(Queue, [&] {
-      return Finished;
-    });
-  }
-
-  void signal() {
-    Lock.withLockThenNotifyAll(Queue, [&]{
-      Finished = true;
-    });
-  }
-};
-
-#endif
-
-using RunAndBlockSignature =
-  AsyncSignature<void(HeapObject*), /*throws*/ false>;
-struct RunAndBlockContext: AsyncContext {
-  const void *Function;
-  HeapObject *FunctionContext;
-  RunAndBlockSemaphore *Semaphore;
-};
-using RunAndBlockCalleeContext =
-  AsyncCalleeContext<RunAndBlockContext, RunAndBlockSignature>;
-
-} // end anonymous namespace
-
-/// Second half of the runAndBlock async function.
-SWIFT_CC(swiftasync)
-static void runAndBlock_finish(SWIFT_ASYNC_CONTEXT AsyncContext *_context) {
-  auto calleeContext = static_cast<RunAndBlockCalleeContext*>(_context);
-
-  auto context = popAsyncContext(calleeContext);
-
-  context->Semaphore->signal();
-
-  return context->ResumeParent(context);
-}
-
-/// First half of the runAndBlock async function.
-SWIFT_CC(swiftasync)
-static void runAndBlock_start(SWIFT_ASYNC_CONTEXT AsyncContext *_context,
-                              SWIFT_CONTEXT HeapObject *closureContext) {
-  auto callerContext = static_cast<RunAndBlockContext*>(_context);
-
-  RunAndBlockSignature::FunctionType *function;
-  size_t calleeContextSize;
-  auto functionContext = callerContext->FunctionContext;
-  assert(closureContext == functionContext);
-  std::tie(function, calleeContextSize)
-    = getAsyncClosureEntryPointAndContextSize<
-      RunAndBlockSignature,
-      SpecialPointerAuthDiscriminators::AsyncRunAndBlockFunction
-    >(const_cast<void*>(callerContext->Function), functionContext);
-
-  auto calleeContext =
-    pushAsyncContext<RunAndBlockSignature>(callerContext,
-                                           calleeContextSize,
-                                           &runAndBlock_finish,
-                                           functionContext);
-  return reinterpret_cast<AsyncVoidClosureEntryPoint *>(function)(
-      calleeContext, functionContext);
-}
-
-// TODO: Remove this hack.
-void swift::swift_task_runAndBlockThread(const void *function,
-                                         HeapObject *functionContext) {
-  RunAndBlockSemaphore semaphore;
-
-  // Set up a task that runs the runAndBlock async function above.
-  auto flags = TaskCreateFlags();
-  flags.setPriority(JobPriority::Default);
-  auto pair = swift_task_create_common(
-      flags.getOpaqueValue(),
-      /*options=*/nullptr,
-      /*futureResultType=*/nullptr,
-      reinterpret_cast<ThinNullaryAsyncSignature::FunctionType *>(
-          &runAndBlock_start),
-      nullptr,
-      sizeof(RunAndBlockContext));
-  auto context = static_cast<RunAndBlockContext*>(pair.InitialContext);
-  context->Function = function;
-  context->FunctionContext = functionContext;
-  context->Semaphore = &semaphore;
-
-  // Enqueue the task.
-  swift_task_enqueueGlobal(pair.Task);
-
-  // Wait until the task completes.
-  semaphore.wait();
-}
-
 size_t swift::swift_task_getJobFlags(AsyncTask *task) {
   return task->Flags.getOpaqueValue();
 }

stdlib/public/Concurrency/Task.cpp

@@ -28,7 +28,6 @@
 #include "swift/Runtime/Config.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/HeapObject.h"
-#include "AsyncCall.h"
 #include "Debug.h"
 #include "bitset"
 #include "string"