Speculative Compilation (f5c40cb9) · Commits · llvm-doe / llvm-project

llvm/examples/CMakeLists.txt

+1 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@ add_subdirectory(HowToUseLLJIT)
		add_subdirectory(LLJITExamples)
		add_subdirectory(Kaleidoscope)
		add_subdirectory(ModuleMaker)
		add_subdirectory(SpeculativeJIT)

		if(LLVM_ENABLE_EH AND (NOT WIN32) AND (NOT "${LLVM_NATIVE_ARCH}" STREQUAL "ARM"))
		add_subdirectory(ExceptionDemo)

llvm/examples/SpeculativeJIT/CMakeLists.txt

0 → 100644

+14 −0

Original line number	Diff line number	Diff line
		set(LLVM_LINK_COMPONENTS
		Core
		IRReader
		OrcJIT
		ExecutionEngine
		Support
		nativecodegen
		Analysis
		Passes
		)

		add_llvm_example(SpeculativeJIT
		SpeculativeJIT.cpp
		)

llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp

0 → 100644

+197 −0

Original line number	Diff line number	Diff line
		#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
		#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
		#include "llvm/ExecutionEngine/Orc/Core.h"
		#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
		#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
		#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
		#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
		#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
		#include "llvm/ExecutionEngine/Orc/SpeculateAnalyses.h"
		#include "llvm/ExecutionEngine/Orc/Speculation.h"
		#include "llvm/ExecutionEngine/SectionMemoryManager.h"
		#include "llvm/IRReader/IRReader.h"
		#include "llvm/Support/CommandLine.h"
		#include "llvm/Support/Debug.h"
		#include "llvm/Support/InitLLVM.h"
		#include "llvm/Support/SourceMgr.h"
		#include "llvm/Support/TargetSelect.h"
		#include "llvm/Support/ThreadPool.h"

		#include <list>
		#include <string>

		using namespace llvm;
		using namespace llvm::orc;

		static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
		cl::desc("input files"));

		static cl::list<std::string> InputArgv("args", cl::Positional,
		cl::desc("<program arguments>..."),
		cl::ZeroOrMore, cl::PositionalEatsArgs);

		static cl::opt<unsigned> NumThreads("num-threads", cl::Optional,
		cl::desc("Number of compile threads"),
		cl::init(4));

		ExitOnError ExitOnErr;

		// Add Layers
		class SpeculativeJIT {
		public:
		static Expected<std::unique_ptr<SpeculativeJIT>> Create() {
		auto JTMB = orc::JITTargetMachineBuilder::detectHost();
		if (!JTMB)
		return JTMB.takeError();

		auto DL = JTMB->getDefaultDataLayoutForTarget();
		if (!DL)
		return DL.takeError();

		auto ES = llvm::make_unique<ExecutionSession>();

		auto LCTMgr = createLocalLazyCallThroughManager(
		JTMB->getTargetTriple(), *ES,
		pointerToJITTargetAddress(explodeOnLazyCompileFailure));
		if (!LCTMgr)
		return LCTMgr.takeError();

		auto ISMBuilder =
		createLocalIndirectStubsManagerBuilder(JTMB->getTargetTriple());
		if (!ISMBuilder)
		return make_error<StringError>("No indirect stubs manager for target",
		inconvertibleErrorCode());

		auto ProcessSymbolsSearchGenerator =
		DynamicLibrarySearchGenerator::GetForCurrentProcess(
		DL->getGlobalPrefix());
		if (!ProcessSymbolsSearchGenerator)
		return ProcessSymbolsSearchGenerator.takeError();

		std::unique_ptr<SpeculativeJIT> SJ(new SpeculativeJIT(
		std::move(ES), std::move(DL), std::move(JTMB), std::move(*LCTMgr),
		std::move(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
		return std::move(SJ);
		}

		ExecutionSession &getES() { return *ES; }

		Error addModule(JITDylib &JD, ThreadSafeModule TSM) {
		return CODLayer.add(JD, std::move(TSM));
		}

		Expected<JITEvaluatedSymbol> lookup(StringRef UnmangledName) {
		return ES->lookup({&ES->getMainJITDylib()}, Mangle(UnmangledName));
		}

		~SpeculativeJIT() { CompileThreads.wait(); }

		private:
		using IndirectStubsManagerBuilderFunction =
		std::function<std::unique_ptr<IndirectStubsManager>()>;

		static void explodeOnLazyCompileFailure() {
		errs() << "Lazy compilation failed, Symbol Implmentation not found!\n";
		exit(1);
		}

		SpeculativeJIT(std::unique_ptr<ExecutionSession> ES, DataLayout DL,
		orc::JITTargetMachineBuilder JTMB,
		std::unique_ptr<LazyCallThroughManager> LCTMgr,
		IndirectStubsManagerBuilderFunction ISMBuilder,
		DynamicLibrarySearchGenerator ProcessSymbolsGenerator)
		: ES(std::move(ES)), DL(std::move(DL)), LCTMgr(std::move(LCTMgr)),
		CompileLayer(*this->ES, ObjLayer,
		ConcurrentIRCompiler(std::move(JTMB))),
		S(Imps, *this->ES),
		SpeculateLayer(*this->ES, CompileLayer, S, BlockFreqQuery()),
		CODLayer(this->ES, SpeculateLayer, this->LCTMgr,
		std::move(ISMBuilder)) {
		this->ES->getMainJITDylib().setGenerator(
		std::move(ProcessSymbolsGenerator));
		this->CODLayer.setImplMap(&Imps);
		this->ES->setDispatchMaterialization(

		[this](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
		// FIXME: Switch to move capture once we have c 14.
		auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
		auto Work = [SharedMU, &JD]() { SharedMU->doMaterialize(JD); };
		CompileThreads.async(std::move(Work));
		});
		JITEvaluatedSymbol SpeculatorSymbol(JITTargetAddress(&S),
		JITSymbolFlags::Exported);
		ExitOnErr(this->ES->getMainJITDylib().define(
		absoluteSymbols({{Mangle("__orc_speculator"), SpeculatorSymbol}})));
		LocalCXXRuntimeOverrides CXXRuntimeoverrides;
		ExitOnErr(CXXRuntimeoverrides.enable(this->ES->getMainJITDylib(), Mangle));
		}

		static std::unique_ptr<SectionMemoryManager> createMemMgr() {
		return llvm::make_unique<SectionMemoryManager>();
		}

		std::unique_ptr<ExecutionSession> ES;
		DataLayout DL;
		MangleAndInterner Mangle{*ES, DL};
		ThreadPool CompileThreads{NumThreads};

		Triple TT;
		std::unique_ptr<LazyCallThroughManager> LCTMgr;
		IRCompileLayer CompileLayer;
		ImplSymbolMap Imps;
		Speculator S;
		RTDyldObjectLinkingLayer ObjLayer{*ES, createMemMgr};
		IRSpeculationLayer SpeculateLayer;
		CompileOnDemandLayer CODLayer;
		};

		int main(int argc, char *argv[]) {
		// Initialize LLVM.
		InitLLVM X(argc, argv);

		InitializeNativeTarget();
		InitializeNativeTargetAsmPrinter();

		cl::ParseCommandLineOptions(argc, argv, "SpeculativeJIT");
		ExitOnErr.setBanner(std::string(argv[0]) + ": ");

		if (NumThreads < 1) {
		errs() << "Speculative compilation requires one or more dedicated compile "
		"threads\n";
		return 1;
		}

		// Create a JIT instance.
		auto SJ = ExitOnErr(SpeculativeJIT::Create());

		// Load the IR inputs.
		for (const auto &InputFile : InputFiles) {
		SMDiagnostic Err;
		auto Ctx = llvm::make_unique<LLVMContext>();
		auto M = parseIRFile(InputFile, Err, *Ctx);
		if (!M) {
		Err.print(argv[0], errs());
		return 1;
		}

		ExitOnErr(SJ->addModule(SJ->getES().getMainJITDylib(),
		ThreadSafeModule(std::move(M), std::move(Ctx))));
		}

		// Build an argv array for the JIT'd main.
		std::vector<const char *> ArgV;
		ArgV.push_back(argv[0]);
		for (const auto &InputArg : InputArgv)
		ArgV.push_back(InputArg.data());
		ArgV.push_back(nullptr);

		// Look up the JIT'd main, cast it to a function pointer, then call it.

		auto MainSym = ExitOnErr(SJ->lookup("main"));
		int (Main)(int, const char []) =
		(int ()(int, const char []))MainSym.getAddress();

		Main(ArgV.size() - 1, ArgV.data());

		return 0;
		}

llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include "llvm/ExecutionEngine/Orc/LazyReexports.h"
		#include "llvm/ExecutionEngine/Orc/Legacy.h"
		#include "llvm/ExecutionEngine/Orc/OrcError.h"
		#include "llvm/ExecutionEngine/Orc/Speculation.h"
		#include "llvm/ExecutionEngine/RuntimeDyld.h"
		#include "llvm/IR/Attributes.h"
		#include "llvm/IR/Constant.h"
		@@ -91,6 +92,8 @@ public:
		/// Sets the partition function.
		void setPartitionFunction(PartitionFunction Partition);

		/// Sets the ImplSymbolMap
		void setImplMap(ImplSymbolMap *Imp);
		/// Emits the given module. This should not be called by clients: it will be
		/// called by the JIT when a definition added via the add method is requested.
		void emit(MaterializationResponsibility R, ThreadSafeModule TSM) override;
		@@ -128,6 +131,7 @@ private:
		PerDylibResourcesMap DylibResources;
		PartitionFunction Partition = compileRequested;
		SymbolLinkagePromoter PromoteSymbols;
		ImplSymbolMap *AliaseeImpls = nullptr;
		};

		/// Compile-on-demand layer.

llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h

+6 −3

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include "llvm/ExecutionEngine/Orc/Core.h"
		#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
		#include "llvm/ExecutionEngine/Orc/Speculation.h"

		namespace llvm {

		@@ -159,7 +160,7 @@ public:
		IndirectStubsManager &ISManager,
		JITDylib &SourceJD,
		SymbolAliasMap CallableAliases,
		VModuleKey K);
		ImplSymbolMap *SrcJDLoc, VModuleKey K);

		StringRef getName() const override;

		@@ -174,6 +175,7 @@ private:
		SymbolAliasMap CallableAliases;
		std::shared_ptr<LazyCallThroughManager::NotifyResolvedFunction>
		NotifyResolved;
		ImplSymbolMap *AliaseeTable;
		};

		/// Define lazy-reexports based on the given SymbolAliasMap. Each lazy re-export
		@@ -182,9 +184,10 @@ private:
		inline std::unique_ptr<LazyReexportsMaterializationUnit>
		lazyReexports(LazyCallThroughManager &LCTManager,
		IndirectStubsManager &ISManager, JITDylib &SourceJD,
		SymbolAliasMap CallableAliases, VModuleKey K = VModuleKey()) {
		SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc = nullptr,
		VModuleKey K = VModuleKey()) {
		return llvm::make_unique<LazyReexportsMaterializationUnit>(
		LCTManager, ISManager, SourceJD, std::move(CallableAliases),
		LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc,
		std::move(K));
		}