LLVM 17.0.0git
SimpleRemoteEPC.cpp
Go to the documentation of this file.
1//===------- SimpleRemoteEPC.cpp -- Simple remote executor control --------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
14
15#define DEBUG_TYPE "orc"
16
17namespace llvm {
18namespace orc {
19
21#ifndef NDEBUG
22 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
23 assert(Disconnected && "Destroyed without disconnection");
24#endif // NDEBUG
25}
26
28SimpleRemoteEPC::loadDylib(const char *DylibPath) {
29 return DylibMgr->open(DylibPath, 0);
30}
31
34 std::vector<tpctypes::LookupResult> Result;
35
36 for (auto &Element : Request) {
37 if (auto R = DylibMgr->lookup(Element.Handle, Element.Symbols)) {
38 Result.push_back({});
39 Result.back().reserve(R->size());
40 for (auto Addr : *R)
41 Result.back().push_back(Addr);
42 } else
43 return R.takeError();
44 }
45 return std::move(Result);
46}
47
50 int64_t Result = 0;
51 if (auto Err = callSPSWrapper<rt::SPSRunAsMainSignature>(
52 RunAsMainAddr, Result, ExecutorAddr(MainFnAddr), Args))
53 return std::move(Err);
54 return Result;
55}
56
58 int32_t Result = 0;
59 if (auto Err = callSPSWrapper<rt::SPSRunAsVoidFunctionSignature>(
60 RunAsVoidFunctionAddr, Result, ExecutorAddr(VoidFnAddr)))
61 return std::move(Err);
62 return Result;
63}
64
66 int Arg) {
67 int32_t Result = 0;
68 if (auto Err = callSPSWrapper<rt::SPSRunAsIntFunctionSignature>(
69 RunAsIntFunctionAddr, Result, ExecutorAddr(IntFnAddr), Arg))
70 return std::move(Err);
71 return Result;
72}
73
75 IncomingWFRHandler OnComplete,
76 ArrayRef<char> ArgBuffer) {
77 uint64_t SeqNo;
78 {
79 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
80 SeqNo = getNextSeqNo();
81 assert(!PendingCallWrapperResults.count(SeqNo) && "SeqNo already in use");
82 PendingCallWrapperResults[SeqNo] = std::move(OnComplete);
83 }
84
85 if (auto Err = sendMessage(SimpleRemoteEPCOpcode::CallWrapper, SeqNo,
86 WrapperFnAddr, ArgBuffer)) {
88
89 // We just registered OnComplete, but there may be a race between this
90 // thread returning from sendMessage and handleDisconnect being called from
91 // the transport's listener thread. If handleDisconnect gets there first
92 // then it will have failed 'H' for us. If we get there first (or if
93 // handleDisconnect already ran) then we need to take care of it.
94 {
95 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
96 auto I = PendingCallWrapperResults.find(SeqNo);
97 if (I != PendingCallWrapperResults.end()) {
98 H = std::move(I->second);
99 PendingCallWrapperResults.erase(I);
100 }
101 }
102
103 if (H)
105
106 getExecutionSession().reportError(std::move(Err));
107 }
108}
109
111 T->disconnect();
112 D->shutdown();
113 std::unique_lock<std::mutex> Lock(SimpleRemoteEPCMutex);
114 DisconnectCV.wait(Lock, [this] { return Disconnected; });
115 return std::move(DisconnectErr);
116}
117
120 ExecutorAddr TagAddr,
122
123 LLVM_DEBUG({
124 dbgs() << "SimpleRemoteEPC::handleMessage: opc = ";
125 switch (OpC) {
127 dbgs() << "Setup";
128 assert(SeqNo == 0 && "Non-zero SeqNo for Setup?");
129 assert(TagAddr.getValue() == 0 && "Non-zero TagAddr for Setup?");
130 break;
132 dbgs() << "Hangup";
133 assert(SeqNo == 0 && "Non-zero SeqNo for Hangup?");
134 assert(TagAddr.getValue() == 0 && "Non-zero TagAddr for Hangup?");
135 break;
137 dbgs() << "Result";
138 assert(TagAddr.getValue() == 0 && "Non-zero TagAddr for Result?");
139 break;
141 dbgs() << "CallWrapper";
142 break;
143 }
144 dbgs() << ", seqno = " << SeqNo
145 << ", tag-addr = " << formatv("{0:x}", TagAddr.getValue())
146 << ", arg-buffer = " << formatv("{0:x}", ArgBytes.size())
147 << " bytes\n";
148 });
149
150 using UT = std::underlying_type_t<SimpleRemoteEPCOpcode>;
151 if (static_cast<UT>(OpC) > static_cast<UT>(SimpleRemoteEPCOpcode::LastOpC))
152 return make_error<StringError>("Unexpected opcode",
154
155 switch (OpC) {
157 if (auto Err = handleSetup(SeqNo, TagAddr, std::move(ArgBytes)))
158 return std::move(Err);
159 break;
161 T->disconnect();
162 if (auto Err = handleHangup(std::move(ArgBytes)))
163 return std::move(Err);
164 return EndSession;
166 if (auto Err = handleResult(SeqNo, TagAddr, std::move(ArgBytes)))
167 return std::move(Err);
168 break;
170 handleCallWrapper(SeqNo, TagAddr, std::move(ArgBytes));
171 break;
172 }
173 return ContinueSession;
174}
175
177 LLVM_DEBUG({
178 dbgs() << "SimpleRemoteEPC::handleDisconnect: "
179 << (Err ? "failure" : "success") << "\n";
180 });
181
183
184 {
185 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
186 std::swap(TmpPending, PendingCallWrapperResults);
187 }
188
189 for (auto &KV : TmpPending)
190 KV.second(
192
193 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
194 DisconnectErr = joinErrors(std::move(DisconnectErr), std::move(Err));
195 Disconnected = true;
196 DisconnectCV.notify_all();
197}
198
200SimpleRemoteEPC::createDefaultMemoryManager(SimpleRemoteEPC &SREPC) {
202 if (auto Err = SREPC.getBootstrapSymbols(
203 {{SAs.Allocator, rt::SimpleExecutorMemoryManagerInstanceName},
204 {SAs.Reserve, rt::SimpleExecutorMemoryManagerReserveWrapperName},
205 {SAs.Finalize, rt::SimpleExecutorMemoryManagerFinalizeWrapperName},
206 {SAs.Deallocate,
207 rt::SimpleExecutorMemoryManagerDeallocateWrapperName}}))
208 return std::move(Err);
209
210 return std::make_unique<EPCGenericJITLinkMemoryManager>(SREPC, SAs);
211}
212
213Expected<std::unique_ptr<ExecutorProcessControl::MemoryAccess>>
214SimpleRemoteEPC::createDefaultMemoryAccess(SimpleRemoteEPC &SREPC) {
215 return nullptr;
216}
217
218Error SimpleRemoteEPC::sendMessage(SimpleRemoteEPCOpcode OpC, uint64_t SeqNo,
219 ExecutorAddr TagAddr,
220 ArrayRef<char> ArgBytes) {
221 assert(OpC != SimpleRemoteEPCOpcode::Setup &&
222 "SimpleRemoteEPC sending Setup message? That's the wrong direction.");
223
224 LLVM_DEBUG({
225 dbgs() << "SimpleRemoteEPC::sendMessage: opc = ";
226 switch (OpC) {
227 case SimpleRemoteEPCOpcode::Hangup:
228 dbgs() << "Hangup";
229 assert(SeqNo == 0 && "Non-zero SeqNo for Hangup?");
230 assert(TagAddr.getValue() == 0 && "Non-zero TagAddr for Hangup?");
231 break;
232 case SimpleRemoteEPCOpcode::Result:
233 dbgs() << "Result";
234 assert(TagAddr.getValue() == 0 && "Non-zero TagAddr for Result?");
235 break;
236 case SimpleRemoteEPCOpcode::CallWrapper:
237 dbgs() << "CallWrapper";
238 break;
239 default:
240 llvm_unreachable("Invalid opcode");
241 }
242 dbgs() << ", seqno = " << SeqNo
243 << ", tag-addr = " << formatv("{0:x}", TagAddr.getValue())
244 << ", arg-buffer = " << formatv("{0:x}", ArgBytes.size())
245 << " bytes\n";
246 });
247 auto Err = T->sendMessage(OpC, SeqNo, TagAddr, ArgBytes);
248 LLVM_DEBUG({
249 if (Err)
250 dbgs() << " \\--> SimpleRemoteEPC::sendMessage failed\n";
251 });
252 return Err;
253}
254
255Error SimpleRemoteEPC::handleSetup(uint64_t SeqNo, ExecutorAddr TagAddr,
256 SimpleRemoteEPCArgBytesVector ArgBytes) {
257 if (SeqNo != 0)
258 return make_error<StringError>("Setup packet SeqNo not zero",
260
261 if (TagAddr)
262 return make_error<StringError>("Setup packet TagAddr not zero",
264
265 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
266 auto I = PendingCallWrapperResults.find(0);
267 assert(PendingCallWrapperResults.size() == 1 &&
268 I != PendingCallWrapperResults.end() &&
269 "Setup message handler not connectly set up");
270 auto SetupMsgHandler = std::move(I->second);
271 PendingCallWrapperResults.erase(I);
272
273 auto WFR =
274 shared::WrapperFunctionResult::copyFrom(ArgBytes.data(), ArgBytes.size());
275 SetupMsgHandler(std::move(WFR));
276 return Error::success();
277}
278
279Error SimpleRemoteEPC::setup(Setup S) {
280 using namespace SimpleRemoteEPCDefaultBootstrapSymbolNames;
281
282 std::promise<MSVCPExpected<SimpleRemoteEPCExecutorInfo>> EIP;
283 auto EIF = EIP.get_future();
284
285 // Prepare a handler for the setup packet.
286 PendingCallWrapperResults[0] =
287 RunInPlace()(
288 [&](shared::WrapperFunctionResult SetupMsgBytes) {
289 if (const char *ErrMsg = SetupMsgBytes.getOutOfBandError()) {
290 EIP.set_value(
291 make_error<StringError>(ErrMsg, inconvertibleErrorCode()));
292 return;
293 }
294 using SPSSerialize =
295 shared::SPSArgList<shared::SPSSimpleRemoteEPCExecutorInfo>;
296 shared::SPSInputBuffer IB(SetupMsgBytes.data(), SetupMsgBytes.size());
297 SimpleRemoteEPCExecutorInfo EI;
298 if (SPSSerialize::deserialize(IB, EI))
299 EIP.set_value(EI);
300 else
301 EIP.set_value(make_error<StringError>(
302 "Could not deserialize setup message", inconvertibleErrorCode()));
303 });
304
305 // Start the transport.
306 if (auto Err = T->start())
307 return Err;
308
309 // Wait for setup packet to arrive.
310 auto EI = EIF.get();
311 if (!EI) {
312 T->disconnect();
313 return EI.takeError();
314 }
315
316 LLVM_DEBUG({
317 dbgs() << "SimpleRemoteEPC received setup message:\n"
318 << " Triple: " << EI->TargetTriple << "\n"
319 << " Page size: " << EI->PageSize << "\n"
320 << " Bootstrap symbols:\n";
321 for (const auto &KV : EI->BootstrapSymbols)
322 dbgs() << " " << KV.first() << ": "
323 << formatv("{0:x16}", KV.second.getValue()) << "\n";
324 });
325 TargetTriple = Triple(EI->TargetTriple);
326 PageSize = EI->PageSize;
327 BootstrapSymbols = std::move(EI->BootstrapSymbols);
328
329 if (auto Err = getBootstrapSymbols(
330 {{JDI.JITDispatchContext, ExecutorSessionObjectName},
331 {JDI.JITDispatchFunction, DispatchFnName},
332 {RunAsMainAddr, rt::RunAsMainWrapperName},
333 {RunAsVoidFunctionAddr, rt::RunAsVoidFunctionWrapperName},
334 {RunAsIntFunctionAddr, rt::RunAsIntFunctionWrapperName}}))
335 return Err;
336
337 if (auto DM =
338 EPCGenericDylibManager::CreateWithDefaultBootstrapSymbols(*this))
339 DylibMgr = std::make_unique<EPCGenericDylibManager>(std::move(*DM));
340 else
341 return DM.takeError();
342
343 // Set a default CreateMemoryManager if none is specified.
344 if (!S.CreateMemoryManager)
345 S.CreateMemoryManager = createDefaultMemoryManager;
346
347 if (auto MemMgr = S.CreateMemoryManager(*this)) {
348 OwnedMemMgr = std::move(*MemMgr);
349 this->MemMgr = OwnedMemMgr.get();
350 } else
351 return MemMgr.takeError();
352
353 // Set a default CreateMemoryAccess if none is specified.
354 if (!S.CreateMemoryAccess)
355 S.CreateMemoryAccess = createDefaultMemoryAccess;
356
357 if (auto MemAccess = S.CreateMemoryAccess(*this)) {
358 OwnedMemAccess = std::move(*MemAccess);
359 this->MemAccess = OwnedMemAccess.get();
360 } else
361 return MemAccess.takeError();
362
363 return Error::success();
364}
365
366Error SimpleRemoteEPC::handleResult(uint64_t SeqNo, ExecutorAddr TagAddr,
367 SimpleRemoteEPCArgBytesVector ArgBytes) {
368 IncomingWFRHandler SendResult;
369
370 if (TagAddr)
371 return make_error<StringError>("Unexpected TagAddr in result message",
373
374 {
375 std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
376 auto I = PendingCallWrapperResults.find(SeqNo);
377 if (I == PendingCallWrapperResults.end())
378 return make_error<StringError>("No call for sequence number " +
379 Twine(SeqNo),
381 SendResult = std::move(I->second);
382 PendingCallWrapperResults.erase(I);
383 releaseSeqNo(SeqNo);
384 }
385
386 auto WFR =
387 shared::WrapperFunctionResult::copyFrom(ArgBytes.data(), ArgBytes.size());
388 SendResult(std::move(WFR));
389 return Error::success();
390}
391
392void SimpleRemoteEPC::handleCallWrapper(
393 uint64_t RemoteSeqNo, ExecutorAddr TagAddr,
394 SimpleRemoteEPCArgBytesVector ArgBytes) {
395 assert(ES && "No ExecutionSession attached");
396 D->dispatch(makeGenericNamedTask(
397 [this, RemoteSeqNo, TagAddr, ArgBytes = std::move(ArgBytes)]() {
398 ES->runJITDispatchHandler(
399 [this, RemoteSeqNo](shared::WrapperFunctionResult WFR) {
400 if (auto Err =
401 sendMessage(SimpleRemoteEPCOpcode::Result, RemoteSeqNo,
402 ExecutorAddr(), {WFR.data(), WFR.size()}))
403 getExecutionSession().reportError(std::move(Err));
404 },
405 TagAddr.getValue(), ArgBytes);
406 },
407 "callWrapper task"));
408}
409
410Error SimpleRemoteEPC::handleHangup(SimpleRemoteEPCArgBytesVector ArgBytes) {
411 using namespace llvm::orc::shared;
412 auto WFR = WrapperFunctionResult::copyFrom(ArgBytes.data(), ArgBytes.size());
413 if (const char *ErrMsg = WFR.getOutOfBandError())
414 return make_error<StringError>(ErrMsg, inconvertibleErrorCode());
415
417 SPSInputBuffer IB(WFR.data(), WFR.size());
419 return make_error<StringError>("Could not deserialize hangup info",
421 return fromSPSSerializable(std::move(Info));
422}
423
424} // end namespace orc
425} // end namespace llvm
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static Error reportError(StringRef Message)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define LLVM_DEBUG(X)
Definition: Debug.h:101
static RegisterPass< DebugifyModulePass > DM("debugify", "Attach debug info to everything")
uint64_t Addr
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)
#define I(x, y, z)
Definition: MD5.cpp:58
#define H(x, y, z)
Definition: MD5.cpp:57
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:145
iterator end()
Definition: DenseMap.h:84
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
size_t size() const
Definition: SmallVector.h:91
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
void reportError(Error Err)
Report a error for this execution session.
Definition: Core.h:1493
Represents an address in the executor process.
uint64_t getValue() const
A handler or incoming WrapperFunctionResults – either return values from callWrapper* calls,...
std::unique_ptr< TaskDispatcher > D
Error getBootstrapSymbols(ArrayRef< std::pair< ExecutorAddr &, StringRef > > Pairs) const
For each (ExecutorAddr&, StringRef) pair, looks up the string in the bootstrap symbols map and writes...
ExecutionSession & getExecutionSession()
Return the ExecutionSession associated with this instance.
void handleDisconnect(Error Err) override
Handle a disconnection from the underlying transport.
Expected< int32_t > runAsMain(ExecutorAddr MainFnAddr, ArrayRef< std::string > Args) override
Run function with a main-like signature.
Expected< HandleMessageAction > handleMessage(SimpleRemoteEPCOpcode OpC, uint64_t SeqNo, ExecutorAddr TagAddr, SimpleRemoteEPCArgBytesVector ArgBytes) override
Handle receipt of a message.
Error disconnect() override
Disconnect from the target process.
Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath) override
Load the dynamic library at the given path and return a handle to it.
Expected< std::vector< tpctypes::LookupResult > > lookupSymbols(ArrayRef< LookupRequest > Request) override
Search for symbols in the target process.
Expected< int32_t > runAsVoidFunction(ExecutorAddr VoidFnAddr) override
Run function with a int (*)(void) signature.
void callWrapperAsync(ExecutorAddr WrapperFnAddr, IncomingWFRHandler OnComplete, ArrayRef< char > ArgBuffer) override
Run a wrapper function in the executor.
Expected< int32_t > runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override
Run function with a int (*)(int) signature.
A utility class for serializing to a blob from a variadic list.
Input char buffer with underflow check.
static WrapperFunctionResult createOutOfBandError(const char *Msg)
Create an out-of-band error by copying the given string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Error fromSPSSerializable(SPSSerializableError BSE)
std::unique_ptr< GenericNamedTask > makeGenericNamedTask(FnT &&Fn, std::string Desc)
Create a generic named task from a std::string description.
Definition: TaskDispatch.h:78
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:79
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:427
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853