more test updates (deadlocks) and adapt some blocking function to be more explicit

Author: vtjnash

llvm/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h

@@ -20,6 +20,7 @@
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Error.h"
@@ -34,6 +35,11 @@
 #include <mutex>
 
 namespace llvm {
+
+namespace orc {
+class ExecutorProcessControl;
+}
+
 namespace jitlink {
 
 class Block;
@@ -132,14 +138,15 @@ class LLVM_ABI JITLinkMemoryManager {
     /// Called to transfer working memory to the target and apply finalization.
     virtual void finalize(OnFinalizedFunction OnFinalized) = 0;
 
-    /// Synchronous convenience version of finalize.
-    Expected<FinalizedAlloc> finalize() {
-      std::promise<MSVCPExpected<FinalizedAlloc>> FinalizeResultP;
+    /// Co-synchronous convenience version of finalize.
+    Expected<FinalizedAlloc> finalize(orc::TaskDispatcher &D) {
+      orc::promise<MSVCPExpected<FinalizedAlloc>> FinalizeResultP;
       auto FinalizeResultF = FinalizeResultP.get_future();
-      finalize([&](Expected<FinalizedAlloc> Result) {
+      finalize([FinalizeResultP = std::move(FinalizeResultP)](
+                   Expected<FinalizedAlloc> Result) mutable {
         FinalizeResultP.set_value(std::move(Result));
       });
-      return FinalizeResultF.get();
+      return FinalizeResultF.get(D);
     }
   };
 
@@ -163,14 +170,17 @@ class LLVM_ABI JITLinkMemoryManager {
   virtual void allocate(const JITLinkDylib *JD, LinkGraph &G,
                         OnAllocatedFunction OnAllocated) = 0;
 
-  /// Convenience function for blocking allocation.
-  AllocResult allocate(const JITLinkDylib *JD, LinkGraph &G) {
-    std::promise<MSVCPExpected<std::unique_ptr<InFlightAlloc>>> AllocResultP;
+  /// Convenience function for co-blocking allocation.
+  AllocResult allocate(const JITLinkDylib *JD, LinkGraph &G,
+                       orc::TaskDispatcher &D) {
+    orc::promise<MSVCPExpected<std::unique_ptr<InFlightAlloc>>> AllocResultP;
     auto AllocResultF = AllocResultP.get_future();
-    allocate(JD, G, [&](AllocResult Alloc) {
-      AllocResultP.set_value(std::move(Alloc));
-    });
-    return AllocResultF.get();
+    allocate(
+        JD, G,
+        [AllocResultP = std::move(AllocResultP)](AllocResult Alloc) mutable {
+          AllocResultP.set_value(std::move(Alloc));
+        });
+    return AllocResultF.get(D);
   }
 
   /// Deallocate a list of allocation objects.
@@ -187,20 +197,22 @@ class LLVM_ABI JITLinkMemoryManager {
     deallocate(std::move(Allocs), std::move(OnDeallocated));
   }
 
-  /// Convenience function for blocking deallocation.
-  Error deallocate(std::vector<FinalizedAlloc> Allocs) {
-    std::promise<MSVCPError> DeallocResultP;
+  /// Convenience function for co-blocking deallocation.
+  Error deallocate(std::vector<FinalizedAlloc> Allocs, orc::TaskDispatcher &D) {
+    orc::promise<MSVCPError> DeallocResultP;
     auto DeallocResultF = DeallocResultP.get_future();
     deallocate(std::move(Allocs),
-               [&](Error Err) { DeallocResultP.set_value(std::move(Err)); });
-    return DeallocResultF.get();
+               [DeallocResultP = std::move(DeallocResultP)](Error Err) mutable {
+                 DeallocResultP.set_value(std::move(Err));
+               });
+    return DeallocResultF.get(D);
   }
 
-  /// Convenience function for blocking deallocation of a single alloc.
-  Error deallocate(FinalizedAlloc Alloc) {
+  /// Convenience function for co-blocking deallocation of a single alloc.
+  Error deallocate(FinalizedAlloc Alloc, orc::TaskDispatcher &D) {
     std::vector<FinalizedAlloc> Allocs;
     Allocs.push_back(std::move(Alloc));
-    return deallocate(std::move(Allocs));
+    return deallocate(std::move(Allocs), D);
   }
 };
 
@@ -326,10 +338,12 @@ class SimpleSegmentAlloc {
                               Triple TT, const JITLinkDylib *JD,
                               SegmentMap Segments, OnCreatedFunction OnCreated);
 
+  // The blocking version of this should be deprecated, and requires an
+  // TaskDispatcher for co-async correctness.
   LLVM_ABI static Expected<SimpleSegmentAlloc>
   Create(JITLinkMemoryManager &MemMgr,
          std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
-         const JITLinkDylib *JD, SegmentMap Segments);
+         const JITLinkDylib *JD, SegmentMap Segments, orc::TaskDispatcher &D);
 
   LLVM_ABI SimpleSegmentAlloc(SimpleSegmentAlloc &&);
   LLVM_ABI SimpleSegmentAlloc &operator=(SimpleSegmentAlloc &&);
@@ -343,9 +357,10 @@ class SimpleSegmentAlloc {
     Alloc->finalize(std::move(OnFinalized));
   }
 
-  /// Finalize all groups.
-  Expected<JITLinkMemoryManager::FinalizedAlloc> finalize() {
-    return Alloc->finalize();
+  /// Finalize all groups (deprecated co-blocking version).
+  Expected<JITLinkMemoryManager::FinalizedAlloc>
+  finalize(orc::TaskDispatcher &D) {
+    return Alloc->finalize(D);
   }
 
 private:

llvm/include/llvm/ExecutionEngine/Orc/DylibManager.h

@@ -14,6 +14,7 @@
 #define LLVM_EXECUTIONENGINE_ORC_DYLIBMANAGER_H
 
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/InProcessMemoryAccess.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include "llvm/Support/Compiler.h"
@@ -75,104 +76,7 @@ class LLVM_ABI DylibManager : public ExecutorProcessControl {
                                   SymbolLookupCompleteFn F) = 0;
 };
 
-/// A ExecutorProcessControl instance that asserts if any of its methods are
-/// used. Suitable for use is unit tests, and by ORC clients who haven't moved
-/// to ExecutorProcessControl-based APIs yet.
-class UnsupportedExecutorProcessControl : public DylibManager,
-                                          private InProcessMemoryAccess {
-public:
-  UnsupportedExecutorProcessControl(
-      std::shared_ptr<SymbolStringPool> SSP = nullptr,
-      std::unique_ptr<TaskDispatcher> D = nullptr, const std::string &TT = "",
-      unsigned PageSize = 0)
-      : DylibManager(
-            SSP ? std::move(SSP) : std::make_shared<SymbolStringPool>(),
-            D ? std::move(D) : std::make_unique<InPlaceTaskDispatcher>()),
-        InProcessMemoryAccess(*this, Triple(TT).isArch64Bit()) {
-    this->TargetTriple = Triple(TT);
-    this->PageSize = PageSize;
-    this->MemAccess = this;
-  }
-
-  Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
-                              ArrayRef<std::string> Args) override {
-    llvm_unreachable("Unsupported");
-  }
-
-  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override {
-    llvm_unreachable("Unsupported");
-  }
-
-  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override {
-    llvm_unreachable("Unsupported");
-  }
-
-  void callWrapperAsync(ExecutorAddr WrapperFnAddr,
-                        IncomingWFRHandler OnComplete,
-                        ArrayRef<char> ArgBuffer) override {
-    llvm_unreachable("Unsupported");
-  }
-
-  Error disconnect() override { return Error::success(); }
-
-  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override {
-    return make_error<StringError>("Unsupported", inconvertibleErrorCode());
-  }
-
-  void lookupSymbolsAsync(ArrayRef<LookupRequest> Request,
-                          SymbolLookupCompleteFn F) override {
-    F(make_error<StringError>("Unsupported", inconvertibleErrorCode()));
-  }
-};
-
-/// A ExecutorProcessControl implementation targeting the current process.
-class LLVM_ABI SelfExecutorProcessControl : public DylibManager,
-                                            private InProcessMemoryAccess {
-public:
-  SelfExecutorProcessControl(
-      std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
-      Triple TargetTriple, unsigned PageSize,
-      std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
-
-  /// Create a SelfExecutorProcessControl with the given symbol string pool and
-  /// memory manager.
-  /// If no symbol string pool is given then one will be created.
-  /// If no memory manager is given a jitlink::InProcessMemoryManager will
-  /// be created and used by default.
-  static Expected<std::unique_ptr<SelfExecutorProcessControl>>
-  Create(std::shared_ptr<SymbolStringPool> SSP = nullptr,
-         std::unique_ptr<TaskDispatcher> D = nullptr,
-         std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
-
-  Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
-                              ArrayRef<std::string> Args) override;
-
-  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override;
 
-  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override;
-
-  void callWrapperAsync(ExecutorAddr WrapperFnAddr,
-                        IncomingWFRHandler OnComplete,
-                        ArrayRef<char> ArgBuffer) override;
-
-  Error disconnect() override;
-
-private:
-  static shared::CWrapperFunctionResult
-  jitDispatchViaWrapperFunctionManager(void *Ctx, const void *FnTag,
-                                       const char *Data, size_t Size);
-
-  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
-
-  void lookupSymbolsAsync(ArrayRef<LookupRequest> Request,
-                          SymbolLookupCompleteFn F) override;
-
-  std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
-#ifdef __APPLE__
-  std::unique_ptr<UnwindInfoManager> UnwindInfoMgr;
-#endif // __APPLE__
-  char GlobalManglingPrefix = 0;
-};
 
 } // end namespace llvm::orc
 

llvm/include/llvm/ExecutionEngine/Orc/EPCGenericMemoryAccess.h

@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Implements ExecutorProcessControl::MemoryAccess by making calls to
+// Implements MemoryAccess by making calls to
 // ExecutorProcessControl::callWrapperAsync.
 //
 // This simplifies the implementaton of new ExecutorProcessControl instances,
@@ -19,6 +19,7 @@
 #define LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
 
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/MemoryAccess.h"
 
 namespace llvm {
 namespace orc {
@@ -107,8 +108,7 @@ class EPCGenericMemoryAccess : public MemoryAccess {
   void readUInt16sAsync(ArrayRef<ExecutorAddr> Rs,
                         OnReadUIntsCompleteFn<uint16_t> OnComplete) override {
     using namespace shared;
-    EPC.callSPSWrapperAsync<SPSSequence<uint16_t>(
-        SPSSequence<SPSExecutorAddr>)>(
+    EPC.callSPSWrapperAsync<SPSSequence<uint16_t>(SPSSequence<SPSExecutorAddr>)>(
         FAs.ReadUInt16s,
         [OnComplete = std::move(OnComplete)](
             Error Err, ReadUIntsResult<uint16_t> Result) mutable {
@@ -123,8 +123,7 @@ class EPCGenericMemoryAccess : public MemoryAccess {
   void readUInt32sAsync(ArrayRef<ExecutorAddr> Rs,
                         OnReadUIntsCompleteFn<uint32_t> OnComplete) override {
     using namespace shared;
-    EPC.callSPSWrapperAsync<SPSSequence<uint32_t>(
-        SPSSequence<SPSExecutorAddr>)>(
+    EPC.callSPSWrapperAsync<SPSSequence<uint32_t>(SPSSequence<SPSExecutorAddr>)>(
         FAs.ReadUInt32s,
         [OnComplete = std::move(OnComplete)](
             Error Err, ReadUIntsResult<uint32_t> Result) mutable {
@@ -139,8 +138,7 @@ class EPCGenericMemoryAccess : public MemoryAccess {
   void readUInt64sAsync(ArrayRef<ExecutorAddr> Rs,
                         OnReadUIntsCompleteFn<uint64_t> OnComplete) override {
     using namespace shared;
-    EPC.callSPSWrapperAsync<SPSSequence<uint64_t>(
-        SPSSequence<SPSExecutorAddr>)>(
+    EPC.callSPSWrapperAsync<SPSSequence<uint64_t>(SPSSequence<SPSExecutorAddr>)>(
         FAs.ReadUInt64s,
         [OnComplete = std::move(OnComplete)](
             Error Err, ReadUIntsResult<uint64_t> Result) mutable {