mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-02-20 12:23:04 +00:00
[ORC][examples] Temporarily remove LLJITWithChildProcess until ORC TPC lands
This solves a phase ordering problem: OrcV2 remote process support depends on OrcV2 removable code, OrcV2 removable code depends on OrcV1 removal, OrcV1 removal depends on LLJITWithChildProcess migration, and LLJITWithChildProcess migration depends on OrcV2 TargetProcessControl support.
This commit is contained in:
Stefan Gränitz
parent
32fd6cdf35
commit
bf37528089
@ -11,7 +11,3 @@ add_subdirectory(LLJITWithThinLTOSummaries)
|
||||
add_subdirectory(OrcV2CBindingsAddObjectFile)
|
||||
add_subdirectory(OrcV2CBindingsBasicUsage)
|
||||
add_subdirectory(OrcV2CBindingsReflectProcessSymbols)
|
||||
|
||||
if(CMAKE_HOST_UNIX)
|
||||
add_subdirectory(LLJITWithChildProcess)
|
||||
endif()
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
set(LLVM_LINK_COMPONENTS
|
||||
Core
|
||||
ExecutionEngine
|
||||
IRReader
|
||||
JITLink
|
||||
OrcError
|
||||
OrcJIT
|
||||
Support
|
||||
nativecodegen
|
||||
)
|
||||
|
||||
add_llvm_example(LLJITInChildProcess
|
||||
LLJITWithChildProcess.cpp
|
||||
)
|
||||
@ -1,128 +0,0 @@
|
||||
//===--- LLJITWithChildProcess.cpp - LLJIT targeting a child process ------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// In this example we will execute JITed code in a child process:
|
||||
//
|
||||
// 1. Launch a remote process.
|
||||
// 2. Create a JITLink-compatible remote memory manager.
|
||||
// 3. Use LLJITBuilder to create a (greedy) LLJIT instance.
|
||||
// 4. Add the Add1Example module and execute add1().
|
||||
// 5. Terminate the remote target session.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
|
||||
#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
|
||||
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
|
||||
#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
|
||||
#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include "llvm/Support/InitLLVM.h"
|
||||
#include "llvm/Support/TargetSelect.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
|
||||
#include "../ExampleModules.h"
|
||||
#include "RemoteJITUtils.h"
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#define DEBUG_TYPE "orc"
|
||||
|
||||
using namespace llvm;
|
||||
using namespace llvm::orc;
|
||||
|
||||
// Executable running in the child process for remote execution. It communicates
|
||||
// via stdin/stdout pipes.
|
||||
cl::opt<std::string>
|
||||
ChildExecPath("remote-process", cl::Required,
|
||||
cl::desc("Specify the filename of the process to launch for "
|
||||
"remote JITing."),
|
||||
cl::value_desc("filename"));
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
InitLLVM X(argc, argv);
|
||||
|
||||
InitializeNativeTarget();
|
||||
InitializeNativeTargetAsmPrinter();
|
||||
|
||||
cl::ParseCommandLineOptions(argc, argv, "LLJITWithChildProcess");
|
||||
|
||||
ExitOnError ExitOnErr;
|
||||
ExitOnErr.setBanner(std::string(argv[0]) + ": ");
|
||||
|
||||
if (!sys::fs::can_execute(ChildExecPath)) {
|
||||
WithColor::error(errs(), argv[0])
|
||||
<< "Child executable invalid: '" << ChildExecPath << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
ExecutionSession ES;
|
||||
ES.setErrorReporter([&](Error Err) { ExitOnErr(std::move(Err)); });
|
||||
|
||||
// Launch the remote process and get a channel to it.
|
||||
pid_t ChildPID;
|
||||
std::unique_ptr<FDRawChannel> Ch = launchRemote(ChildExecPath, ChildPID);
|
||||
if (!Ch) {
|
||||
WithColor::error(errs(), argv[0]) << "Failed to launch remote JIT.\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
LLVM_DEBUG({
|
||||
dbgs()
|
||||
<< "Launched executable in subprocess " << ChildPID << ":\n"
|
||||
<< ChildExecPath << "\n\n"
|
||||
<< "You may want to attach a debugger now. Press enter to continue.\n";
|
||||
fflush(stdin);
|
||||
getchar();
|
||||
});
|
||||
|
||||
std::unique_ptr<remote::OrcRemoteTargetClient> Client =
|
||||
ExitOnErr(remote::OrcRemoteTargetClient::Create(*Ch, ES));
|
||||
|
||||
// Create a JITLink-compatible remote memory manager.
|
||||
using MemManager = remote::OrcRemoteTargetClient::RemoteJITLinkMemoryManager;
|
||||
std::unique_ptr<MemManager> RemoteMM =
|
||||
ExitOnErr(Client->createRemoteJITLinkMemoryManager());
|
||||
|
||||
// Our remote target is running on the host system.
|
||||
auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost());
|
||||
JTMB.setCodeModel(CodeModel::Small);
|
||||
|
||||
// Create an LLJIT instance with a JITLink ObjectLinkingLayer.
|
||||
auto J = ExitOnErr(
|
||||
LLJITBuilder()
|
||||
.setJITTargetMachineBuilder(std::move(JTMB))
|
||||
.setObjectLinkingLayerCreator(
|
||||
[&](ExecutionSession &ES,
|
||||
const Triple &TT) -> std::unique_ptr<ObjectLayer> {
|
||||
return std::make_unique<ObjectLinkingLayer>(ES, *RemoteMM);
|
||||
})
|
||||
.create());
|
||||
|
||||
auto M = ExitOnErr(parseExampleModule(Add1Example, "add1"));
|
||||
|
||||
ExitOnErr(J->addIRModule(std::move(M)));
|
||||
|
||||
// Look up the JIT'd function.
|
||||
auto Add1Sym = ExitOnErr(J->lookup("add1"));
|
||||
|
||||
// Run in child target.
|
||||
Expected<int> Result = Client->callIntInt(Add1Sym.getAddress(), 42);
|
||||
if (Result)
|
||||
outs() << "add1(42) = " << *Result << "\n";
|
||||
else
|
||||
ES.reportError(Result.takeError());
|
||||
|
||||
// Signal the remote target that we're done JITing.
|
||||
ExitOnErr(Client->terminateSession());
|
||||
LLVM_DEBUG(dbgs() << "Subprocess terminated\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,121 +0,0 @@
|
||||
//===-- RemoteJITUtils.h - Utilities for remote-JITing ----------*- C++ -*-===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Utilities for remote-JITing
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_EXAMPLES_ORCV2EXAMPLES_LLJITWITHCHILDPROCESS_REMOTEJITUTILS_H
|
||||
#define LLVM_EXAMPLES_ORCV2EXAMPLES_LLJITWITHCHILDPROCESS_REMOTEJITUTILS_H
|
||||
|
||||
#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
|
||||
#include <mutex>
|
||||
|
||||
#if !defined(_MSC_VER) && !defined(__MINGW32__)
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
/// RPC channel that reads from and writes from file descriptors.
|
||||
class FDRawChannel final : public llvm::orc::rpc::RawByteChannel {
|
||||
public:
|
||||
FDRawChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
|
||||
|
||||
llvm::Error readBytes(char *Dst, unsigned Size) override {
|
||||
assert(Dst && "Attempt to read into null.");
|
||||
ssize_t Completed = 0;
|
||||
while (Completed < static_cast<ssize_t>(Size)) {
|
||||
ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
|
||||
if (Read <= 0) {
|
||||
auto ErrNo = errno;
|
||||
if (ErrNo == EAGAIN || ErrNo == EINTR)
|
||||
continue;
|
||||
else
|
||||
return llvm::errorCodeToError(
|
||||
std::error_code(errno, std::generic_category()));
|
||||
}
|
||||
Completed += Read;
|
||||
}
|
||||
return llvm::Error::success();
|
||||
}
|
||||
|
||||
llvm::Error appendBytes(const char *Src, unsigned Size) override {
|
||||
assert(Src && "Attempt to append from null.");
|
||||
ssize_t Completed = 0;
|
||||
while (Completed < static_cast<ssize_t>(Size)) {
|
||||
ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
|
||||
if (Written < 0) {
|
||||
auto ErrNo = errno;
|
||||
if (ErrNo == EAGAIN || ErrNo == EINTR)
|
||||
continue;
|
||||
else
|
||||
return llvm::errorCodeToError(
|
||||
std::error_code(errno, std::generic_category()));
|
||||
}
|
||||
Completed += Written;
|
||||
}
|
||||
return llvm::Error::success();
|
||||
}
|
||||
|
||||
llvm::Error send() override { return llvm::Error::success(); }
|
||||
|
||||
private:
|
||||
int InFD, OutFD;
|
||||
};
|
||||
|
||||
// Launch child process and return a channel to it.
|
||||
std::unique_ptr<FDRawChannel> launchRemote(std::string ExecPath,
|
||||
pid_t &ChildPID) {
|
||||
// Create two pipes.
|
||||
int PipeFD[2][2];
|
||||
if (pipe(PipeFD[0]) != 0 || pipe(PipeFD[1]) != 0)
|
||||
perror("Error creating pipe: ");
|
||||
|
||||
ChildPID = fork();
|
||||
|
||||
if (ChildPID == 0) {
|
||||
// In the child...
|
||||
|
||||
// Close the parent ends of the pipes
|
||||
close(PipeFD[0][1]);
|
||||
close(PipeFD[1][0]);
|
||||
|
||||
// Execute the child process.
|
||||
std::unique_ptr<char[]> ChildPath, ChildIn, ChildOut;
|
||||
{
|
||||
ChildPath.reset(new char[ExecPath.size() + 1]);
|
||||
std::copy(ExecPath.begin(), ExecPath.end(), &ChildPath[0]);
|
||||
ChildPath[ExecPath.size()] = '\0';
|
||||
std::string ChildInStr = llvm::utostr(PipeFD[0][0]);
|
||||
ChildIn.reset(new char[ChildInStr.size() + 1]);
|
||||
std::copy(ChildInStr.begin(), ChildInStr.end(), &ChildIn[0]);
|
||||
ChildIn[ChildInStr.size()] = '\0';
|
||||
std::string ChildOutStr = llvm::utostr(PipeFD[1][1]);
|
||||
ChildOut.reset(new char[ChildOutStr.size() + 1]);
|
||||
std::copy(ChildOutStr.begin(), ChildOutStr.end(), &ChildOut[0]);
|
||||
ChildOut[ChildOutStr.size()] = '\0';
|
||||
}
|
||||
|
||||
char *const args[] = {&ChildPath[0], &ChildIn[0], &ChildOut[0], nullptr};
|
||||
int rc = execv(ExecPath.c_str(), args);
|
||||
if (rc != 0)
|
||||
perror("Error executing child process: ");
|
||||
llvm_unreachable("Error executing child process");
|
||||
}
|
||||
// else we're the parent...
|
||||
|
||||
// Close the child ends of the pipes
|
||||
close(PipeFD[0][0]);
|
||||
close(PipeFD[1][1]);
|
||||
|
||||
// Return an RPC channel connected to our end of the pipes.
|
||||
return std::make_unique<FDRawChannel>(PipeFD[1][0], PipeFD[0][1]);
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
x
Reference in New Issue
Block a user