use TaskDispatch-safe concurrency primitives

Author: vtjnash

llvm/include/llvm/ExecutionEngine/Orc/COFFPlatform.h

@@ -22,7 +22,7 @@
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Compiler.h"
 
-#include <future>
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <list>
 #include <memory>
 #include <thread>

llvm/include/llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h

@@ -20,7 +20,7 @@
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Compiler.h"
 
-#include <future>
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <memory>
 #include <thread>
 #include <vector>

llvm/include/llvm/ExecutionEngine/Orc/Core.h

@@ -33,7 +33,7 @@
 
 #include <atomic>
 #include <deque>
-#include <future>
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <memory>
 #include <vector>
 

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

@@ -13,21 +13,25 @@
 #ifndef LLVM_EXECUTIONENGINE_ORC_DYLIBMANAGER_H
 #define LLVM_EXECUTIONENGINE_ORC_DYLIBMANAGER_H
 
+#include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
-
-#include <future>
 #include <mutex>
 #include <vector>
 
 namespace llvm::orc {
 
 class SymbolLookupSet;
 
-class LLVM_ABI DylibManager {
+class LLVM_ABI DylibManager : public ExecutorProcessControl {
 public:
+  DylibManager(std::shared_ptr<SymbolStringPool> SSP,
+               std::unique_ptr<TaskDispatcher> D)
+      : ExecutorProcessControl(std::move(SSP), std::move(D)) {}
+
   /// A pair of a dylib and a set of symbols to be looked up.
   struct LookupRequest {
     LookupRequest(tpctypes::DylibHandle Handle, const SymbolLookupSet &Symbols)
@@ -51,11 +55,11 @@ class LLVM_ABI DylibManager {
   /// symbol is not found then it be assigned a '0' value.
   Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) {
-    std::promise<MSVCPExpected<std::vector<tpctypes::LookupResult>>> RP;
+    orc::promise<MSVCPExpected<std::vector<tpctypes::LookupResult>>> RP;
     auto RF = RP.get_future();
     lookupSymbolsAsync(Request,
                        [&RP](auto Result) { RP.set_value(std::move(Result)); });
-    return RF.get();
+    return RF.get(getDispatcher());
   }
 
   using SymbolLookupCompleteFn =
@@ -71,6 +75,106 @@ class LLVM_ABI DylibManager {
                                   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
 
 #endif // LLVM_EXECUTIONENGINE_ORC_DYLIBMANAGER_H

llvm/include/llvm/ExecutionEngine/Orc/ELFNixPlatform.h

@@ -20,7 +20,7 @@
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Compiler.h"
 
-#include <future>
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include <thread>
 #include <unordered_map>
 #include <vector>

llvm/include/llvm/ExecutionEngine/Orc/EPCGenericDylibManager.h

@@ -21,6 +21,7 @@
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/Orc/Shared/SimpleRemoteEPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
@@ -53,19 +54,19 @@ class EPCGenericDylibManager {
   /// Looks up symbols within the given dylib.
   Expected<tpctypes::LookupResult> lookup(tpctypes::DylibHandle H,
                                           const SymbolLookupSet &Lookup) {
-    std::promise<MSVCPExpected<tpctypes::LookupResult>> RP;
+    orc::promise<MSVCPExpected<tpctypes::LookupResult>> RP;
     auto RF = RP.get_future();
     lookupAsync(H, Lookup, [&RP](auto R) { RP.set_value(std::move(R)); });
-    return RF.get();
+    return RF.get(EPC.getDispatcher());
   }
 
   /// Looks up symbols within the given dylib.
   Expected<tpctypes::LookupResult> lookup(tpctypes::DylibHandle H,
                                           const RemoteSymbolLookupSet &Lookup) {
-    std::promise<MSVCPExpected<tpctypes::LookupResult>> RP;
+    orc::promise<MSVCPExpected<tpctypes::LookupResult>> RP;
     auto RF = RP.get_future();
     lookupAsync(H, Lookup, [&RP](auto R) { RP.set_value(std::move(R)); });
-    return RF.get();
+    return RF.get(EPC.getDispatcher());
   }
 
   using SymbolLookupCompleteFn =

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

@@ -45,7 +45,7 @@ class EPCGenericMemoryAccess : public MemoryAccess {
   /// Create an EPCGenericMemoryAccess instance from a given set of
   /// function addrs.
   EPCGenericMemoryAccess(ExecutorProcessControl &EPC, FuncAddrs FAs)
-      : EPC(EPC), FAs(FAs) {}
+      : MemoryAccess(EPC), FAs(FAs) {}
 
   void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
                         WriteResultFn OnWriteComplete) override {
@@ -202,7 +202,6 @@ class EPCGenericMemoryAccess : public MemoryAccess {
   }
 
 private:
-  ExecutorProcessControl &EPC;
   FuncAddrs FAs;
 };
 

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

@@ -26,13 +26,13 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/TargetParser/Triple.h"
 
-#include <future>
 #include <mutex>
 #include <vector>
 
 namespace llvm::orc {
 
 class ExecutionSession;
+class DylibManager;
 
 /// ExecutorProcessControl supports interaction with a JIT target process.
 class LLVM_ABI ExecutorProcessControl {
@@ -97,6 +97,85 @@ class LLVM_ABI ExecutorProcessControl {
     TaskDispatcher &D;
   };
 
+  /// APIs for manipulating memory in the target process.
+  class LLVM_ABI MemoryAccess {
+  public:
+    /// Callback function for asynchronous writes.
+    using WriteResultFn = unique_function<void(Error)>;
+
+    MemoryAccess(ExecutorProcessControl &EPC) : EPC(EPC) {}
+    virtual ~MemoryAccess();
+
+    virtual void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
+                                  WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
+                                   WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
+                                   WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
+                                   WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
+                                   WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                                    WriteResultFn OnWriteComplete) = 0;
+
+    Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt8sAsync(Ws,
+                       [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+    Error writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt16sAsync(Ws,
+                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+    Error writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt32sAsync(Ws,
+                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+    Error writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt64sAsync(Ws,
+                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+    Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeBuffersAsync(Ws,
+                        [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+    Error writePointers(ArrayRef<tpctypes::PointerWrite> Ws) {
+      orc::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writePointersAsync(Ws,
+                         [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get(EPC.getDispatcher());
+    }
+
+  protected:
+    ExecutorProcessControl &EPC;
+  };
+
   /// Contains the address of the dispatch function and context that the ORC
   /// runtime can use to call functions in the JIT.
   struct JITDispatchInfo {
@@ -251,14 +330,14 @@ class LLVM_ABI ExecutorProcessControl {
   /// \endcode{.cpp}
   shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr,
                                             ArrayRef<char> ArgBuffer) {
-    std::promise<shared::WrapperFunctionResult> RP;
+    orc::promise<shared::WrapperFunctionResult> RP;
     auto RF = RP.get_future();
     callWrapperAsync(
         RunInPlace(), WrapperFnAddr,
         [&](shared::WrapperFunctionResult R) {
           RP.set_value(std::move(R));
         }, ArgBuffer);
-    return RF.get();
+    return RF.get(*D);
   }
 
   /// Run a wrapper function using SPS to serialize the arguments and
@@ -322,6 +401,34 @@ class LLVM_ABI ExecutorProcessControl {
   StringMap<ExecutorAddr> BootstrapSymbols;
 };
 
-} // namespace llvm::orc
+class LLVM_ABI InProcessMemoryAccess
+    : public ExecutorProcessControl::MemoryAccess {
+public:
+  InProcessMemoryAccess(ExecutorProcessControl &EPC, bool IsArch64Bit) 
+      : MemoryAccess(EPC), IsArch64Bit(IsArch64Bit) {}
+  void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
+                        WriteResultFn OnWriteComplete) override;
+
+  void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
+                         WriteResultFn OnWriteComplete) override;
+
+  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                          WriteResultFn OnWriteComplete) override;
+
+private:
+  bool IsArch64Bit;
+};
+
+} // end namespace orc
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_EXECUTORPROCESSCONTROL_H