19#define DEBUG_TYPE "orc"
30#if LLVM_ENABLE_THREADS
31void SimpleRemoteEPCServer::ThreadDispatcher::dispatch(
34 std::lock_guard<std::mutex> Lock(DispatchMutex);
40 std::thread([
this, Work = std::move(Work)]()
mutable {
42 std::lock_guard<std::mutex> Lock(DispatchMutex);
44 OutstandingCV.notify_all();
48void SimpleRemoteEPCServer::ThreadDispatcher::shutdown() {
49 std::unique_lock<std::mutex> Lock(DispatchMutex);
51 OutstandingCV.wait(Lock, [
this]() {
return Outstanding == 0; });
67 dbgs() <<
"SimpleRemoteEPCServer::handleMessage: opc = ";
71 assert(SeqNo == 0 &&
"Non-zero SeqNo for Setup?");
72 assert(!TagAddr &&
"Non-zero TagAddr for Setup?");
76 assert(SeqNo == 0 &&
"Non-zero SeqNo for Hangup?");
77 assert(!TagAddr &&
"Non-zero TagAddr for Hangup?");
81 assert(!TagAddr &&
"Non-zero TagAddr for Result?");
84 dbgs() <<
"CallWrapper";
87 dbgs() <<
", seqno = " << SeqNo <<
", tag-addr = " << TagAddr
88 <<
", arg-buffer = " <<
formatv(
"{0:x}", ArgBytes.
size())
92 using UT = std::underlying_type_t<SimpleRemoteEPCOpcode>;
94 return make_error<StringError>(
"Unexpected opcode",
100 return make_error<StringError>(
"Unexpected Setup opcode",
105 if (
auto Err = handleResult(SeqNo, TagAddr, std::move(ArgBytes)))
106 return std::move(Err);
109 handleCallWrapper(SeqNo, TagAddr, std::move(ArgBytes));
116 std::unique_lock<std::mutex> Lock(ServerStateMutex);
117 ShutdownCV.wait(Lock, [
this]() {
return RunState == ServerShutDown; });
118 return std::move(ShutdownErr);
125 std::lock_guard<std::mutex> Lock(ServerStateMutex);
126 std::swap(TmpPending, PendingJITDispatchResults);
127 RunState = ServerShuttingDown;
131 for (
auto &KV : TmpPending)
132 KV.second->set_value(
139 while (!Services.empty()) {
141 joinErrors(std::move(ShutdownErr), Services.back()->shutdown());
145 std::lock_guard<std::mutex> Lock(ServerStateMutex);
146 ShutdownErr =
joinErrors(std::move(ShutdownErr), std::move(Err));
147 RunState = ServerShutDown;
148 ShutdownCV.notify_all();
156 dbgs() <<
"SimpleRemoteEPCServer::sendMessage: opc = ";
160 assert(SeqNo == 0 &&
"Non-zero SeqNo for Setup?");
161 assert(!TagAddr &&
"Non-zero TagAddr for Setup?");
165 assert(SeqNo == 0 &&
"Non-zero SeqNo for Hangup?");
166 assert(!TagAddr &&
"Non-zero TagAddr for Hangup?");
170 assert(!TagAddr &&
"Non-zero TagAddr for Result?");
173 dbgs() <<
"CallWrapper";
176 dbgs() <<
", seqno = " << SeqNo <<
", tag-addr = " << TagAddr
177 <<
", arg-buffer = " <<
formatv(
"{0:x}", ArgBytes.
size())
180 auto Err =
T->sendMessage(OpC, SeqNo, TagAddr, ArgBytes);
183 dbgs() <<
" \\--> SimpleRemoteEPC::sendMessage failed\n";
188Error SimpleRemoteEPCServer::sendSetupMessage(
189 StringMap<std::vector<char>> BootstrapMap,
192 using namespace SimpleRemoteEPCDefaultBootstrapSymbolNames;
194 std::vector<char> SetupPacket;
205 "Dispatch context name should not be set");
207 "Dispatch function name should not be set");
217 auto SetupPacketBytes =
220 if (!SPSSerialize::serialize(OB, EI))
221 return make_error<StringError>(
"Could not send setup packet",
225 {SetupPacketBytes.data(), SetupPacketBytes.size()});
228Error SimpleRemoteEPCServer::handleResult(
231 std::promise<shared::WrapperFunctionResult> *
P =
nullptr;
233 std::lock_guard<std::mutex> Lock(ServerStateMutex);
234 auto I = PendingJITDispatchResults.
find(SeqNo);
235 if (
I == PendingJITDispatchResults.
end())
236 return make_error<StringError>(
"No call for sequence number " +
240 PendingJITDispatchResults.
erase(
I);
244 memcpy(
R.data(), ArgBytes.
data(), ArgBytes.
size());
245 P->set_value(std::move(R));
249void SimpleRemoteEPCServer::handleCallWrapper(
252 D->dispatch([
this, RemoteSeqNo, TagAddr, ArgBytes = std::move(ArgBytes)]() {
255 auto *Fn = TagAddr.
toPtr<WrapperFnTy>();
257 Fn(ArgBytes.
data(), ArgBytes.
size()));
260 {ResultBytes.data(), ResultBytes.size()}))
261 ReportError(std::move(Err));
266SimpleRemoteEPCServer::doJITDispatch(
const void *FnTag,
const char *ArgData,
269 std::promise<shared::WrapperFunctionResult> ResultP;
270 auto ResultF = ResultP.get_future();
272 std::lock_guard<std::mutex> Lock(ServerStateMutex);
273 if (RunState != ServerRunning)
275 "jit_dispatch not available (EPC server shut down)");
277 SeqNo = getNextSeqNo();
278 assert(!PendingJITDispatchResults.
count(SeqNo) &&
"SeqNo already in use");
279 PendingJITDispatchResults[SeqNo] = &ResultP;
284 ReportError(std::move(Err));
286 return ResultF.get();
290SimpleRemoteEPCServer::jitDispatchEntry(
void *DispatchCtx,
const void *FnTag,
291 const char *ArgData,
size_t ArgSize) {
293 ->doJITDispatch(FnTag, ArgData, ArgSize)
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)
Provides a library for accessing information about this process and other processes on the operating ...
LLVM_ABI llvm::orc::shared::CWrapperFunctionResult llvm_orc_deregisterEHFrameSectionWrapper(const char *Data, uint64_t Size)
LLVM_ABI llvm::orc::shared::CWrapperFunctionResult llvm_orc_registerEHFrameSectionWrapper(const char *Data, uint64_t Size)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
iterator find(const_arg_type_t< KeyT > Val)
bool erase(const KeyT &Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
pointer data()
Return a pointer to the vector's buffer, even if empty().
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Represents an address in the executor process.
static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())
Create an ExecutorAddr from the given pointer.
std::enable_if_t< std::is_pointer< T >::value, T > toPtr(WrapFn &&Wrap=WrapFn()) const
Cast this ExecutorAddr to a pointer of the given type.
virtual ~ExecutorBootstrapService()
A simple EPC server implementation.
static StringMap< ExecutorAddr > defaultBootstrapSymbols()
Expected< HandleMessageAction > handleMessage(SimpleRemoteEPCOpcode OpC, uint64_t SeqNo, ExecutorAddr TagAddr, SimpleRemoteEPCArgBytesVector ArgBytes) override
Call to handle an incoming message.
void handleDisconnect(Error Err) override
Handle a disconnection from the underlying transport.
Error waitForDisconnect()
A utility class for serializing to a blob from a variadic list.
Output char buffer with overflow check.
C++ wrapper function result: Same as CWrapperFunctionResult but auto-releases memory.
static WrapperFunctionResult allocate(size_t Size)
Create a WrapperFunctionResult with the given size and return a pointer to the underlying memory.
CWrapperFunctionResult release()
Release ownership of the contained CWrapperFunctionResult.
static WrapperFunctionResult createOutOfBandError(const char *Msg)
Create an out-of-band error by copying the given string.
static Expected< unsigned > getPageSize()
Get the process's page size.
unique_function is a type-erasing functor similar to std::function.
@ OB
OB - OneByte - Set if this instruction has a one byte opcode.
const char * DispatchFnName
const char * ExecutorSessionObjectName
void addTo(StringMap< ExecutorAddr > &M)
const char * DeregisterEHFrameSectionWrapperName
const char * RegisterEHFrameSectionWrapperName
std::string getProcessTriple()
getProcessTriple() - Return an appropriate target triple for generating code to be loaded into the cu...
This is an optimization pass for GlobalISel generic memory operations.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
Error joinErrors(Error E1, Error E2)
Concatenate errors.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
StringMap< ExecutorAddr > BootstrapSymbols
StringMap< std::vector< char > > BootstrapMap