1 //===------- SimpleEPCServer.cpp - EPC over simple abstract channel -------===// 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 9 #include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleRemoteEPCServer.h" 10 11 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h" 12 #include "llvm/Support/FormatVariadic.h" 13 #include "llvm/Support/Process.h" 14 #include "llvm/TargetParser/Host.h" 15 16 #include "OrcRTBootstrap.h" 17 18 #define DEBUG_TYPE "orc" 19 20 using namespace llvm::orc::shared; 21 22 namespace llvm { 23 namespace orc { 24 25 ExecutorBootstrapService::~ExecutorBootstrapService() = default; 26 27 SimpleRemoteEPCServer::Dispatcher::~Dispatcher() = default; 28 29 #if LLVM_ENABLE_THREADS 30 void SimpleRemoteEPCServer::ThreadDispatcher::dispatch( 31 unique_function<void()> Work) { 32 { 33 std::lock_guard<std::mutex> Lock(DispatchMutex); 34 if (!Running) 35 return; 36 ++Outstanding; 37 } 38 39 std::thread([this, Work = std::move(Work)]() mutable { 40 Work(); 41 std::lock_guard<std::mutex> Lock(DispatchMutex); 42 --Outstanding; 43 OutstandingCV.notify_all(); 44 }).detach(); 45 } 46 47 void SimpleRemoteEPCServer::ThreadDispatcher::shutdown() { 48 std::unique_lock<std::mutex> Lock(DispatchMutex); 49 Running = false; 50 OutstandingCV.wait(Lock, [this]() { return Outstanding == 0; }); 51 } 52 #endif 53 54 StringMap<ExecutorAddr> SimpleRemoteEPCServer::defaultBootstrapSymbols() { 55 StringMap<ExecutorAddr> DBS; 56 rt_bootstrap::addTo(DBS); 57 return DBS; 58 } 59 60 Expected<SimpleRemoteEPCTransportClient::HandleMessageAction> 61 SimpleRemoteEPCServer::handleMessage(SimpleRemoteEPCOpcode OpC, uint64_t SeqNo, 62 ExecutorAddr TagAddr, 63 SimpleRemoteEPCArgBytesVector ArgBytes) { 64 65 LLVM_DEBUG({ 66 dbgs() << "SimpleRemoteEPCServer::handleMessage: opc = "; 67 switch (OpC) { 68 case SimpleRemoteEPCOpcode::Setup: 69 dbgs() << "Setup"; 70 assert(SeqNo == 0 && "Non-zero SeqNo for Setup?"); 71 assert(!TagAddr && "Non-zero TagAddr for Setup?"); 72 break; 73 case SimpleRemoteEPCOpcode::Hangup: 74 dbgs() << "Hangup"; 75 assert(SeqNo == 0 && "Non-zero SeqNo for Hangup?"); 76 assert(!TagAddr && "Non-zero TagAddr for Hangup?"); 77 break; 78 case SimpleRemoteEPCOpcode::Result: 79 dbgs() << "Result"; 80 assert(!TagAddr && "Non-zero TagAddr for Result?"); 81 break; 82 case SimpleRemoteEPCOpcode::CallWrapper: 83 dbgs() << "CallWrapper"; 84 break; 85 } 86 dbgs() << ", seqno = " << SeqNo << ", tag-addr = " << TagAddr 87 << ", arg-buffer = " << formatv("{0:x}", ArgBytes.size()) 88 << " bytes\n"; 89 }); 90 91 using UT = std::underlying_type_t<SimpleRemoteEPCOpcode>; 92 if (static_cast<UT>(OpC) > static_cast<UT>(SimpleRemoteEPCOpcode::LastOpC)) 93 return make_error<StringError>("Unexpected opcode", 94 inconvertibleErrorCode()); 95 96 // TODO: Clean detach message? 97 switch (OpC) { 98 case SimpleRemoteEPCOpcode::Setup: 99 return make_error<StringError>("Unexpected Setup opcode", 100 inconvertibleErrorCode()); 101 case SimpleRemoteEPCOpcode::Hangup: 102 return SimpleRemoteEPCTransportClient::EndSession; 103 case SimpleRemoteEPCOpcode::Result: 104 if (auto Err = handleResult(SeqNo, TagAddr, std::move(ArgBytes))) 105 return std::move(Err); 106 break; 107 case SimpleRemoteEPCOpcode::CallWrapper: 108 handleCallWrapper(SeqNo, TagAddr, std::move(ArgBytes)); 109 break; 110 } 111 return ContinueSession; 112 } 113 114 Error SimpleRemoteEPCServer::waitForDisconnect() { 115 std::unique_lock<std::mutex> Lock(ServerStateMutex); 116 ShutdownCV.wait(Lock, [this]() { return RunState == ServerShutDown; }); 117 return std::move(ShutdownErr); 118 } 119 120 void SimpleRemoteEPCServer::handleDisconnect(Error Err) { 121 PendingJITDispatchResultsMap TmpPending; 122 123 { 124 std::lock_guard<std::mutex> Lock(ServerStateMutex); 125 std::swap(TmpPending, PendingJITDispatchResults); 126 RunState = ServerShuttingDown; 127 } 128 129 // Send out-of-band errors to any waiting threads. 130 for (auto &KV : TmpPending) 131 KV.second->set_value( 132 shared::WrapperFunctionResult::createOutOfBandError("disconnecting")); 133 134 // Wait for dispatcher to clear. 135 D->shutdown(); 136 137 // Shut down services. 138 while (!Services.empty()) { 139 ShutdownErr = 140 joinErrors(std::move(ShutdownErr), Services.back()->shutdown()); 141 Services.pop_back(); 142 } 143 144 std::lock_guard<std::mutex> Lock(ServerStateMutex); 145 ShutdownErr = joinErrors(std::move(ShutdownErr), std::move(Err)); 146 RunState = ServerShutDown; 147 ShutdownCV.notify_all(); 148 } 149 150 Error SimpleRemoteEPCServer::sendMessage(SimpleRemoteEPCOpcode OpC, 151 uint64_t SeqNo, ExecutorAddr TagAddr, 152 ArrayRef<char> ArgBytes) { 153 154 LLVM_DEBUG({ 155 dbgs() << "SimpleRemoteEPCServer::sendMessage: opc = "; 156 switch (OpC) { 157 case SimpleRemoteEPCOpcode::Setup: 158 dbgs() << "Setup"; 159 assert(SeqNo == 0 && "Non-zero SeqNo for Setup?"); 160 assert(!TagAddr && "Non-zero TagAddr for Setup?"); 161 break; 162 case SimpleRemoteEPCOpcode::Hangup: 163 dbgs() << "Hangup"; 164 assert(SeqNo == 0 && "Non-zero SeqNo for Hangup?"); 165 assert(!TagAddr && "Non-zero TagAddr for Hangup?"); 166 break; 167 case SimpleRemoteEPCOpcode::Result: 168 dbgs() << "Result"; 169 assert(!TagAddr && "Non-zero TagAddr for Result?"); 170 break; 171 case SimpleRemoteEPCOpcode::CallWrapper: 172 dbgs() << "CallWrapper"; 173 break; 174 } 175 dbgs() << ", seqno = " << SeqNo << ", tag-addr = " << TagAddr 176 << ", arg-buffer = " << formatv("{0:x}", ArgBytes.size()) 177 << " bytes\n"; 178 }); 179 auto Err = T->sendMessage(OpC, SeqNo, TagAddr, ArgBytes); 180 LLVM_DEBUG({ 181 if (Err) 182 dbgs() << " \\--> SimpleRemoteEPC::sendMessage failed\n"; 183 }); 184 return Err; 185 } 186 187 Error SimpleRemoteEPCServer::sendSetupMessage( 188 StringMap<ExecutorAddr> BootstrapSymbols) { 189 190 using namespace SimpleRemoteEPCDefaultBootstrapSymbolNames; 191 192 std::vector<char> SetupPacket; 193 SimpleRemoteEPCExecutorInfo EI; 194 EI.TargetTriple = sys::getProcessTriple(); 195 if (auto PageSize = sys::Process::getPageSize()) 196 EI.PageSize = *PageSize; 197 else 198 return PageSize.takeError(); 199 EI.BootstrapSymbols = std::move(BootstrapSymbols); 200 201 assert(!EI.BootstrapSymbols.count(ExecutorSessionObjectName) && 202 "Dispatch context name should not be set"); 203 assert(!EI.BootstrapSymbols.count(DispatchFnName) && 204 "Dispatch function name should not be set"); 205 EI.BootstrapSymbols[ExecutorSessionObjectName] = ExecutorAddr::fromPtr(this); 206 EI.BootstrapSymbols[DispatchFnName] = ExecutorAddr::fromPtr(jitDispatchEntry); 207 208 using SPSSerialize = 209 shared::SPSArgList<shared::SPSSimpleRemoteEPCExecutorInfo>; 210 auto SetupPacketBytes = 211 shared::WrapperFunctionResult::allocate(SPSSerialize::size(EI)); 212 shared::SPSOutputBuffer OB(SetupPacketBytes.data(), SetupPacketBytes.size()); 213 if (!SPSSerialize::serialize(OB, EI)) 214 return make_error<StringError>("Could not send setup packet", 215 inconvertibleErrorCode()); 216 217 return sendMessage(SimpleRemoteEPCOpcode::Setup, 0, ExecutorAddr(), 218 {SetupPacketBytes.data(), SetupPacketBytes.size()}); 219 } 220 221 Error SimpleRemoteEPCServer::handleResult( 222 uint64_t SeqNo, ExecutorAddr TagAddr, 223 SimpleRemoteEPCArgBytesVector ArgBytes) { 224 std::promise<shared::WrapperFunctionResult> *P = nullptr; 225 { 226 std::lock_guard<std::mutex> Lock(ServerStateMutex); 227 auto I = PendingJITDispatchResults.find(SeqNo); 228 if (I == PendingJITDispatchResults.end()) 229 return make_error<StringError>("No call for sequence number " + 230 Twine(SeqNo), 231 inconvertibleErrorCode()); 232 P = I->second; 233 PendingJITDispatchResults.erase(I); 234 releaseSeqNo(SeqNo); 235 } 236 auto R = shared::WrapperFunctionResult::allocate(ArgBytes.size()); 237 memcpy(R.data(), ArgBytes.data(), ArgBytes.size()); 238 P->set_value(std::move(R)); 239 return Error::success(); 240 } 241 242 void SimpleRemoteEPCServer::handleCallWrapper( 243 uint64_t RemoteSeqNo, ExecutorAddr TagAddr, 244 SimpleRemoteEPCArgBytesVector ArgBytes) { 245 D->dispatch([this, RemoteSeqNo, TagAddr, ArgBytes = std::move(ArgBytes)]() { 246 using WrapperFnTy = 247 shared::CWrapperFunctionResult (*)(const char *, size_t); 248 auto *Fn = TagAddr.toPtr<WrapperFnTy>(); 249 shared::WrapperFunctionResult ResultBytes( 250 Fn(ArgBytes.data(), ArgBytes.size())); 251 if (auto Err = sendMessage(SimpleRemoteEPCOpcode::Result, RemoteSeqNo, 252 ExecutorAddr(), 253 {ResultBytes.data(), ResultBytes.size()})) 254 ReportError(std::move(Err)); 255 }); 256 } 257 258 shared::WrapperFunctionResult 259 SimpleRemoteEPCServer::doJITDispatch(const void *FnTag, const char *ArgData, 260 size_t ArgSize) { 261 uint64_t SeqNo; 262 std::promise<shared::WrapperFunctionResult> ResultP; 263 auto ResultF = ResultP.get_future(); 264 { 265 std::lock_guard<std::mutex> Lock(ServerStateMutex); 266 if (RunState != ServerRunning) 267 return shared::WrapperFunctionResult::createOutOfBandError( 268 "jit_dispatch not available (EPC server shut down)"); 269 270 SeqNo = getNextSeqNo(); 271 assert(!PendingJITDispatchResults.count(SeqNo) && "SeqNo already in use"); 272 PendingJITDispatchResults[SeqNo] = &ResultP; 273 } 274 275 if (auto Err = sendMessage(SimpleRemoteEPCOpcode::CallWrapper, SeqNo, 276 ExecutorAddr::fromPtr(FnTag), {ArgData, ArgSize})) 277 ReportError(std::move(Err)); 278 279 return ResultF.get(); 280 } 281 282 shared::CWrapperFunctionResult 283 SimpleRemoteEPCServer::jitDispatchEntry(void *DispatchCtx, const void *FnTag, 284 const char *ArgData, size_t ArgSize) { 285 return reinterpret_cast<SimpleRemoteEPCServer *>(DispatchCtx) 286 ->doJITDispatch(FnTag, ArgData, ArgSize) 287 .release(); 288 } 289 290 } // end namespace orc 291 } // end namespace llvm 292