[llvm-branch-commits] [llvm] 5efc71e - [ORC] Move Orc RPC code into Shared, rename some RPC types.
Lang Hames via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Dec 29 17:53:26 PST 2020
Author: Lang Hames
Date: 2020-12-30T12:48:20+11:00
New Revision: 5efc71e119d4eba235209d262e7d171361a0b9be
URL: https://github.com/llvm/llvm-project/commit/5efc71e119d4eba235209d262e7d171361a0b9be
DIFF: https://github.com/llvm/llvm-project/commit/5efc71e119d4eba235209d262e7d171361a0b9be.diff
LOG: [ORC] Move Orc RPC code into Shared, rename some RPC types.
Moves all headers from Orc/RPC to Orc/Shared, and from the llvm::orc::rpc
namespace into llvm::orc::shared. Also renames RPCTypeName to
SerializationTypeName and Function to RPCFunction.
In addition to being a more reasonable home for this code, this will make it
easier for the upcoming Orc runtime to re-use the Serialization system for
creating and parsing wrapper-function binary blobs.
Added:
llvm/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
llvm/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
llvm/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
llvm/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
Modified:
llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp
llvm/tools/lli/ChildTarget/ChildTarget.cpp
llvm/tools/lli/RemoteJITUtils.h
llvm/tools/lli/lli.cpp
llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp
llvm/tools/llvm-jitlink/llvm-jitlink.cpp
llvm/tools/llvm-jitlink/llvm-jitlink.h
llvm/unittests/ExecutionEngine/Orc/QueueChannel.h
llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
Removed:
llvm/include/llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h
llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h
llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCUtils.h
llvm/include/llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
index 1856e0d78209..1097ae67b2a2 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
@@ -13,8 +13,8 @@
#ifndef LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
#define LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
#include "llvm/Support/MSVCErrorWorkarounds.h"
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
index dfed5e09e4d4..3d139740d677 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
@@ -54,7 +54,7 @@ namespace remote {
/// OrcRemoteTargetServer class) via an RPC system (see RPCUtils.h) to carry out
/// its actions.
class OrcRemoteTargetClient
- : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+ : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
public:
/// Remote-mapped RuntimeDyld-compatible memory manager.
class RemoteRTDyldMemoryManager : public RuntimeDyld::MemoryManager {
@@ -703,7 +703,7 @@ class OrcRemoteTargetClient
/// Channel is the ChannelT instance to communicate on. It is assumed that
/// the channel is ready to be read from and written to.
static Expected<std::unique_ptr<OrcRemoteTargetClient>>
- Create(rpc::RawByteChannel &Channel, ExecutionSession &ES) {
+ Create(shared::RawByteChannel &Channel, ExecutionSession &ES) {
Error Err = Error::success();
auto Client = std::unique_ptr<OrcRemoteTargetClient>(
new OrcRemoteTargetClient(Channel, ES, Err));
@@ -805,9 +805,10 @@ class OrcRemoteTargetClient
Error terminateSession() { return callB<utils::TerminateSession>(); }
private:
- OrcRemoteTargetClient(rpc::RawByteChannel &Channel, ExecutionSession &ES,
+ OrcRemoteTargetClient(shared::RawByteChannel &Channel, ExecutionSession &ES,
Error &Err)
- : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(Channel, true),
+ : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
+ true),
ES(ES) {
ErrorAsOutParameter EAO(&Err);
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
index 430ae2ca429b..367bfb369191 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
@@ -16,8 +16,8 @@
#define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
#include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
namespace llvm {
namespace orc {
@@ -73,10 +73,9 @@ class DirectBufferWriter {
} // end namespace remote
-namespace rpc {
+namespace shared {
-template <>
-class RPCTypeName<JITSymbolFlags> {
+template <> class SerializationTypeName<JITSymbolFlags> {
public:
static const char *getName() { return "JITSymbolFlags"; }
};
@@ -100,7 +99,7 @@ class SerializationTraits<ChannelT, JITSymbolFlags> {
}
};
-template <> class RPCTypeName<remote::DirectBufferWriter> {
+template <> class SerializationTypeName<remote::DirectBufferWriter> {
public:
static const char *getName() { return "DirectBufferWriter"; }
};
@@ -133,7 +132,7 @@ class SerializationTraits<
}
};
-} // end namespace rpc
+} // end namespace shared
namespace remote {
@@ -167,20 +166,20 @@ class ResourceIdMgr {
namespace eh {
/// Registers EH frames on the remote.
- class RegisterEHFrames
- : public rpc::Function<RegisterEHFrames,
- void(JITTargetAddress Addr, uint32_t Size)> {
- public:
- static const char *getName() { return "RegisterEHFrames"; }
- };
+class RegisterEHFrames
+ : public shared::RPCFunction<RegisterEHFrames,
+ void(JITTargetAddress Addr, uint32_t Size)> {
+public:
+ static const char *getName() { return "RegisterEHFrames"; }
+};
/// Deregisters EH frames on the remote.
- class DeregisterEHFrames
- : public rpc::Function<DeregisterEHFrames,
- void(JITTargetAddress Addr, uint32_t Size)> {
- public:
- static const char *getName() { return "DeregisterEHFrames"; }
- };
+class DeregisterEHFrames
+ : public shared::RPCFunction<DeregisterEHFrames,
+ void(JITTargetAddress Addr, uint32_t Size)> {
+public:
+ static const char *getName() { return "DeregisterEHFrames"; }
+};
} // end namespace eh
@@ -189,36 +188,38 @@ namespace exec {
/// Call an 'int32_t()'-type function on the remote, returns the called
/// function's return value.
- class CallIntVoid
- : public rpc::Function<CallIntVoid, int32_t(JITTargetAddress Addr)> {
- public:
- static const char *getName() { return "CallIntVoid"; }
- };
+class CallIntVoid
+ : public shared::RPCFunction<CallIntVoid, int32_t(JITTargetAddress Addr)> {
+public:
+ static const char *getName() { return "CallIntVoid"; }
+};
/// Call an 'int32_t(int32_t)'-type function on the remote, returns the called
/// function's return value.
- class CallIntInt
- : public rpc::Function<CallIntInt, int32_t(JITTargetAddress Addr, int)> {
- public:
- static const char *getName() { return "CallIntInt"; }
- };
+class CallIntInt
+ : public shared::RPCFunction<CallIntInt,
+ int32_t(JITTargetAddress Addr, int)> {
+public:
+ static const char *getName() { return "CallIntInt"; }
+};
/// Call an 'int32_t(int32_t, char**)'-type function on the remote, returns the
/// called function's return value.
- class CallMain
- : public rpc::Function<CallMain, int32_t(JITTargetAddress Addr,
- std::vector<std::string> Args)> {
- public:
- static const char *getName() { return "CallMain"; }
- };
+class CallMain
+ : public shared::RPCFunction<CallMain,
+ int32_t(JITTargetAddress Addr,
+ std::vector<std::string> Args)> {
+public:
+ static const char *getName() { return "CallMain"; }
+};
/// Calls a 'void()'-type function on the remote, returns when the called
/// function completes.
- class CallVoidVoid
- : public rpc::Function<CallVoidVoid, void(JITTargetAddress FnAddr)> {
- public:
- static const char *getName() { return "CallVoidVoid"; }
- };
+class CallVoidVoid
+ : public shared::RPCFunction<CallVoidVoid, void(JITTargetAddress FnAddr)> {
+public:
+ static const char *getName() { return "CallVoidVoid"; }
+};
} // end namespace exec
@@ -226,60 +227,62 @@ namespace exec {
namespace mem {
/// Creates a memory allocator on the remote.
- class CreateRemoteAllocator
- : public rpc::Function<CreateRemoteAllocator,
- void(ResourceIdMgr::ResourceId AllocatorID)> {
- public:
- static const char *getName() { return "CreateRemoteAllocator"; }
- };
+class CreateRemoteAllocator
+ : public shared::RPCFunction<CreateRemoteAllocator,
+ void(ResourceIdMgr::ResourceId AllocatorID)> {
+public:
+ static const char *getName() { return "CreateRemoteAllocator"; }
+};
/// Destroys a remote allocator, freeing any memory allocated by it.
- class DestroyRemoteAllocator
- : public rpc::Function<DestroyRemoteAllocator,
- void(ResourceIdMgr::ResourceId AllocatorID)> {
- public:
- static const char *getName() { return "DestroyRemoteAllocator"; }
- };
+class DestroyRemoteAllocator
+ : public shared::RPCFunction<DestroyRemoteAllocator,
+ void(ResourceIdMgr::ResourceId AllocatorID)> {
+public:
+ static const char *getName() { return "DestroyRemoteAllocator"; }
+};
/// Read a remote memory block.
- class ReadMem
- : public rpc::Function<ReadMem, std::vector<uint8_t>(JITTargetAddress Src,
- uint64_t Size)> {
- public:
- static const char *getName() { return "ReadMem"; }
- };
+class ReadMem
+ : public shared::RPCFunction<
+ ReadMem, std::vector<uint8_t>(JITTargetAddress Src, uint64_t Size)> {
+public:
+ static const char *getName() { return "ReadMem"; }
+};
/// Reserve a block of memory on the remote via the given allocator.
- class ReserveMem
- : public rpc::Function<ReserveMem,
- JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
- uint64_t Size, uint32_t Align)> {
- public:
- static const char *getName() { return "ReserveMem"; }
- };
+class ReserveMem
+ : public shared::RPCFunction<
+ ReserveMem, JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
+ uint64_t Size, uint32_t Align)> {
+public:
+ static const char *getName() { return "ReserveMem"; }
+};
/// Set the memory protection on a memory block.
- class SetProtections
- : public rpc::Function<SetProtections,
- void(ResourceIdMgr::ResourceId AllocID,
- JITTargetAddress Dst, uint32_t ProtFlags)> {
- public:
- static const char *getName() { return "SetProtections"; }
- };
+class SetProtections
+ : public shared::RPCFunction<
+ SetProtections, void(ResourceIdMgr::ResourceId AllocID,
+ JITTargetAddress Dst, uint32_t ProtFlags)> {
+public:
+ static const char *getName() { return "SetProtections"; }
+};
/// Write to a remote memory block.
- class WriteMem
- : public rpc::Function<WriteMem, void(remote::DirectBufferWriter DB)> {
- public:
- static const char *getName() { return "WriteMem"; }
- };
+class WriteMem
+ : public shared::RPCFunction<WriteMem,
+ void(remote::DirectBufferWriter DB)> {
+public:
+ static const char *getName() { return "WriteMem"; }
+};
/// Write to a remote pointer.
- class WritePtr : public rpc::Function<WritePtr, void(JITTargetAddress Dst,
- JITTargetAddress Val)> {
- public:
- static const char *getName() { return "WritePtr"; }
- };
+class WritePtr
+ : public shared::RPCFunction<WritePtr, void(JITTargetAddress Dst,
+ JITTargetAddress Val)> {
+public:
+ static const char *getName() { return "WritePtr"; }
+};
} // end namespace mem
@@ -287,45 +290,46 @@ namespace mem {
namespace stubs {
/// Creates an indirect stub owner on the remote.
- class CreateIndirectStubsOwner
- : public rpc::Function<CreateIndirectStubsOwner,
- void(ResourceIdMgr::ResourceId StubOwnerID)> {
- public:
- static const char *getName() { return "CreateIndirectStubsOwner"; }
- };
+class CreateIndirectStubsOwner
+ : public shared::RPCFunction<CreateIndirectStubsOwner,
+ void(ResourceIdMgr::ResourceId StubOwnerID)> {
+public:
+ static const char *getName() { return "CreateIndirectStubsOwner"; }
+};
/// RPC function for destroying an indirect stubs owner.
- class DestroyIndirectStubsOwner
- : public rpc::Function<DestroyIndirectStubsOwner,
- void(ResourceIdMgr::ResourceId StubsOwnerID)> {
- public:
- static const char *getName() { return "DestroyIndirectStubsOwner"; }
- };
+class DestroyIndirectStubsOwner
+ : public shared::RPCFunction<DestroyIndirectStubsOwner,
+ void(ResourceIdMgr::ResourceId StubsOwnerID)> {
+public:
+ static const char *getName() { return "DestroyIndirectStubsOwner"; }
+};
/// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
- class EmitIndirectStubs
- : public rpc::Function<
- EmitIndirectStubs,
- std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
- ResourceIdMgr::ResourceId StubsOwnerID,
- uint32_t NumStubsRequired)> {
- public:
- static const char *getName() { return "EmitIndirectStubs"; }
- };
+class EmitIndirectStubs
+ : public shared::RPCFunction<
+ EmitIndirectStubs,
+ std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
+ ResourceIdMgr::ResourceId StubsOwnerID,
+ uint32_t NumStubsRequired)> {
+public:
+ static const char *getName() { return "EmitIndirectStubs"; }
+};
/// RPC function to emit the resolver block and return its address.
- class EmitResolverBlock : public rpc::Function<EmitResolverBlock, void()> {
- public:
- static const char *getName() { return "EmitResolverBlock"; }
- };
+class EmitResolverBlock
+ : public shared::RPCFunction<EmitResolverBlock, void()> {
+public:
+ static const char *getName() { return "EmitResolverBlock"; }
+};
/// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
- class EmitTrampolineBlock
- : public rpc::Function<EmitTrampolineBlock,
- std::tuple<JITTargetAddress, uint32_t>()> {
- public:
- static const char *getName() { return "EmitTrampolineBlock"; }
- };
+class EmitTrampolineBlock
+ : public shared::RPCFunction<EmitTrampolineBlock,
+ std::tuple<JITTargetAddress, uint32_t>()> {
+public:
+ static const char *getName() { return "EmitTrampolineBlock"; }
+};
} // end namespace stubs
@@ -334,44 +338,44 @@ namespace utils {
/// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
/// IndirectStubsSize).
- class GetRemoteInfo
- : public rpc::Function<
- GetRemoteInfo,
- std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
- public:
- static const char *getName() { return "GetRemoteInfo"; }
- };
+class GetRemoteInfo
+ : public shared::RPCFunction<
+ GetRemoteInfo,
+ std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
+public:
+ static const char *getName() { return "GetRemoteInfo"; }
+};
/// Get the address of a remote symbol.
- class GetSymbolAddress
- : public rpc::Function<GetSymbolAddress,
- JITTargetAddress(std::string SymbolName)> {
- public:
- static const char *getName() { return "GetSymbolAddress"; }
- };
+class GetSymbolAddress
+ : public shared::RPCFunction<GetSymbolAddress,
+ JITTargetAddress(std::string SymbolName)> {
+public:
+ static const char *getName() { return "GetSymbolAddress"; }
+};
/// Request that the host execute a compile callback.
- class RequestCompile
- : public rpc::Function<
- RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
- public:
- static const char *getName() { return "RequestCompile"; }
- };
+class RequestCompile
+ : public shared::RPCFunction<
+ RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
+public:
+ static const char *getName() { return "RequestCompile"; }
+};
/// Notify the remote and terminate the session.
- class TerminateSession : public rpc::Function<TerminateSession, void()> {
- public:
- static const char *getName() { return "TerminateSession"; }
- };
+class TerminateSession : public shared::RPCFunction<TerminateSession, void()> {
+public:
+ static const char *getName() { return "TerminateSession"; }
+};
} // namespace utils
class OrcRemoteTargetRPCAPI
- : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+ : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
public:
// FIXME: Remove constructors once MSVC supports synthesizing move-ops.
- OrcRemoteTargetRPCAPI(rpc::RawByteChannel &C)
- : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(C, true) {}
+ OrcRemoteTargetRPCAPI(shared::RawByteChannel &C)
+ : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(C, true) {}
};
} // end namespace remote
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
index 562e38d6ef0b..68eccf44cc72 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
@@ -46,7 +46,7 @@ namespace remote {
template <typename ChannelT, typename TargetT>
class OrcRemoteTargetServer
- : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+ : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
public:
using SymbolLookupFtor =
std::function<JITTargetAddress(const std::string &Name)>;
@@ -57,7 +57,8 @@ class OrcRemoteTargetServer
OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup,
EHFrameRegistrationFtor EHFramesRegister,
EHFrameRegistrationFtor EHFramesDeregister)
- : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(Channel, true),
+ : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
+ true),
SymbolLookup(std::move(SymbolLookup)),
EHFramesRegister(std::move(EHFramesRegister)),
EHFramesDeregister(std::move(EHFramesDeregister)) {
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
similarity index 87%
rename from llvm/include/llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h
rename to llvm/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
index 9faa1afe546c..f90b71db108b 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
@@ -10,10 +10,10 @@
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H
-#define LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
-#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/raw_ostream.h"
@@ -26,9 +26,9 @@
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
-/// RPC channel that reads from and writes from file descriptors.
+/// Serialization channel that reads from and writes from file descriptors.
class FDRawByteChannel final : public RawByteChannel {
public:
FDRawByteChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
@@ -85,8 +85,8 @@ class FDRawByteChannel final : public RawByteChannel {
int InFD, OutFD;
};
-} // namespace rpc
+} // namespace shared
} // namespace orc
} // namespace llvm
-#endif // LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCUtils.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
similarity index 89%
rename from llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCUtils.h
rename to llvm/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
index 306a5eeec384..1c8b8e0bc922 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCUtils.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
@@ -14,8 +14,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPC_RPCUTILS_H
-#define LLVM_EXECUTIONENGINE_ORC_RPC_RPCUTILS_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
#include <map>
#include <thread>
@@ -23,14 +23,14 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/Orc/OrcError.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h"
+#include "llvm/ExecutionEngine/Orc/Shared/Serialization.h"
#include "llvm/Support/MSVCErrorWorkarounds.h"
#include <future>
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
/// Base class of all fatal RPC errors (those that necessarily result in the
/// termination of the RPC session).
@@ -56,7 +56,7 @@ class ConnectionClosed : public ErrorInfo<ConnectionClosed> {
/// function id it cannot parse the call.
template <typename FnIdT, typename SeqNoT>
class BadFunctionCall
- : public ErrorInfo<BadFunctionCall<FnIdT, SeqNoT>, RPCFatalError> {
+ : public ErrorInfo<BadFunctionCall<FnIdT, SeqNoT>, RPCFatalError> {
public:
static char ID;
@@ -68,8 +68,10 @@ class BadFunctionCall
}
void log(raw_ostream &OS) const override {
- OS << "Call to invalid RPC function id '" << FnId << "' with "
- "sequence number " << SeqNo;
+ OS << "Call to invalid RPC function id '" << FnId
+ << "' with "
+ "sequence number "
+ << SeqNo;
}
private:
@@ -89,12 +91,12 @@ char BadFunctionCall<FnIdT, SeqNoT>::ID = 0;
/// a result parser for this sequence number it can't do that.
template <typename SeqNoT>
class InvalidSequenceNumberForResponse
- : public ErrorInfo<InvalidSequenceNumberForResponse<SeqNoT>, RPCFatalError> {
+ : public ErrorInfo<InvalidSequenceNumberForResponse<SeqNoT>,
+ RPCFatalError> {
public:
static char ID;
- InvalidSequenceNumberForResponse(SeqNoT SeqNo)
- : SeqNo(std::move(SeqNo)) {}
+ InvalidSequenceNumberForResponse(SeqNoT SeqNo) : SeqNo(std::move(SeqNo)) {}
std::error_code convertToErrorCode() const override {
return orcError(OrcErrorCode::UnexpectedRPCCall);
@@ -103,6 +105,7 @@ class InvalidSequenceNumberForResponse
void log(raw_ostream &OS) const override {
OS << "Response has unknown sequence number " << SeqNo;
}
+
private:
SeqNoT SeqNo;
};
@@ -131,17 +134,18 @@ class CouldNotNegotiate : public ErrorInfo<CouldNotNegotiate> {
std::error_code convertToErrorCode() const override;
void log(raw_ostream &OS) const override;
const std::string &getSignature() const { return Signature; }
+
private:
std::string Signature;
};
-template <typename DerivedFunc, typename FnT> class Function;
+template <typename DerivedFunc, typename FnT> class RPCFunction;
// RPC Function class.
// DerivedFunc should be a user defined class with a static 'getName()' method
// returning a const char* representing the function's name.
template <typename DerivedFunc, typename RetT, typename... ArgTs>
-class Function<DerivedFunc, RetT(ArgTs...)> {
+class RPCFunction<DerivedFunc, RetT(ArgTs...)> {
public:
/// User defined function type.
using Type = RetT(ArgTs...);
@@ -154,8 +158,9 @@ class Function<DerivedFunc, RetT(ArgTs...)> {
static std::string Name = [] {
std::string Name;
raw_string_ostream(Name)
- << RPCTypeName<RetT>::getName() << " " << DerivedFunc::getName()
- << "(" << llvm::orc::rpc::RPCTypeNameSequence<ArgTs...>() << ")";
+ << SerializationTypeName<RetT>::getName() << " "
+ << DerivedFunc::getName() << "("
+ << SerializationTypeNameSequence<ArgTs...>() << ")";
return Name;
}();
return Name.data();
@@ -199,10 +204,10 @@ class RPCFunctionIdAllocator<T, std::enable_if_t<std::is_integral<T>::value>> {
namespace detail {
/// Provides a typedef for a tuple containing the decayed argument types.
-template <typename T> class FunctionArgsTuple;
+template <typename T> class RPCFunctionArgsTuple;
template <typename RetT, typename... ArgTs>
-class FunctionArgsTuple<RetT(ArgTs...)> {
+class RPCFunctionArgsTuple<RetT(ArgTs...)> {
public:
using Type = std::tuple<std::decay_t<std::remove_reference_t<ArgTs>>...>;
};
@@ -287,34 +292,28 @@ class ResultTraits<Expected<RetT>> : public ResultTraits<RetT> {};
// Determines whether an RPC function's defined error return type supports
// error return value.
-template <typename T>
-class SupportsErrorReturn {
+template <typename T> class SupportsErrorReturn {
public:
static const bool value = false;
};
-template <>
-class SupportsErrorReturn<Error> {
+template <> class SupportsErrorReturn<Error> {
public:
static const bool value = true;
};
-template <typename T>
-class SupportsErrorReturn<Expected<T>> {
+template <typename T> class SupportsErrorReturn<Expected<T>> {
public:
static const bool value = true;
};
// RespondHelper packages return values based on whether or not the declared
// RPC function return type supports error returns.
-template <bool FuncSupportsErrorReturn>
-class RespondHelper;
+template <bool FuncSupportsErrorReturn> class RespondHelper;
// RespondHelper specialization for functions that support error returns.
-template <>
-class RespondHelper<true> {
+template <> class RespondHelper<true> {
public:
-
// Send Expected<T>.
template <typename WireRetT, typename HandlerRetT, typename ChannelT,
typename FunctionIdT, typename SequenceNumberT>
@@ -330,9 +329,8 @@ class RespondHelper<true> {
// Serialize the result.
if (auto Err =
- SerializationTraits<ChannelT, WireRetT,
- Expected<HandlerRetT>>::serialize(
- C, std::move(ResultOrErr)))
+ SerializationTraits<ChannelT, WireRetT, Expected<HandlerRetT>>::
+ serialize(C, std::move(ResultOrErr)))
return Err;
// Close the response message.
@@ -354,14 +352,11 @@ class RespondHelper<true> {
return Err2;
return C.send();
}
-
};
// RespondHelper specialization for functions that do not support error returns.
-template <>
-class RespondHelper<false> {
+template <> class RespondHelper<false> {
public:
-
template <typename WireRetT, typename HandlerRetT, typename ChannelT,
typename FunctionIdT, typename SequenceNumberT>
static Error sendResult(ChannelT &C, const FunctionIdT &ResponseId,
@@ -376,8 +371,8 @@ class RespondHelper<false> {
// Serialize the result.
if (auto Err =
- SerializationTraits<ChannelT, WireRetT, HandlerRetT>::serialize(
- C, *ResultOrErr))
+ SerializationTraits<ChannelT, WireRetT, HandlerRetT>::serialize(
+ C, *ResultOrErr))
return Err;
// End the response message.
@@ -398,18 +393,17 @@ class RespondHelper<false> {
return Err2;
return C.send();
}
-
};
-
// Send a response of the given wire return type (WireRetT) over the
// channel, with the given sequence number.
template <typename WireRetT, typename HandlerRetT, typename ChannelT,
typename FunctionIdT, typename SequenceNumberT>
-Error respond(ChannelT &C, const FunctionIdT &ResponseId,
- SequenceNumberT SeqNo, Expected<HandlerRetT> ResultOrErr) {
+Error respond(ChannelT &C, const FunctionIdT &ResponseId, SequenceNumberT SeqNo,
+ Expected<HandlerRetT> ResultOrErr) {
return RespondHelper<SupportsErrorReturn<WireRetT>::value>::
- template sendResult<WireRetT>(C, ResponseId, SeqNo, std::move(ResultOrErr));
+ template sendResult<WireRetT>(C, ResponseId, SeqNo,
+ std::move(ResultOrErr));
}
// Send an empty response message on the given channel to indicate that
@@ -418,8 +412,8 @@ template <typename WireRetT, typename ChannelT, typename FunctionIdT,
typename SequenceNumberT>
Error respond(ChannelT &C, const FunctionIdT &ResponseId, SequenceNumberT SeqNo,
Error Err) {
- return RespondHelper<SupportsErrorReturn<WireRetT>::value>::
- sendResult(C, ResponseId, SeqNo, std::move(Err));
+ return RespondHelper<SupportsErrorReturn<WireRetT>::value>::sendResult(
+ C, ResponseId, SeqNo, std::move(Err));
}
// Converts a given type to the equivalent error return type.
@@ -453,7 +447,8 @@ template <> class WrappedHandlerReturn<ErrorSuccess> {
template <typename FnT> class AsyncHandlerTraits;
template <typename ResultT, typename... ArgTs>
-class AsyncHandlerTraits<Error(std::function<Error(Expected<ResultT>)>, ArgTs...)> {
+class AsyncHandlerTraits<Error(std::function<Error(Expected<ResultT>)>,
+ ArgTs...)> {
public:
using Type = Error(ArgTs...);
using ResultType = Expected<ResultT>;
@@ -490,9 +485,9 @@ class AsyncHandlerTraits<Error(ResponseHandlerT, ArgTs...)>
// specialized for function types) and inherits from the appropriate
// speciilization for the given non-function type's call operator.
template <typename HandlerT>
-class HandlerTraits : public HandlerTraits<decltype(
- &std::remove_reference<HandlerT>::type::operator())> {
-};
+class HandlerTraits
+ : public HandlerTraits<
+ decltype(&std::remove_reference<HandlerT>::type::operator())> {};
// Traits for handlers with a given function type.
template <typename RetT, typename... ArgTs>
@@ -524,7 +519,7 @@ class HandlerTraits<RetT(ArgTs...)> {
template <typename HandlerT>
static std::enable_if_t<
std::is_void<typename HandlerTraits<HandlerT>::ReturnType>::value, Error>
- run(HandlerT &Handler, ArgTs &&... Args) {
+ run(HandlerT &Handler, ArgTs &&...Args) {
Handler(std::move(Args)...);
return Error::success();
}
@@ -577,8 +572,8 @@ class HandlerTraits<RetT(ArgTs...)> {
// Handler traits for free functions.
template <typename RetT, typename... ArgTs>
-class HandlerTraits<RetT(*)(ArgTs...)>
- : public HandlerTraits<RetT(ArgTs...)> {};
+class HandlerTraits<RetT (*)(ArgTs...)> : public HandlerTraits<RetT(ArgTs...)> {
+};
// Handler traits for class methods (especially call operators for lambdas).
template <typename Class, typename RetT, typename... ArgTs>
@@ -714,9 +709,8 @@ class ResponseHandlerImpl<ChannelT, Expected<FuncRetT>, HandlerT>
typename HandlerTraits<HandlerT>::Type>::ArgType;
HandlerArgType Result((typename HandlerArgType::value_type()));
- if (auto Err =
- SerializationTraits<ChannelT, Expected<FuncRetT>,
- HandlerArgType>::deserialize(C, Result))
+ if (auto Err = SerializationTraits<ChannelT, Expected<FuncRetT>,
+ HandlerArgType>::deserialize(C, Result))
return Err;
if (auto Err = C.endReceiveMessage())
return Err;
@@ -786,7 +780,7 @@ class MemberFnWrapper {
using MethodT = RetT (ClassT::*)(ArgTs...);
MemberFnWrapper(ClassT &Instance, MethodT Method)
: Instance(Instance), Method(Method) {}
- RetT operator()(ArgTs &&... Args) {
+ RetT operator()(ArgTs &&...Args) {
return (Instance.*Method)(std::move(Args)...);
}
@@ -804,10 +798,9 @@ template <typename... ArgTs> class ReadArgs {
template <typename ArgT, typename... ArgTs>
class ReadArgs<ArgT, ArgTs...> : public ReadArgs<ArgTs...> {
public:
- ReadArgs(ArgT &Arg, ArgTs &... Args)
- : ReadArgs<ArgTs...>(Args...), Arg(Arg) {}
+ ReadArgs(ArgT &Arg, ArgTs &...Args) : ReadArgs<ArgTs...>(Args...), Arg(Arg) {}
- Error operator()(ArgT &ArgVal, ArgTs &... ArgVals) {
+ Error operator()(ArgT &ArgVal, ArgTs &...ArgVals) {
this->Arg = std::move(ArgVal);
return ReadArgs<ArgTs...>::operator()(ArgVals...);
}
@@ -872,8 +865,8 @@ class RPCArgTypeCheckHelper<P, std::tuple<T, Ts...>, std::tuple<U, Us...>> {
template <template <class, class> class P, typename T1Sig, typename T2Sig>
class RPCArgTypeCheck {
public:
- using T1Tuple = typename FunctionArgsTuple<T1Sig>::Type;
- using T2Tuple = typename FunctionArgsTuple<T2Sig>::Type;
+ using T1Tuple = typename RPCFunctionArgsTuple<T1Sig>::Type;
+ using T2Tuple = typename RPCFunctionArgsTuple<T2Sig>::Type;
static_assert(std::tuple_size<T1Tuple>::value >=
std::tuple_size<T2Tuple>::value,
@@ -937,18 +930,18 @@ template <typename ImplT, typename ChannelT, typename FunctionIdT,
typename SequenceNumberT>
class RPCEndpointBase {
protected:
- class OrcRPCInvalid : public Function<OrcRPCInvalid, void()> {
+ class OrcRPCInvalid : public RPCFunction<OrcRPCInvalid, void()> {
public:
static const char *getName() { return "__orc_rpc$invalid"; }
};
- class OrcRPCResponse : public Function<OrcRPCResponse, void()> {
+ class OrcRPCResponse : public RPCFunction<OrcRPCResponse, void()> {
public:
static const char *getName() { return "__orc_rpc$response"; }
};
class OrcRPCNegotiate
- : public Function<OrcRPCNegotiate, FunctionIdT(std::string)> {
+ : public RPCFunction<OrcRPCNegotiate, FunctionIdT(std::string)> {
public:
static const char *getName() { return "__orc_rpc$negotiate"; }
};
@@ -994,7 +987,6 @@ class RPCEndpointBase {
[this](const std::string &Name) { return handleNegotiate(Name); });
}
-
/// Negotiate a function id for Func with the other end of the channel.
template <typename Func> Error negotiateFunction(bool Retry = false) {
return getRemoteFunctionId<Func>(true, Retry).takeError();
@@ -1006,7 +998,7 @@ class RPCEndpointBase {
/// or an Error (if Func::ReturnType is void). The handler will be called
/// with an error if the return value is abandoned due to a channel error.
template <typename Func, typename HandlerT, typename... ArgTs>
- Error appendCallAsync(HandlerT Handler, const ArgTs &... Args) {
+ Error appendCallAsync(HandlerT Handler, const ArgTs &...Args) {
static_assert(
detail::RPCArgTypeCheck<CanSerializeCheck, typename Func::Type,
@@ -1036,8 +1028,8 @@ class RPCEndpointBase {
// Install the user handler.
PendingResponses[SeqNo] =
- detail::createResponseHandler<ChannelT, typename Func::ReturnType>(
- std::move(Handler));
+ detail::createResponseHandler<ChannelT, typename Func::ReturnType>(
+ std::move(Handler));
}
// Open the function call message.
@@ -1065,7 +1057,7 @@ class RPCEndpointBase {
Error sendAppendedCalls() { return C.send(); };
template <typename Func, typename HandlerT, typename... ArgTs>
- Error callAsync(HandlerT Handler, const ArgTs &... Args) {
+ Error callAsync(HandlerT Handler, const ArgTs &...Args) {
if (auto Err = appendCallAsync<Func>(std::move(Handler), Args...))
return Err;
return C.send();
@@ -1104,7 +1096,7 @@ class RPCEndpointBase {
/// /* Handle Args */ ;
///
template <typename... ArgTs>
- static detail::ReadArgs<ArgTs...> readArgs(ArgTs &... Args) {
+ static detail::ReadArgs<ArgTs...> readArgs(ArgTs &...Args) {
return detail::ReadArgs<ArgTs...>(Args...);
}
@@ -1128,8 +1120,7 @@ class RPCEndpointBase {
/// Remove the handler for the given function.
/// A handler must currently be registered for this function.
- template <typename Func>
- void removeHandler() {
+ template <typename Func> void removeHandler() {
auto IdItr = LocalFunctionIds.find(Func::getPrototype());
assert(IdItr != LocalFunctionIds.end() &&
"Function does not have a registered handler");
@@ -1140,12 +1131,9 @@ class RPCEndpointBase {
}
/// Clear all handlers.
- void clearHandlers() {
- Handlers.clear();
- }
+ void clearHandlers() { Handlers.clear(); }
protected:
-
FunctionIdT getInvalidFunctionId() const {
return FnIdAllocator.getInvalidId();
}
@@ -1168,12 +1156,12 @@ class RPCEndpointBase {
template <typename Func, typename HandlerT>
void addAsyncHandlerImpl(HandlerT Handler) {
- static_assert(detail::RPCArgTypeCheck<
- CanDeserializeCheck, typename Func::Type,
- typename detail::AsyncHandlerTraits<
- typename detail::HandlerTraits<HandlerT>::Type
- >::Type>::value,
- "");
+ static_assert(
+ detail::RPCArgTypeCheck<
+ CanDeserializeCheck, typename Func::Type,
+ typename detail::AsyncHandlerTraits<
+ typename detail::HandlerTraits<HandlerT>::Type>::Type>::value,
+ "");
FunctionIdT NewFnId = FnIdAllocator.template allocate<Func>();
LocalFunctionIds[Func::getPrototype()] = NewFnId;
@@ -1197,8 +1185,8 @@ class RPCEndpointBase {
// Unlock the pending results map to prevent recursive lock.
Lock.unlock();
abandonPendingResponses();
- return make_error<
- InvalidSequenceNumberForResponse<SequenceNumberT>>(SeqNo);
+ return make_error<InvalidSequenceNumberForResponse<SequenceNumberT>>(
+ SeqNo);
}
}
@@ -1241,7 +1229,7 @@ class RPCEndpointBase {
if (DoNegotiate) {
auto &Impl = static_cast<ImplT &>(*this);
if (auto RemoteIdOrErr =
- Impl.template callB<OrcRPCNegotiate>(Func::getPrototype())) {
+ Impl.template callB<OrcRPCNegotiate>(Func::getPrototype())) {
RemoteFunctionIds[Func::getPrototype()] = *RemoteIdOrErr;
if (*RemoteIdOrErr == getInvalidFunctionId())
return make_error<CouldNotNegotiate>(Func::getPrototype());
@@ -1264,9 +1252,8 @@ class RPCEndpointBase {
return [this, Handler](ChannelT &Channel,
SequenceNumberT SeqNo) mutable -> Error {
// Start by deserializing the arguments.
- using ArgsTuple =
- typename detail::FunctionArgsTuple<
- typename detail::HandlerTraits<HandlerT>::Type>::Type;
+ using ArgsTuple = typename detail::RPCFunctionArgsTuple<
+ typename detail::HandlerTraits<HandlerT>::Type>::Type;
auto Args = std::make_shared<ArgsTuple>();
if (auto Err =
@@ -1298,9 +1285,9 @@ class RPCEndpointBase {
SequenceNumberT SeqNo) mutable -> Error {
// Start by deserializing the arguments.
using AHTraits = detail::AsyncHandlerTraits<
- typename detail::HandlerTraits<HandlerT>::Type>;
+ typename detail::HandlerTraits<HandlerT>::Type>;
using ArgsTuple =
- typename detail::FunctionArgsTuple<typename AHTraits::Type>::Type;
+ typename detail::RPCFunctionArgsTuple<typename AHTraits::Type>::Type;
auto Args = std::make_shared<ArgsTuple>();
if (auto Err =
@@ -1319,11 +1306,11 @@ class RPCEndpointBase {
using HTraits = detail::HandlerTraits<HandlerT>;
using FuncReturn = typename Func::ReturnType;
- auto Responder =
- [this, SeqNo](typename AHTraits::ResultType RetVal) -> Error {
- return detail::respond<FuncReturn>(C, ResponseId, SeqNo,
- std::move(RetVal));
- };
+ auto Responder = [this,
+ SeqNo](typename AHTraits::ResultType RetVal) -> Error {
+ return detail::respond<FuncReturn>(C, ResponseId, SeqNo,
+ std::move(RetVal));
+ };
return HTraits::unpackAndRunAsync(Handler, Responder, *Args);
};
@@ -1356,17 +1343,16 @@ class MultiThreadedRPCEndpoint
MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
ChannelT, FunctionIdT, SequenceNumberT> {
private:
- using BaseClass =
- detail::RPCEndpointBase<
- MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
- ChannelT, FunctionIdT, SequenceNumberT>;
+ using BaseClass = detail::RPCEndpointBase<
+ MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
+ ChannelT, FunctionIdT, SequenceNumberT>;
public:
MultiThreadedRPCEndpoint(ChannelT &C, bool LazyAutoNegotiation)
: BaseClass(C, LazyAutoNegotiation) {}
/// Add a handler for the given RPC function.
- /// This installs the given handler functor for the given RPC Function, and
+ /// This installs the given handler functor for the given RPCFunction, and
/// makes the RPC function available for negotiation/calling from the remote.
template <typename Func, typename HandlerT>
void addHandler(HandlerT Handler) {
@@ -1377,7 +1363,7 @@ class MultiThreadedRPCEndpoint
template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
void addHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
addHandler<Func>(
- detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+ detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
}
template <typename Func, typename HandlerT>
@@ -1389,7 +1375,7 @@ class MultiThreadedRPCEndpoint
template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
void addAsyncHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
addAsyncHandler<Func>(
- detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+ detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
}
/// Return type for non-blocking call primitives.
@@ -1405,7 +1391,7 @@ class MultiThreadedRPCEndpoint
/// result. In multi-threaded mode the appendCallNB method, which does not
/// return the sequence numeber, should be preferred.
template <typename Func, typename... ArgTs>
- Expected<NonBlockingCallResult<Func>> appendCallNB(const ArgTs &... Args) {
+ Expected<NonBlockingCallResult<Func>> appendCallNB(const ArgTs &...Args) {
using RTraits = detail::ResultTraits<typename Func::ReturnType>;
using ErrorReturn = typename RTraits::ErrorReturnType;
using ErrorReturnPromise = typename RTraits::ReturnPromiseType;
@@ -1428,7 +1414,7 @@ class MultiThreadedRPCEndpoint
/// The same as appendCallNBWithSeq, except that it calls C.send() to
/// flush the channel after serializing the call.
template <typename Func, typename... ArgTs>
- Expected<NonBlockingCallResult<Func>> callNB(const ArgTs &... Args) {
+ Expected<NonBlockingCallResult<Func>> callNB(const ArgTs &...Args) {
auto Result = appendCallNB<Func>(Args...);
if (!Result)
return Result;
@@ -1449,7 +1435,7 @@ class MultiThreadedRPCEndpoint
template <typename Func, typename... ArgTs,
typename AltRetT = typename Func::ReturnType>
typename detail::ResultTraits<AltRetT>::ErrorReturnType
- callB(const ArgTs &... Args) {
+ callB(const ArgTs &...Args) {
if (auto FutureResOrErr = callNB<Func>(Args...))
return FutureResOrErr->get();
else
@@ -1472,10 +1458,9 @@ class SingleThreadedRPCEndpoint
SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
ChannelT, FunctionIdT, SequenceNumberT> {
private:
- using BaseClass =
- detail::RPCEndpointBase<
- SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
- ChannelT, FunctionIdT, SequenceNumberT>;
+ using BaseClass = detail::RPCEndpointBase<
+ SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
+ ChannelT, FunctionIdT, SequenceNumberT>;
public:
SingleThreadedRPCEndpoint(ChannelT &C, bool LazyAutoNegotiation)
@@ -1501,13 +1486,13 @@ class SingleThreadedRPCEndpoint
template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
void addAsyncHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
addAsyncHandler<Func>(
- detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+ detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
}
template <typename Func, typename... ArgTs,
typename AltRetT = typename Func::ReturnType>
typename detail::ResultTraits<AltRetT>::ErrorReturnType
- callB(const ArgTs &... Args) {
+ callB(const ArgTs &...Args) {
bool ReceivedResponse = false;
using ResultType = typename detail::ResultTraits<AltRetT>::ErrorReturnType;
auto Result = detail::ResultTraits<AltRetT>::createBlankErrorReturnValue();
@@ -1547,13 +1532,12 @@ class SingleThreadedRPCEndpoint
};
/// Asynchronous dispatch for a function on an RPC endpoint.
-template <typename RPCClass, typename Func>
-class RPCAsyncDispatch {
+template <typename RPCClass, typename Func> class RPCAsyncDispatch {
public:
RPCAsyncDispatch(RPCClass &Endpoint) : Endpoint(Endpoint) {}
template <typename HandlerT, typename... ArgTs>
- Error operator()(HandlerT Handler, const ArgTs &... Args) const {
+ Error operator()(HandlerT Handler, const ArgTs &...Args) const {
return Endpoint.template appendCallAsync<Func>(std::move(Handler), Args...);
}
@@ -1571,7 +1555,6 @@ RPCAsyncDispatch<RPCEndpointT, Func> rpcAsyncDispatch(RPCEndpointT &Endpoint) {
/// waited on as a group.
class ParallelCallGroup {
public:
-
ParallelCallGroup() = default;
ParallelCallGroup(const ParallelCallGroup &) = delete;
ParallelCallGroup &operator=(const ParallelCallGroup &) = delete;
@@ -1579,7 +1562,7 @@ class ParallelCallGroup {
/// Make as asynchronous call.
template <typename AsyncDispatcher, typename HandlerT, typename... ArgTs>
Error call(const AsyncDispatcher &AsyncDispatch, HandlerT Handler,
- const ArgTs &... Args) {
+ const ArgTs &...Args) {
// Increment the count of outstanding calls. This has to happen before
// we invoke the call, as the handler may (depending on scheduling)
// be run immediately on another thread, and we don't want the decrement
@@ -1618,70 +1601,57 @@ class ParallelCallGroup {
uint32_t NumOutstandingCalls = 0;
};
-/// Convenience class for grouping RPC Functions into APIs that can be
+/// Convenience class for grouping RPCFunctions into APIs that can be
/// negotiated as a block.
///
-template <typename... Funcs>
-class APICalls {
+template <typename... Funcs> class APICalls {
public:
-
/// Test whether this API contains Function F.
- template <typename F>
- class Contains {
+ template <typename F> class Contains {
public:
static const bool value = false;
};
/// Negotiate all functions in this API.
- template <typename RPCEndpoint>
- static Error negotiate(RPCEndpoint &R) {
+ template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
return Error::success();
}
};
-template <typename Func, typename... Funcs>
-class APICalls<Func, Funcs...> {
+template <typename Func, typename... Funcs> class APICalls<Func, Funcs...> {
public:
-
- template <typename F>
- class Contains {
+ template <typename F> class Contains {
public:
static const bool value = std::is_same<F, Func>::value |
APICalls<Funcs...>::template Contains<F>::value;
};
- template <typename RPCEndpoint>
- static Error negotiate(RPCEndpoint &R) {
+ template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
if (auto Err = R.template negotiateFunction<Func>())
return Err;
return APICalls<Funcs...>::negotiate(R);
}
-
};
template <typename... InnerFuncs, typename... Funcs>
class APICalls<APICalls<InnerFuncs...>, Funcs...> {
public:
-
- template <typename F>
- class Contains {
+ template <typename F> class Contains {
public:
static const bool value =
- APICalls<InnerFuncs...>::template Contains<F>::value |
- APICalls<Funcs...>::template Contains<F>::value;
+ APICalls<InnerFuncs...>::template Contains<F>::value |
+ APICalls<Funcs...>::template Contains<F>::value;
};
- template <typename RPCEndpoint>
- static Error negotiate(RPCEndpoint &R) {
+ template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
if (auto Err = APICalls<InnerFuncs...>::negotiate(R))
return Err;
return APICalls<Funcs...>::negotiate(R);
}
-
};
-} // end namespace rpc
+} // end namespace shared
} // end namespace orc
} // end namespace llvm
-#endif // LLVM_EXECUTIONENGINE_ORC_RPC_RPCUTILS_H
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
similarity index 88%
rename from llvm/include/llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h
rename to llvm/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
index 2e201000e522..2ee471939251 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
@@ -1,4 +1,4 @@
-//===- llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h ----------------*- C++ -*-===//
+//===- RawByteChannel.h -----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPC_RAWBYTECHANNEL_H
-#define LLVM_EXECUTIONENGINE_ORC_RPC_RAWBYTECHANNEL_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
#include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h"
+#include "llvm/ExecutionEngine/Orc/Shared/Serialization.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/Error.h"
#include <cstdint>
@@ -20,9 +20,9 @@
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
-/// Interface for byte-streams to be used with RPC.
+/// Interface for byte-streams to be used with ORC Serialization.
class RawByteChannel {
public:
virtual ~RawByteChannel() = default;
@@ -115,8 +115,7 @@ class SerializationTraits<
public:
static Error serialize(ChannelT &C, bool V) {
uint8_t Tmp = V ? 1 : 0;
- if (auto Err =
- C.appendBytes(reinterpret_cast<const char *>(&Tmp), 1))
+ if (auto Err = C.appendBytes(reinterpret_cast<const char *>(&Tmp), 1))
return Err;
return Error::success();
}
@@ -135,7 +134,7 @@ class SerializationTraits<
ChannelT, std::string, StringRef,
std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
public:
- /// RPC channel serialization for std::strings.
+ /// Serialization channel serialization for std::strings.
static Error serialize(RawByteChannel &C, StringRef S) {
if (auto Err = serializeSeq(C, static_cast<uint64_t>(S.size())))
return Err;
@@ -161,13 +160,13 @@ class SerializationTraits<
ChannelT, std::string, std::string,
std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
public:
- /// RPC channel serialization for std::strings.
+ /// Serialization channel serialization for std::strings.
static Error serialize(RawByteChannel &C, const std::string &S) {
return SerializationTraits<ChannelT, std::string, StringRef>::serialize(C,
S);
}
- /// RPC channel deserialization for std::strings.
+ /// Serialization channel deserialization for std::strings.
static Error deserialize(RawByteChannel &C, std::string &S) {
uint64_t Count = 0;
if (auto Err = deserializeSeq(C, Count))
@@ -177,8 +176,8 @@ class SerializationTraits<
}
};
-} // end namespace rpc
+} // end namespace shared
} // end namespace orc
} // end namespace llvm
-#endif // LLVM_EXECUTIONENGINE_ORC_RPC_RAWBYTECHANNEL_H
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
similarity index 76%
rename from llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h
rename to llvm/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
index 0dc05f4d1c17..64a4ab8be709 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
@@ -1,4 +1,4 @@
-//===- llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h --------------*- C++ -*-===//
+//===- Serialization.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H
-#define LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_SERIALIZATION_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_SERIALIZATION_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
@@ -22,118 +22,104 @@
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
-template <typename T>
-class RPCTypeName;
+template <typename T> class SerializationTypeName;
/// TypeNameSequence is a utility for rendering sequences of types to a string
/// by rendering each type, separated by ", ".
-template <typename... ArgTs> class RPCTypeNameSequence {};
+template <typename... ArgTs> class SerializationTypeNameSequence {};
/// Render an empty TypeNameSequence to an ostream.
template <typename OStream>
-OStream &operator<<(OStream &OS, const RPCTypeNameSequence<> &V) {
+OStream &operator<<(OStream &OS, const SerializationTypeNameSequence<> &V) {
return OS;
}
/// Render a TypeNameSequence of a single type to an ostream.
template <typename OStream, typename ArgT>
-OStream &operator<<(OStream &OS, const RPCTypeNameSequence<ArgT> &V) {
- OS << RPCTypeName<ArgT>::getName();
+OStream &operator<<(OStream &OS, const SerializationTypeNameSequence<ArgT> &V) {
+ OS << SerializationTypeName<ArgT>::getName();
return OS;
}
/// Render a TypeNameSequence of more than one type to an ostream.
template <typename OStream, typename ArgT1, typename ArgT2, typename... ArgTs>
-OStream&
-operator<<(OStream &OS, const RPCTypeNameSequence<ArgT1, ArgT2, ArgTs...> &V) {
- OS << RPCTypeName<ArgT1>::getName() << ", "
- << RPCTypeNameSequence<ArgT2, ArgTs...>();
+OStream &
+operator<<(OStream &OS,
+ const SerializationTypeNameSequence<ArgT1, ArgT2, ArgTs...> &V) {
+ OS << SerializationTypeName<ArgT1>::getName() << ", "
+ << SerializationTypeNameSequence<ArgT2, ArgTs...>();
return OS;
}
-template <>
-class RPCTypeName<void> {
+template <> class SerializationTypeName<void> {
public:
- static const char* getName() { return "void"; }
+ static const char *getName() { return "void"; }
};
-template <>
-class RPCTypeName<int8_t> {
+template <> class SerializationTypeName<int8_t> {
public:
- static const char* getName() { return "int8_t"; }
+ static const char *getName() { return "int8_t"; }
};
-template <>
-class RPCTypeName<uint8_t> {
+template <> class SerializationTypeName<uint8_t> {
public:
- static const char* getName() { return "uint8_t"; }
+ static const char *getName() { return "uint8_t"; }
};
-template <>
-class RPCTypeName<int16_t> {
+template <> class SerializationTypeName<int16_t> {
public:
- static const char* getName() { return "int16_t"; }
+ static const char *getName() { return "int16_t"; }
};
-template <>
-class RPCTypeName<uint16_t> {
+template <> class SerializationTypeName<uint16_t> {
public:
- static const char* getName() { return "uint16_t"; }
+ static const char *getName() { return "uint16_t"; }
};
-template <>
-class RPCTypeName<int32_t> {
+template <> class SerializationTypeName<int32_t> {
public:
- static const char* getName() { return "int32_t"; }
+ static const char *getName() { return "int32_t"; }
};
-template <>
-class RPCTypeName<uint32_t> {
+template <> class SerializationTypeName<uint32_t> {
public:
- static const char* getName() { return "uint32_t"; }
+ static const char *getName() { return "uint32_t"; }
};
-template <>
-class RPCTypeName<int64_t> {
+template <> class SerializationTypeName<int64_t> {
public:
- static const char* getName() { return "int64_t"; }
+ static const char *getName() { return "int64_t"; }
};
-template <>
-class RPCTypeName<uint64_t> {
+template <> class SerializationTypeName<uint64_t> {
public:
- static const char* getName() { return "uint64_t"; }
+ static const char *getName() { return "uint64_t"; }
};
-template <>
-class RPCTypeName<bool> {
+template <> class SerializationTypeName<bool> {
public:
- static const char* getName() { return "bool"; }
+ static const char *getName() { return "bool"; }
};
-template <>
-class RPCTypeName<std::string> {
+template <> class SerializationTypeName<std::string> {
public:
- static const char* getName() { return "std::string"; }
+ static const char *getName() { return "std::string"; }
};
-template <>
-class RPCTypeName<Error> {
+template <> class SerializationTypeName<Error> {
public:
- static const char* getName() { return "Error"; }
+ static const char *getName() { return "Error"; }
};
-template <typename T>
-class RPCTypeName<Expected<T>> {
+template <typename T> class SerializationTypeName<Expected<T>> {
public:
- static const char* getName() {
+ static const char *getName() {
static std::string Name = [] {
std::string Name;
- raw_string_ostream(Name) << "Expected<"
- << RPCTypeNameSequence<T>()
- << ">";
+ raw_string_ostream(Name)
+ << "Expected<" << SerializationTypeNameSequence<T>() << ">";
return Name;
}();
return Name.data();
@@ -141,80 +127,78 @@ class RPCTypeName<Expected<T>> {
};
template <typename T1, typename T2>
-class RPCTypeName<std::pair<T1, T2>> {
+class SerializationTypeName<std::pair<T1, T2>> {
public:
- static const char* getName() {
+ static const char *getName() {
static std::string Name = [] {
std::string Name;
- raw_string_ostream(Name) << "std::pair<" << RPCTypeNameSequence<T1, T2>()
- << ">";
+ raw_string_ostream(Name)
+ << "std::pair<" << SerializationTypeNameSequence<T1, T2>() << ">";
return Name;
}();
return Name.data();
}
};
-template <typename... ArgTs>
-class RPCTypeName<std::tuple<ArgTs...>> {
+template <typename... ArgTs> class SerializationTypeName<std::tuple<ArgTs...>> {
public:
- static const char* getName() {
+ static const char *getName() {
static std::string Name = [] {
std::string Name;
- raw_string_ostream(Name) << "std::tuple<"
- << RPCTypeNameSequence<ArgTs...>() << ">";
+ raw_string_ostream(Name)
+ << "std::tuple<" << SerializationTypeNameSequence<ArgTs...>() << ">";
return Name;
}();
return Name.data();
}
};
-template <typename T> class RPCTypeName<Optional<T>> {
+template <typename T> class SerializationTypeName<Optional<T>> {
public:
static const char *getName() {
static std::string Name = [] {
std::string Name;
raw_string_ostream(Name)
- << "Optional<" << RPCTypeName<T>::getName() << ">";
+ << "Optional<" << SerializationTypeName<T>::getName() << ">";
return Name;
}();
return Name.data();
}
};
-template <typename T>
-class RPCTypeName<std::vector<T>> {
+template <typename T> class SerializationTypeName<std::vector<T>> {
public:
- static const char*getName() {
+ static const char *getName() {
static std::string Name = [] {
std::string Name;
- raw_string_ostream(Name) << "std::vector<" << RPCTypeName<T>::getName()
- << ">";
+ raw_string_ostream(Name)
+ << "std::vector<" << SerializationTypeName<T>::getName() << ">";
return Name;
}();
return Name.data();
}
};
-template <typename T> class RPCTypeName<std::set<T>> {
+template <typename T> class SerializationTypeName<std::set<T>> {
public:
static const char *getName() {
static std::string Name = [] {
std::string Name;
raw_string_ostream(Name)
- << "std::set<" << RPCTypeName<T>::getName() << ">";
+ << "std::set<" << SerializationTypeName<T>::getName() << ">";
return Name;
}();
return Name.data();
}
};
-template <typename K, typename V> class RPCTypeName<std::map<K, V>> {
+template <typename K, typename V> class SerializationTypeName<std::map<K, V>> {
public:
static const char *getName() {
static std::string Name = [] {
std::string Name;
raw_string_ostream(Name)
- << "std::map<" << RPCTypeNameSequence<K, V>() << ">";
+ << "std::map<" << SerializationTypeNameSequence<K, V>() << ">";
return Name;
}();
return Name.data();
@@ -257,8 +241,7 @@ template <typename ChannelT, typename WireType,
typename ConcreteType = WireType, typename = void>
class SerializationTraits;
-template <typename ChannelT>
-class SequenceTraits {
+template <typename ChannelT> class SequenceTraits {
public:
static Error emitSeparator(ChannelT &C) { return Error::success(); }
static Error consumeSeparator(ChannelT &C) { return Error::success(); }
@@ -273,11 +256,9 @@ class SequenceTraits {
/// is a SerializationTraits specialization
/// SerializeTraits<ChannelT, ArgT, CArgT> with methods that can serialize the
/// caller argument to over-the-wire value.
-template <typename ChannelT, typename... ArgTs>
-class SequenceSerialization;
+template <typename ChannelT, typename... ArgTs> class SequenceSerialization;
-template <typename ChannelT>
-class SequenceSerialization<ChannelT> {
+template <typename ChannelT> class SequenceSerialization<ChannelT> {
public:
static Error serialize(ChannelT &C) { return Error::success(); }
static Error deserialize(ChannelT &C) { return Error::success(); }
@@ -286,15 +267,12 @@ class SequenceSerialization<ChannelT> {
template <typename ChannelT, typename ArgT>
class SequenceSerialization<ChannelT, ArgT> {
public:
-
- template <typename CArgT>
- static Error serialize(ChannelT &C, CArgT &&CArg) {
+ template <typename CArgT> static Error serialize(ChannelT &C, CArgT &&CArg) {
return SerializationTraits<ChannelT, ArgT, std::decay_t<CArgT>>::serialize(
C, std::forward<CArgT>(CArg));
}
- template <typename CArgT>
- static Error deserialize(ChannelT &C, CArgT &CArg) {
+ template <typename CArgT> static Error deserialize(ChannelT &C, CArgT &CArg) {
return SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg);
}
};
@@ -302,25 +280,22 @@ class SequenceSerialization<ChannelT, ArgT> {
template <typename ChannelT, typename ArgT, typename... ArgTs>
class SequenceSerialization<ChannelT, ArgT, ArgTs...> {
public:
-
template <typename CArgT, typename... CArgTs>
- static Error serialize(ChannelT &C, CArgT &&CArg,
- CArgTs &&... CArgs) {
+ static Error serialize(ChannelT &C, CArgT &&CArg, CArgTs &&...CArgs) {
if (auto Err =
SerializationTraits<ChannelT, ArgT, std::decay_t<CArgT>>::serialize(
C, std::forward<CArgT>(CArg)))
return Err;
if (auto Err = SequenceTraits<ChannelT>::emitSeparator(C))
return Err;
- return SequenceSerialization<ChannelT, ArgTs...>::
- serialize(C, std::forward<CArgTs>(CArgs)...);
+ return SequenceSerialization<ChannelT, ArgTs...>::serialize(
+ C, std::forward<CArgTs>(CArgs)...);
}
template <typename CArgT, typename... CArgTs>
- static Error deserialize(ChannelT &C, CArgT &CArg,
- CArgTs &... CArgs) {
+ static Error deserialize(ChannelT &C, CArgT &CArg, CArgTs &...CArgs) {
if (auto Err =
- SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg))
+ SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg))
return Err;
if (auto Err = SequenceTraits<ChannelT>::consumeSeparator(C))
return Err;
@@ -329,25 +304,23 @@ class SequenceSerialization<ChannelT, ArgT, ArgTs...> {
};
template <typename ChannelT, typename... ArgTs>
-Error serializeSeq(ChannelT &C, ArgTs &&... Args) {
+Error serializeSeq(ChannelT &C, ArgTs &&...Args) {
return SequenceSerialization<ChannelT, std::decay_t<ArgTs>...>::serialize(
C, std::forward<ArgTs>(Args)...);
}
template <typename ChannelT, typename... ArgTs>
-Error deserializeSeq(ChannelT &C, ArgTs &... Args) {
+Error deserializeSeq(ChannelT &C, ArgTs &...Args) {
return SequenceSerialization<ChannelT, ArgTs...>::deserialize(C, Args...);
}
-template <typename ChannelT>
-class SerializationTraits<ChannelT, Error> {
+template <typename ChannelT> class SerializationTraits<ChannelT, Error> {
public:
-
using WrappedErrorSerializer =
- std::function<Error(ChannelT &C, const ErrorInfoBase&)>;
+ std::function<Error(ChannelT &C, const ErrorInfoBase &)>;
using WrappedErrorDeserializer =
- std::function<Error(ChannelT &C, Error &Err)>;
+ std::function<Error(ChannelT &C, Error &Err)>;
template <typename ErrorInfoT, typename SerializeFtor,
typename DeserializeFtor>
@@ -358,15 +331,14 @@ class SerializationTraits<ChannelT, Error> {
const std::string *KeyName = nullptr;
{
- // We're abusing the stability of std::map here: We take a reference to the
- // key of the deserializers map to save us from duplicating the string in
- // the serializer. This should be changed to use a stringpool if we switch
- // to a map type that may move keys in memory.
+ // We're abusing the stability of std::map here: We take a reference to
+ // the key of the deserializers map to save us from duplicating the string
+ // in the serializer. This should be changed to use a stringpool if we
+ // switch to a map type that may move keys in memory.
std::lock_guard<std::recursive_mutex> Lock(DeserializersMutex);
- auto I =
- Deserializers.insert(Deserializers.begin(),
- std::make_pair(std::move(Name),
- std::move(Deserialize)));
+ auto I = Deserializers.insert(
+ Deserializers.begin(),
+ std::make_pair(std::move(Name), std::move(Deserialize)));
KeyName = &I->first;
}
@@ -391,13 +363,12 @@ class SerializationTraits<ChannelT, Error> {
if (!Err)
return serializeSeq(C, std::string());
- return handleErrors(std::move(Err),
- [&C](const ErrorInfoBase &EIB) {
- auto SI = Serializers.find(EIB.dynamicClassID());
- if (SI == Serializers.end())
- return serializeAsStringError(C, EIB);
- return (SI->second)(C, EIB);
- });
+ return handleErrors(std::move(Err), [&C](const ErrorInfoBase &EIB) {
+ auto SI = Serializers.find(EIB.dynamicClassID());
+ if (SI == Serializers.end())
+ return serializeAsStringError(C, EIB);
+ return (SI->second)(C, EIB);
+ });
}
static Error deserialize(ChannelT &C, Error &Err) {
@@ -419,7 +390,6 @@ class SerializationTraits<ChannelT, Error> {
}
private:
-
static Error serializeAsStringError(ChannelT &C, const ErrorInfoBase &EIB) {
std::string ErrMsg;
{
@@ -432,7 +402,7 @@ class SerializationTraits<ChannelT, Error> {
static std::recursive_mutex SerializersMutex;
static std::recursive_mutex DeserializersMutex;
- static std::map<const void*, WrappedErrorSerializer> Serializers;
+ static std::map<const void *, WrappedErrorSerializer> Serializers;
static std::map<std::string, WrappedErrorDeserializer> Deserializers;
};
@@ -443,14 +413,14 @@ template <typename ChannelT>
std::recursive_mutex SerializationTraits<ChannelT, Error>::DeserializersMutex;
template <typename ChannelT>
-std::map<const void*,
+std::map<const void *,
typename SerializationTraits<ChannelT, Error>::WrappedErrorSerializer>
-SerializationTraits<ChannelT, Error>::Serializers;
+ SerializationTraits<ChannelT, Error>::Serializers;
template <typename ChannelT>
-std::map<std::string,
- typename SerializationTraits<ChannelT, Error>::WrappedErrorDeserializer>
-SerializationTraits<ChannelT, Error>::Deserializers;
+std::map<std::string, typename SerializationTraits<
+ ChannelT, Error>::WrappedErrorDeserializer>
+ SerializationTraits<ChannelT, Error>::Deserializers;
/// Registers a serializer and deserializer for the given error type on the
/// given channel type.
@@ -459,32 +429,29 @@ template <typename ChannelT, typename ErrorInfoT, typename SerializeFtor,
void registerErrorSerialization(std::string Name, SerializeFtor &&Serialize,
DeserializeFtor &&Deserialize) {
SerializationTraits<ChannelT, Error>::template registerErrorType<ErrorInfoT>(
- std::move(Name),
- std::forward<SerializeFtor>(Serialize),
- std::forward<DeserializeFtor>(Deserialize));
+ std::move(Name), std::forward<SerializeFtor>(Serialize),
+ std::forward<DeserializeFtor>(Deserialize));
}
/// Registers serialization/deserialization for StringError.
-template <typename ChannelT>
-void registerStringError() {
+template <typename ChannelT> void registerStringError() {
static bool AlreadyRegistered = false;
if (!AlreadyRegistered) {
registerErrorSerialization<ChannelT, StringError>(
- "StringError",
- [](ChannelT &C, const StringError &SE) {
- return serializeSeq(C, SE.getMessage());
- },
- [](ChannelT &C, Error &Err) -> Error {
- ErrorAsOutParameter EAO(&Err);
- std::string Msg;
- if (auto E2 = deserializeSeq(C, Msg))
- return E2;
- Err =
- make_error<StringError>(std::move(Msg),
- orcError(
- OrcErrorCode::UnknownErrorCodeFromRemote));
- return Error::success();
- });
+ "StringError",
+ [](ChannelT &C, const StringError &SE) {
+ return serializeSeq(C, SE.getMessage());
+ },
+ [](ChannelT &C, Error &Err) -> Error {
+ ErrorAsOutParameter EAO(&Err);
+ std::string Msg;
+ if (auto E2 = deserializeSeq(C, Msg))
+ return E2;
+ Err = make_error<StringError>(
+ std::move(Msg),
+ orcError(OrcErrorCode::UnknownErrorCodeFromRemote));
+ return Error::success();
+ });
AlreadyRegistered = true;
}
}
@@ -493,7 +460,6 @@ void registerStringError() {
template <typename ChannelT, typename T1, typename T2>
class SerializationTraits<ChannelT, Expected<T1>, Expected<T2>> {
public:
-
static Error serialize(ChannelT &C, Expected<T2> &&ValOrErr) {
if (ValOrErr) {
if (auto Err = serializeSeq(C, true))
@@ -524,7 +490,6 @@ class SerializationTraits<ChannelT, Expected<T1>, Expected<T2>> {
template <typename ChannelT, typename T1, typename T2>
class SerializationTraits<ChannelT, Expected<T1>, T2> {
public:
-
static Error serialize(ChannelT &C, T2 &&Val) {
return serializeSeq(C, Expected<T2>(std::forward<T2>(Val)));
}
@@ -534,7 +499,6 @@ class SerializationTraits<ChannelT, Expected<T1>, T2> {
template <typename ChannelT, typename T>
class SerializationTraits<ChannelT, Expected<T>, Error> {
public:
-
static Error serialize(ChannelT &C, Error &&Err) {
return serializeSeq(C, Expected<T>(std::move(Err)));
}
@@ -562,7 +526,6 @@ class SerializationTraits<ChannelT, std::pair<T1, T2>, std::pair<T3, T4>> {
template <typename ChannelT, typename... ArgTs>
class SerializationTraits<ChannelT, std::tuple<ArgTs...>> {
public:
-
/// RPC channel serialization for std::tuple.
static Error serialize(ChannelT &C, const std::tuple<ArgTs...> &V) {
return serializeTupleHelper(C, V, std::index_sequence_for<ArgTs...>());
@@ -618,7 +581,6 @@ class SerializationTraits<ChannelT, Optional<T>> {
template <typename ChannelT, typename T>
class SerializationTraits<ChannelT, std::vector<T>> {
public:
-
/// Serialize a std::vector<T> from std::vector<T>.
static Error serialize(ChannelT &C, const std::vector<T> &V) {
if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
@@ -800,7 +762,7 @@ class SerializationTraits<ChannelT, std::map<K, V>, DenseMap<K2, V2>> {
}
};
-} // end namespace rpc
+} // namespace shared
} // end namespace orc
} // end namespace llvm
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h b/llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
index 2b759dea6333..253e06ba0ba1 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
@@ -14,8 +14,8 @@
#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
#include "llvm/ADT/BitmaskEnum.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
@@ -93,49 +93,50 @@ using ReleaseOrFinalizeMemRequest =
} // end namespace orcrpctpc
-namespace rpc {
+namespace shared {
-template <> class RPCTypeName<tpctypes::UInt8Write> {
+template <> class SerializationTypeName<tpctypes::UInt8Write> {
public:
static const char *getName() { return "UInt8Write"; }
};
-template <> class RPCTypeName<tpctypes::UInt16Write> {
+template <> class SerializationTypeName<tpctypes::UInt16Write> {
public:
static const char *getName() { return "UInt16Write"; }
};
-template <> class RPCTypeName<tpctypes::UInt32Write> {
+template <> class SerializationTypeName<tpctypes::UInt32Write> {
public:
static const char *getName() { return "UInt32Write"; }
};
-template <> class RPCTypeName<tpctypes::UInt64Write> {
+template <> class SerializationTypeName<tpctypes::UInt64Write> {
public:
static const char *getName() { return "UInt64Write"; }
};
-template <> class RPCTypeName<tpctypes::BufferWrite> {
+template <> class SerializationTypeName<tpctypes::BufferWrite> {
public:
static const char *getName() { return "BufferWrite"; }
};
-template <> class RPCTypeName<orcrpctpc::ReserveMemRequestElement> {
+template <> class SerializationTypeName<orcrpctpc::ReserveMemRequestElement> {
public:
static const char *getName() { return "ReserveMemRequestElement"; }
};
-template <> class RPCTypeName<orcrpctpc::ReserveMemResultElement> {
+template <> class SerializationTypeName<orcrpctpc::ReserveMemResultElement> {
public:
static const char *getName() { return "ReserveMemResultElement"; }
};
-template <> class RPCTypeName<orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
+template <>
+class SerializationTypeName<orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
public:
static const char *getName() { return "ReleaseOrFinalizeMemRequestElement"; }
};
-template <> class RPCTypeName<tpctypes::WrapperFunctionResult> {
+template <> class SerializationTypeName<tpctypes::WrapperFunctionResult> {
public:
static const char *getName() { return "WrapperFunctionResult"; }
};
@@ -271,7 +272,7 @@ class SerializationTraits<
}
};
-} // end namespace rpc
+} // end namespace shared
namespace orcrpctpc {
@@ -279,100 +280,105 @@ using RemoteSymbolLookupSet = std::vector<std::pair<std::string, bool>>;
using RemoteLookupRequest =
std::pair<tpctypes::DylibHandle, RemoteSymbolLookupSet>;
-class GetTargetTriple : public rpc::Function<GetTargetTriple, std::string()> {
+class GetTargetTriple
+ : public shared::RPCFunction<GetTargetTriple, std::string()> {
public:
static const char *getName() { return "GetTargetTriple"; }
};
-class GetPageSize : public rpc::Function<GetPageSize, uint64_t()> {
+class GetPageSize : public shared::RPCFunction<GetPageSize, uint64_t()> {
public:
static const char *getName() { return "GetPageSize"; }
};
-class ReserveMem : public rpc::Function<ReserveMem, Expected<ReserveMemResult>(
- ReserveMemRequest)> {
+class ReserveMem
+ : public shared::RPCFunction<ReserveMem, Expected<ReserveMemResult>(
+ ReserveMemRequest)> {
public:
static const char *getName() { return "ReserveMem"; }
};
class FinalizeMem
- : public rpc::Function<FinalizeMem, Error(ReleaseOrFinalizeMemRequest)> {
+ : public shared::RPCFunction<FinalizeMem,
+ Error(ReleaseOrFinalizeMemRequest)> {
public:
static const char *getName() { return "FinalizeMem"; }
};
class ReleaseMem
- : public rpc::Function<ReleaseMem, Error(ReleaseOrFinalizeMemRequest)> {
+ : public shared::RPCFunction<ReleaseMem,
+ Error(ReleaseOrFinalizeMemRequest)> {
public:
static const char *getName() { return "ReleaseMem"; }
};
class WriteUInt8s
- : public rpc::Function<WriteUInt8s,
- Error(std::vector<tpctypes::UInt8Write>)> {
+ : public shared::RPCFunction<WriteUInt8s,
+ Error(std::vector<tpctypes::UInt8Write>)> {
public:
static const char *getName() { return "WriteUInt8s"; }
};
class WriteUInt16s
- : public rpc::Function<WriteUInt16s,
- Error(std::vector<tpctypes::UInt16Write>)> {
+ : public shared::RPCFunction<WriteUInt16s,
+ Error(std::vector<tpctypes::UInt16Write>)> {
public:
static const char *getName() { return "WriteUInt16s"; }
};
class WriteUInt32s
- : public rpc::Function<WriteUInt32s,
- Error(std::vector<tpctypes::UInt32Write>)> {
+ : public shared::RPCFunction<WriteUInt32s,
+ Error(std::vector<tpctypes::UInt32Write>)> {
public:
static const char *getName() { return "WriteUInt32s"; }
};
class WriteUInt64s
- : public rpc::Function<WriteUInt64s,
- Error(std::vector<tpctypes::UInt64Write>)> {
+ : public shared::RPCFunction<WriteUInt64s,
+ Error(std::vector<tpctypes::UInt64Write>)> {
public:
static const char *getName() { return "WriteUInt64s"; }
};
class WriteBuffers
- : public rpc::Function<WriteBuffers,
- Error(std::vector<tpctypes::BufferWrite>)> {
+ : public shared::RPCFunction<WriteBuffers,
+ Error(std::vector<tpctypes::BufferWrite>)> {
public:
static const char *getName() { return "WriteBuffers"; }
};
class LoadDylib
- : public rpc::Function<LoadDylib, Expected<tpctypes::DylibHandle>(
- std::string DylibPath)> {
+ : public shared::RPCFunction<LoadDylib, Expected<tpctypes::DylibHandle>(
+ std::string DylibPath)> {
public:
static const char *getName() { return "LoadDylib"; }
};
class LookupSymbols
- : public rpc::Function<LookupSymbols,
- Expected<std::vector<tpctypes::LookupResult>>(
- std::vector<RemoteLookupRequest>)> {
+ : public shared::RPCFunction<LookupSymbols,
+ Expected<std::vector<tpctypes::LookupResult>>(
+ std::vector<RemoteLookupRequest>)> {
public:
static const char *getName() { return "LookupSymbols"; }
};
class RunMain
- : public rpc::Function<RunMain, int32_t(JITTargetAddress MainAddr,
- std::vector<std::string> Args)> {
+ : public shared::RPCFunction<RunMain,
+ int32_t(JITTargetAddress MainAddr,
+ std::vector<std::string> Args)> {
public:
static const char *getName() { return "RunMain"; }
};
class RunWrapper
- : public rpc::Function<RunWrapper,
- tpctypes::WrapperFunctionResult(
- JITTargetAddress, std::vector<uint8_t>)> {
+ : public shared::RPCFunction<RunWrapper,
+ tpctypes::WrapperFunctionResult(
+ JITTargetAddress, std::vector<uint8_t>)> {
public:
static const char *getName() { return "RunWrapper"; }
};
-class CloseConnection : public rpc::Function<CloseConnection, void()> {
+class CloseConnection : public shared::RPCFunction<CloseConnection, void()> {
public:
static const char *getName() { return "CloseConnection"; }
};
diff --git a/llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp b/llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp
index a13db4863953..a55cb220f218 100644
--- a/llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp
@@ -10,21 +10,21 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
#include <system_error>
-char llvm::orc::rpc::RPCFatalError::ID = 0;
-char llvm::orc::rpc::ConnectionClosed::ID = 0;
-char llvm::orc::rpc::ResponseAbandoned::ID = 0;
-char llvm::orc::rpc::CouldNotNegotiate::ID = 0;
+char llvm::orc::shared::RPCFatalError::ID = 0;
+char llvm::orc::shared::ConnectionClosed::ID = 0;
+char llvm::orc::shared::ResponseAbandoned::ID = 0;
+char llvm::orc::shared::CouldNotNegotiate::ID = 0;
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
std::error_code ConnectionClosed::convertToErrorCode() const {
return orcError(OrcErrorCode::RPCConnectionClosed);
@@ -53,6 +53,6 @@ void CouldNotNegotiate::log(raw_ostream &OS) const {
OS << "Could not negotiate RPC function " << Signature;
}
-} // end namespace rpc
+} // end namespace shared
} // end namespace orc
} // end namespace llvm
diff --git a/llvm/tools/lli/ChildTarget/ChildTarget.cpp b/llvm/tools/lli/ChildTarget/ChildTarget.cpp
index b5cf63c5ad90..5772baca1d09 100644
--- a/llvm/tools/lli/ChildTarget/ChildTarget.cpp
+++ b/llvm/tools/lli/ChildTarget/ChildTarget.cpp
@@ -1,6 +1,6 @@
#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h"
-#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/Process.h"
@@ -54,8 +54,8 @@ int main(int argc, char *argv[]) {
RTDyldMemoryManager::deregisterEHFramesInProcess(Addr, Size);
};
- rpc::FDRawByteChannel Channel(InFD, OutFD);
- typedef remote::OrcRemoteTargetServer<rpc::FDRawByteChannel, HostOrcArch>
+ shared::FDRawByteChannel Channel(InFD, OutFD);
+ typedef remote::OrcRemoteTargetServer<shared::FDRawByteChannel, HostOrcArch>
JITServer;
JITServer Server(Channel, SymbolLookup, RegisterEHFrames, DeregisterEHFrames);
diff --git a/llvm/tools/lli/RemoteJITUtils.h b/llvm/tools/lli/RemoteJITUtils.h
index b2d06b9174f4..cc8d034f62a5 100644
--- a/llvm/tools/lli/RemoteJITUtils.h
+++ b/llvm/tools/lli/RemoteJITUtils.h
@@ -13,7 +13,7 @@
#ifndef LLVM_TOOLS_LLI_REMOTEJITUTILS_H
#define LLVM_TOOLS_LLI_REMOTEJITUTILS_H
-#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h"
#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
#include <mutex>
@@ -24,7 +24,7 @@
#endif
// launch the remote process (see lli.cpp) and return a channel to it.
-std::unique_ptr<llvm::orc::rpc::FDRawByteChannel> launchRemote();
+std::unique_ptr<llvm::orc::shared::FDRawByteChannel> launchRemote();
namespace llvm {
diff --git a/llvm/tools/lli/lli.cpp b/llvm/tools/lli/lli.cpp
index e9b48a8542ec..70c838126946 100644
--- a/llvm/tools/lli/lli.cpp
+++ b/llvm/tools/lli/lli.cpp
@@ -670,7 +670,7 @@ int main(int argc, char **argv, char * const *envp) {
// MCJIT itself. FIXME.
// Lanch the remote process and get a channel to it.
- std::unique_ptr<orc::rpc::FDRawByteChannel> C = launchRemote();
+ std::unique_ptr<orc::shared::FDRawByteChannel> C = launchRemote();
if (!C) {
WithColor::error(errs(), argv[0]) << "failed to launch remote JIT.\n";
exit(1);
@@ -1015,7 +1015,7 @@ void disallowOrcOptions() {
}
}
-std::unique_ptr<orc::rpc::FDRawByteChannel> launchRemote() {
+std::unique_ptr<orc::shared::FDRawByteChannel> launchRemote() {
#ifndef LLVM_ON_UNIX
llvm_unreachable("launchRemote not supported on non-Unix platforms");
#else
@@ -1065,7 +1065,7 @@ std::unique_ptr<orc::rpc::FDRawByteChannel> launchRemote() {
close(PipeFD[1][1]);
// Return an RPC channel connected to our end of the pipes.
- return std::make_unique<orc::rpc::FDRawByteChannel>(PipeFD[1][0],
- PipeFD[0][1]);
+ return std::make_unique<orc::shared::FDRawByteChannel>(PipeFD[1][0],
+ PipeFD[0][1]);
#endif
}
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp
index 09a01c242dee..fd7e30ffea87 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp
@@ -11,7 +11,7 @@
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
#include "llvm/Support/DynamicLibrary.h"
@@ -113,11 +113,11 @@ int main(int argc, char *argv[]) {
ExitOnErr.setBanner(std::string(argv[0]) + ":");
using JITLinkExecutorEndpoint =
- rpc::MultiThreadedRPCEndpoint<rpc::FDRawByteChannel>;
+ shared::MultiThreadedRPCEndpoint<shared::FDRawByteChannel>;
- rpc::registerStringError<rpc::FDRawByteChannel>();
+ shared::registerStringError<shared::FDRawByteChannel>();
- rpc::FDRawByteChannel C(InFD, OutFD);
+ shared::FDRawByteChannel C(InFD, OutFD);
JITLinkExecutorEndpoint EP(C, true);
OrcRPCTPCServer<JITLinkExecutorEndpoint> Server(EP);
Server.setProgramName(std::string("llvm-jitlink-executor"));
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
index 808a7db9c101..763189904a82 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
@@ -585,7 +585,7 @@ LLVMJITLinkRemoteTargetProcessControl::LaunchExecutor() {
inconvertibleErrorCode());
#else
- rpc::registerStringError<LLVMJITLinkChannel>();
+ shared::registerStringError<LLVMJITLinkChannel>();
constexpr int ReadEnd = 0;
constexpr int WriteEnd = 1;
@@ -640,8 +640,8 @@ LLVMJITLinkRemoteTargetProcessControl::LaunchExecutor() {
// Return an RPC channel connected to our end of the pipes.
auto SSP = std::make_shared<SymbolStringPool>();
- auto Channel = std::make_unique<rpc::FDRawByteChannel>(FromExecutor[ReadEnd],
- ToExecutor[WriteEnd]);
+ auto Channel = std::make_unique<shared::FDRawByteChannel>(
+ FromExecutor[ReadEnd], ToExecutor[WriteEnd]);
auto Endpoint = std::make_unique<LLVMJITLinkRPCEndpoint>(*Channel, true);
auto ReportError = [](Error Err) {
@@ -668,7 +668,7 @@ LLVMJITLinkRemoteTargetProcessControl::ConnectToExecutor() {
inconvertibleErrorCode());
#else
- rpc::registerStringError<LLVMJITLinkChannel>();
+ shared::registerStringError<LLVMJITLinkChannel>();
StringRef HostNameStr, PortStr;
std::tie(HostNameStr, PortStr) =
@@ -705,7 +705,7 @@ LLVMJITLinkRemoteTargetProcessControl::ConnectToExecutor() {
inconvertibleErrorCode());
auto SSP = std::make_shared<SymbolStringPool>();
- auto Channel = std::make_unique<rpc::FDRawByteChannel>(SockFD, SockFD);
+ auto Channel = std::make_unique<shared::FDRawByteChannel>(SockFD, SockFD);
auto Endpoint = std::make_unique<LLVMJITLinkRPCEndpoint>(*Channel, true);
auto ReportError = [](Error Err) {
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.h b/llvm/tools/llvm-jitlink/llvm-jitlink.h
index 5132eb204be1..13b55920cb5d 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink.h
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink.h
@@ -19,8 +19,8 @@
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
#include "llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h"
-#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
#include "llvm/ExecutionEngine/RuntimeDyldChecker.h"
#include "llvm/Support/Error.h"
@@ -48,9 +48,9 @@ class LLVMJITLinkObjectLinkingLayer : public orc::ObjectLinkingLayer {
Session &S;
};
-using LLVMJITLinkChannel = orc::rpc::FDRawByteChannel;
+using LLVMJITLinkChannel = orc::shared::FDRawByteChannel;
using LLVMJITLinkRPCEndpoint =
- orc::rpc::MultiThreadedRPCEndpoint<LLVMJITLinkChannel>;
+ orc::shared::MultiThreadedRPCEndpoint<LLVMJITLinkChannel>;
using LLVMJITLinkRemoteMemoryManager =
orc::OrcRPCTPCJITLinkMemoryManager<LLVMJITLinkRPCEndpoint>;
using LLVMJITLinkRemoteMemoryAccess =
diff --git a/llvm/unittests/ExecutionEngine/Orc/QueueChannel.h b/llvm/unittests/ExecutionEngine/Orc/QueueChannel.h
index fabe2d11fe9d..6d011baf1ab2 100644
--- a/llvm/unittests/ExecutionEngine/Orc/QueueChannel.h
+++ b/llvm/unittests/ExecutionEngine/Orc/QueueChannel.h
@@ -9,7 +9,7 @@
#ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_QUEUECHANNEL_H
#define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_QUEUECHANNEL_H
-#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
#include "llvm/Support/Error.h"
#include <atomic>
@@ -70,7 +70,7 @@ class Queue : public std::queue<char> {
std::function<Error()> ReadError, WriteError;
};
-class QueueChannel : public orc::rpc::RawByteChannel {
+class QueueChannel : public orc::shared::RawByteChannel {
public:
QueueChannel(std::shared_ptr<Queue> InQueue,
std::shared_ptr<Queue> OutQueue)
@@ -84,25 +84,25 @@ class QueueChannel : public orc::rpc::RawByteChannel {
template <typename FunctionIdT, typename SequenceIdT>
Error startSendMessage(const FunctionIdT &FnId, const SequenceIdT &SeqNo) {
++InFlightOutgoingMessages;
- return orc::rpc::RawByteChannel::startSendMessage(FnId, SeqNo);
+ return orc::shared::RawByteChannel::startSendMessage(FnId, SeqNo);
}
Error endSendMessage() {
--InFlightOutgoingMessages;
++CompletedOutgoingMessages;
- return orc::rpc::RawByteChannel::endSendMessage();
+ return orc::shared::RawByteChannel::endSendMessage();
}
template <typename FunctionIdT, typename SequenceNumberT>
Error startReceiveMessage(FunctionIdT &FnId, SequenceNumberT &SeqNo) {
++InFlightIncomingMessages;
- return orc::rpc::RawByteChannel::startReceiveMessage(FnId, SeqNo);
+ return orc::shared::RawByteChannel::startReceiveMessage(FnId, SeqNo);
}
Error endReceiveMessage() {
--InFlightIncomingMessages;
++CompletedIncomingMessages;
- return orc::rpc::RawByteChannel::endReceiveMessage();
+ return orc::shared::RawByteChannel::endReceiveMessage();
}
Error readBytes(char *Dst, unsigned Size) override {
diff --git a/llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
index 734511bf33ad..1ad13e8b4e20 100644
--- a/llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
#include "QueueChannel.h"
#include "gtest/gtest.h"
@@ -14,19 +14,18 @@
using namespace llvm;
using namespace llvm::orc;
-using namespace llvm::orc::rpc;
+using namespace llvm::orc::shared;
class RPCFoo {};
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
- template <>
- class RPCTypeName<RPCFoo> {
- public:
- static const char* getName() { return "RPCFoo"; }
- };
+template <> class SerializationTypeName<RPCFoo> {
+public:
+ static const char *getName() { return "RPCFoo"; }
+};
template <>
class SerializationTraits<QueueChannel, RPCFoo, RPCFoo> {
@@ -40,7 +39,7 @@ namespace rpc {
}
};
-} // end namespace rpc
+ } // namespace shared
} // end namespace orc
} // end namespace llvm
@@ -96,65 +95,64 @@ void registerDummyErrorSerialization() {
namespace llvm {
namespace orc {
-namespace rpc {
+namespace shared {
- template <>
- class SerializationTraits<QueueChannel, RPCFoo, RPCBar> {
- public:
- static Error serialize(QueueChannel&, const RPCBar&) {
- return Error::success();
- }
+template <> class SerializationTraits<QueueChannel, RPCFoo, RPCBar> {
+public:
+ static Error serialize(QueueChannel &, const RPCBar &) {
+ return Error::success();
+ }
- static Error deserialize(QueueChannel&, RPCBar&) {
- return Error::success();
- }
+ static Error deserialize(QueueChannel &, RPCBar &) {
+ return Error::success();
+ }
};
-} // end namespace rpc
+} // end namespace shared
} // end namespace orc
} // end namespace llvm
namespace DummyRPCAPI {
- class VoidBool : public Function<VoidBool, void(bool)> {
- public:
- static const char* getName() { return "VoidBool"; }
- };
-
- class IntInt : public Function<IntInt, int32_t(int32_t)> {
- public:
- static const char* getName() { return "IntInt"; }
- };
+class VoidBool : public RPCFunction<VoidBool, void(bool)> {
+public:
+ static const char *getName() { return "VoidBool"; }
+};
- class VoidString : public Function<VoidString, void(std::string)> {
- public:
- static const char* getName() { return "VoidString"; }
- };
+class IntInt : public RPCFunction<IntInt, int32_t(int32_t)> {
+public:
+ static const char *getName() { return "IntInt"; }
+};
- class AllTheTypes
- : public Function<AllTheTypes, void(int8_t, uint8_t, int16_t, uint16_t,
- int32_t, uint32_t, int64_t, uint64_t,
- bool, std::string, std::vector<int>,
- std::set<int>, std::map<int, bool>)> {
- public:
- static const char* getName() { return "AllTheTypes"; }
- };
+class VoidString : public RPCFunction<VoidString, void(std::string)> {
+public:
+ static const char *getName() { return "VoidString"; }
+};
- class CustomType : public Function<CustomType, RPCFoo(RPCFoo)> {
- public:
- static const char* getName() { return "CustomType"; }
- };
+class AllTheTypes
+ : public RPCFunction<AllTheTypes,
+ void(int8_t, uint8_t, int16_t, uint16_t, int32_t,
+ uint32_t, int64_t, uint64_t, bool, std::string,
+ std::vector<int>, std::set<int>,
+ std::map<int, bool>)> {
+public:
+ static const char *getName() { return "AllTheTypes"; }
+};
- class ErrorFunc : public Function<ErrorFunc, Error()> {
- public:
- static const char* getName() { return "ErrorFunc"; }
- };
+class CustomType : public RPCFunction<CustomType, RPCFoo(RPCFoo)> {
+public:
+ static const char *getName() { return "CustomType"; }
+};
- class ExpectedFunc : public Function<ExpectedFunc, Expected<uint32_t>()> {
- public:
- static const char* getName() { return "ExpectedFunc"; }
- };
+class ErrorFunc : public RPCFunction<ErrorFunc, Error()> {
+public:
+ static const char *getName() { return "ErrorFunc"; }
+};
+class ExpectedFunc : public RPCFunction<ExpectedFunc, Expected<uint32_t>()> {
+public:
+ static const char *getName() { return "ExpectedFunc"; }
+};
}
class DummyRPCEndpoint : public SingleThreadedRPCEndpoint<QueueChannel> {
More information about the llvm-branch-commits
mailing list