diff options
Diffstat (limited to 'llvm/docs/tutorial/BuildingAJIT3.rst')
| -rw-r--r-- | llvm/docs/tutorial/BuildingAJIT3.rst | 33 |
1 files changed, 17 insertions, 16 deletions
diff --git a/llvm/docs/tutorial/BuildingAJIT3.rst b/llvm/docs/tutorial/BuildingAJIT3.rst index 071e92c7454..9c4e59fe117 100644 --- a/llvm/docs/tutorial/BuildingAJIT3.rst +++ b/llvm/docs/tutorial/BuildingAJIT3.rst @@ -21,7 +21,7 @@ Lazy Compilation When we add a module to the KaleidoscopeJIT class from Chapter 2 it is immediately optimized, compiled and linked for us by the IRTransformLayer, -IRCompileLayer and ObjectLinkingLayer respectively. This scheme, where all the +IRCompileLayer and RTDyldObjectLinkingLayer respectively. This scheme, where all the work to make a Module executable is done up front, is simple to understand and its performance characteristics are easy to reason about. However, it will lead to very high startup times if the amount of code to be compiled is large, and @@ -33,7 +33,7 @@ the ORC APIs provide us with a layer to lazily compile LLVM IR: *CompileOnDemandLayer*. The CompileOnDemandLayer class conforms to the layer interface described in -Chapter 2, but its addModuleSet method behaves quite differently from the layers +Chapter 2, but its addModule method behaves quite differently from the layers we have seen so far: rather than doing any work up front, it just scans the Modules being added and arranges for each function in them to be compiled the first time it is called. To do this, the CompileOnDemandLayer creates two small @@ -73,21 +73,22 @@ lazy compilation. We just need a few changes to the source: private: std::unique_ptr<TargetMachine> TM; const DataLayout DL; - std::unique_ptr<JITCompileCallbackManager> CompileCallbackManager; - ObjectLinkingLayer<> ObjectLayer; - IRCompileLayer<decltype(ObjectLayer)> CompileLayer; + RTDyldObjectLinkingLayer ObjectLayer; + IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer; - typedef std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)> - OptimizeFunction; + using OptimizeFunction = + std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>; IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer; + + std::unique_ptr<JITCompileCallbackManager> CompileCallbackManager; CompileOnDemandLayer<decltype(OptimizeLayer)> CODLayer; public: - typedef decltype(CODLayer)::ModuleSetHandleT ModuleHandle; + using ModuleHandle = decltype(CODLayer)::ModuleHandleT; First we need to include the CompileOnDemandLayer.h header, then add two new -members: a std::unique_ptr<CompileCallbackManager> and a CompileOnDemandLayer, +members: a std::unique_ptr<JITCompileCallbackManager> and a CompileOnDemandLayer, to our class. The CompileCallbackManager member is used by the CompileOnDemandLayer to create the compile callback needed for each function. @@ -95,9 +96,10 @@ to create the compile callback needed for each function. KaleidoscopeJIT() : TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()), + ObjectLayer([]() { return std::make_shared<SectionMemoryManager>(); }), CompileLayer(ObjectLayer, SimpleCompiler(*TM)), OptimizeLayer(CompileLayer, - [this](std::unique_ptr<Module> M) { + [this](std::shared_ptr<Module> M) { return optimizeModule(std::move(M)); }), CompileCallbackManager( @@ -133,7 +135,7 @@ our CompileCallbackManager. Finally, we need to supply an "indirect stubs manager builder": a utility function that constructs IndirectStubManagers, which are in turn used to build the stubs for the functions in each module. The CompileOnDemandLayer will call the indirect stub manager builder once for each -call to addModuleSet, and use the resulting indirect stubs manager to create +call to addModule, and use the resulting indirect stubs manager to create stubs for all functions in all modules in the set. If/when the module set is removed from the JIT the indirect stubs manager will be deleted, freeing any memory allocated to the stubs. We supply this function by using the @@ -144,9 +146,8 @@ createLocalIndirectStubsManagerBuilder utility. // ... if (auto Sym = CODLayer.findSymbol(Name, false)) // ... - return CODLayer.addModuleSet(std::move(Ms), - make_unique<SectionMemoryManager>(), - std::move(Resolver)); + return cantFail(CODLayer.addModule(std::move(Ms), + std::move(Resolver))); // ... // ... @@ -154,7 +155,7 @@ createLocalIndirectStubsManagerBuilder utility. // ... // ... - CODLayer.removeModuleSet(H); + CODLayer.removeModule(H); // ... Finally, we need to replace the references to OptimizeLayer in our addModule, @@ -173,7 +174,7 @@ layer added to enable lazy function-at-a-time compilation. To build this example .. code-block:: bash # Compile - clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core orc native` -O3 -o toy + clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core orcjit native` -O3 -o toy # Run ./toy |
