Changeset 5915


Ignore:
Timestamp:
Mar 18, 2018, 9:49:56 PM (13 months ago)
Author:
cameron
Message:

ORCJIT for LLVM 3.9/4.0 initial check-in

Location:
icGREP/icgrep-devel/icgrep
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/editd/editd.cpp

    r5872 r5915  
    223223
    224224std::mutex store_mutex;
    225 void wrapped_report_pos(size_t match_pos, int dist) {
     225extern "C" void wrapped_report_pos(size_t match_pos, int dist) {
    226226    struct matchPosition curMatch;
    227227    curMatch.pos = match_pos;
  • icGREP/icgrep-devel/icgrep/kernels/linebreak_kernel.cpp

    r5872 r5915  
    5252,Binding{b->getStreamSetTy(1), "lf", FixedRate(), LookAhead(1)}},
    5353// outputs
    54 {Binding{b->getStreamSetTy(1), "linebreak", FixedRate(), Add1()}
     54{Binding{b->getStreamSetTy(1), "linebreak", FixedRate()}
    5555,Binding{b->getStreamSetTy(1), "cr+lf"}}) {
    5656
  • icGREP/icgrep-devel/icgrep/kernels/source_kernel.cpp

    r5883 r5915  
    1313using namespace llvm;
    1414
    15 uint64_t file_size(const uint32_t fd) {
     15extern "C" uint64_t file_size(const uint32_t fd) {
    1616    struct stat st;
    1717    if (LLVM_UNLIKELY(fstat(fd, &st) != 0)) {
  • icGREP/icgrep-devel/icgrep/toolchain/cpudriver.cpp

    r5913 r5915  
    44#include <toolchain/toolchain.h>
    55#include <llvm/Support/DynamicLibrary.h>           // for LoadLibraryPermanently
    6 #include <llvm/ExecutionEngine/RuntimeDyld.h>
     6#include <llvm/ExecutionEngine/ExecutionEngine.h>  // for EngineBuilder
    77#include <llvm/ExecutionEngine/RTDyldMemoryManager.h>
    8 #include <llvm/ExecutionEngine/ExecutionEngine.h>  // for EngineBuilder
     8
    99#include <llvm/IR/LegacyPassManager.h>             // for PassManager
    1010#include <llvm/IR/IRPrintingPasses.h>
    11 #include <llvm/InitializePasses.h>                 // for initializeCodeGen
     11#include <llvm/InitializePasses.h>                 // for initializeCodeGencd .
    1212#include <llvm/PassRegistry.h>                     // for PassRegistry
    1313#include <llvm/Support/CodeGen.h>                  // for Level, Level::None
     
    2727#include <kernels/kernel.h>
    2828#include <llvm/IR/Verifier.h>
     29#ifdef ORCJIT
     30#include "llvm/IR/Mangler.h"
     31#if LLVM_VERSION_INTEGER < LLVM_VERSION_CODE(4, 0, 0)
     32#include <llvm/ExecutionEngine/Orc/JITSymbol.h>
     33#else
     34#include <llvm/ExecutionEngine/JITSymbol.h>
     35#endif
     36#include <llvm/ExecutionEngine/RuntimeDyld.h>
     37#include <llvm/ExecutionEngine/SectionMemoryManager.h>
     38#include <llvm/ExecutionEngine/Orc/CompileUtils.h>
     39#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
     40#include <llvm/ExecutionEngine/Orc/IRTransformLayer.h>
     41#include <llvm/ExecutionEngine/Orc/LambdaResolver.h>
     42#include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
     43#include <llvm/ExecutionEngine/Orc/GlobalMappingLayer.h>
     44#endif
    2945
    3046#ifndef NDEBUG
     
    4258: Driver(std::move(moduleName))
    4359, mTarget(nullptr)
     60#ifndef ORCJIT
    4461, mEngine(nullptr)
     62#endif
    4563, mCache(nullptr)
    4664, mIROutputStream(nullptr)
     
    5371
    5472    preparePassManager();
    55 
     73   
     74
     75#ifdef ORCJIT
     76    EngineBuilder builder;
     77#else
    5678    std::string errMessage;
    5779    EngineBuilder builder{std::unique_ptr<Module>(mMainModule)};
    5880    builder.setErrorStr(&errMessage);
    5981    builder.setUseOrcMCJITReplacement(true);
     82    builder.setVerifyModules(false);
     83    builder.setEngineKind(EngineKind::JIT);
     84#endif
    6085    builder.setTargetOptions(codegen::Options);
    61     builder.setVerifyModules(false);
    6286    builder.setOptLevel(codegen::OptLevel);
    6387
     
    7296    }
    7397
     98    mTarget = builder.selectTarget();
     99   
     100    if (mTarget == nullptr) {
     101        throw std::runtime_error("Could not selectTarget");
     102    }
     103   
     104#ifdef ORCJIT
     105    mCompileLayer = make_unique<CompileLayerT>(mObjectLayer, orc::SimpleCompiler(*mTarget));
     106    /*
     107    mOptimizeLayer = make_unique<OptimizeLayerT>
     108                        (mCompileLayer,
     109                         [this](std::unique_ptr<Module> M) {mPassManager.run(M.get()); return M;});
     110     */
     111#else
    74112    mEngine = builder.create();
    75113    if (mEngine == nullptr) {
    76114        throw std::runtime_error("Could not create ExecutionEngine: " + errMessage);
    77115    }
    78     mTarget = builder.selectTarget();   
     116#endif
    79117    if (LLVM_LIKELY(codegen::EnableObjectCache)) {
    80118        if (codegen::ObjectCacheDir) {
     
    83121            mCache = new ParabixObjectCache();
    84122        }
     123#ifdef ORCJIT
     124        mCompileLayer->setObjectCache(mCache);
     125#else
    85126        mEngine->setObjectCache(mCache);
    86     }
    87     mMainModule->setTargetTriple(mTarget->getTargetTriple().getTriple());
     127#endif
     128    }
     129    auto triple = mTarget->getTargetTriple().getTriple();
     130    const DataLayout DL(mTarget->createDataLayout());
     131    mMainModule->setTargetTriple(triple);
     132    mMainModule->setDataLayout(DL);
    88133    iBuilder.reset(IDISA::GetIDISA_Builder(*mContext));
    89134    iBuilder->setDriver(this);
     
    92137
    93138void ParabixDriver::makeKernelCall(Kernel * kernel, const std::vector<StreamSetBuffer *> & inputs, const std::vector<StreamSetBuffer *> & outputs) {
    94     assert ("makeKernelCall was already run on this kernel." && (kernel->getModule() == nullptr));
     139    assert ("addKernelCall or makeKernelCall was already run on this kernel." && (kernel->getModule() == nullptr));
    95140    mPipeline.emplace_back(kernel);
    96141    kernel->bindPorts(inputs, outputs);
     
    130175}
    131176
     177#if 0 //def ORCJIT
     178OptimizeLayerT::ModuleSetHandleT ParabixDriver::addModule(std::unique_ptr<Module> M) {
     179    // Build our symbol resolver:
     180    // Lambda 1: Look back into the JIT itself to find symbols that are part of
     181    //           the same "logical dylib".
     182    // Lambda 2: Search for external symbols in the host process.
     183    auto Resolver = orc::createLambdaResolver(
     184                                         [&](const std::string &Name) {
     185                                             if (auto Sym = mOptimizeLayer->findSymbol(Name, false))
     186                                                 return Sym;
     187                                             return orc::JITSymbol(nullptr);
     188                                         },
     189                                         [](const std::string &Name) {
     190                                             if (auto SymAddr =
     191                                                 RTDyldMemoryManager::getSymbolAddressInProcess(Name))
     192                                                 return orc::JITSymbol(SymAddr, JITSymbolFlags::Exported);
     193                                             return orc::JITSymbol(nullptr);
     194                                         });
     195   
     196    // Build a singleton module set to hold our module.
     197    std::vector<std::unique_ptr<Module>> Ms;
     198    Ms.push_back(std::move(M));
     199   
     200    // Add the set to the JIT with the resolver we created above and a newly
     201    // created SectionMemoryManager.
     202    return mOptimizeLayer->addModuleSet(std::move(Ms),
     203                                      make_unique<SectionMemoryManager>(),
     204                                      std::move(Resolver));
     205}
     206#endif
     207
     208
    132209Function * ParabixDriver::addLinkFunction(Module * mod, llvm::StringRef name, FunctionType * type, void * functionPtr) const {
    133210    if (LLVM_UNLIKELY(mod == nullptr)) {
     
    137214    if (LLVM_UNLIKELY(f == nullptr)) {
    138215        f = Function::Create(type, Function::ExternalLinkage, name, mod);
     216#ifdef ORCJIT
     217        mCompileLayer->setObjectCache(mCache);
     218#else
    139219        mEngine->updateGlobalMapping(f, functionPtr);
     220#endif
    140221    } else if (LLVM_UNLIKELY(f->getType() != type->getPointerTo())) {
    141222        report_fatal_error("Cannot link " + name + ": a function with a different signature already exists with that name in " + mod->getName());
     
    143224    return f;
    144225}
     226
    145227
    146228void ParabixDriver::preparePassManager() {
     
    199281}
    200282
    201 
    202283void ParabixDriver::finalizeObject() {
    203 
     284#ifdef ORCJIT
     285    std::vector<std::unique_ptr<Module>> moduleSet;
     286    auto Resolver = llvm::orc::createLambdaResolver(
     287            [&](const std::string &Name) {
     288                                                        if (auto Sym = mCompileLayer->findSymbol(Name, false)) {
     289#if LLVM_VERSION_INTEGER <= LLVM_VERSION_CODE(3, 9, 1)
     290                                                            return Sym.toRuntimeDyldSymbol();
     291#else
     292                                                            return Sym;
     293#endif
     294                                                        }
     295#if LLVM_VERSION_INTEGER <= LLVM_VERSION_CODE(3, 9, 1)
     296                                                        return RuntimeDyld::SymbolInfo(nullptr);
     297#else
     298                                                        return JITSymbol(nullptr);
     299#endif
     300                                                    },
     301                                                    [](const std::string &Name) {
     302                                                        if (auto SymAddr =
     303                                                            RTDyldMemoryManager::getSymbolAddressInProcess(Name)) {
     304#if LLVM_VERSION_INTEGER <= LLVM_VERSION_CODE(3, 9, 1)
     305                                                            return RuntimeDyld::SymbolInfo(SymAddr, JITSymbolFlags::Exported);
     306#else
     307                                                            return JITSymbol(SymAddr, JITSymbolFlags::Exported);
     308#endif
     309                                                        }
     310#if LLVM_VERSION_INTEGER <= LLVM_VERSION_CODE(3, 9, 1)
     311                                                        return RuntimeDyld::SymbolInfo(nullptr);
     312#else
     313                                                        return JITSymbol(nullptr);
     314#endif                                                       
     315                                                    });
     316#endif
     317   
    204318    Module * module = nullptr;
    205319    try {
     
    209323            module = kernel->getModule(); assert (module);
    210324            module->setTargetTriple(mMainModule->getTargetTriple());
     325#ifndef ORCJIT
    211326            mPassManager.run(*module);
     327#endif
    212328        }
    213329        module = mMainModule;
    214330        iBuilder->setKernel(nullptr);
    215         mPassManager.run(*mMainModule);
     331        //mPassManager.run(*mMainModule);
    216332        for (Kernel * const kernel : mPipeline) {
    217333            if (LLVM_UNLIKELY(kernel->getModule() == nullptr)) {
    218334                report_fatal_error(kernel->getName() + " was neither loaded from cache nor generated prior to finalizeObject");
    219335            }
     336#ifndef ORCJIT
    220337            mEngine->addModule(std::unique_ptr<Module>(kernel->getModule()));
    221         }
    222         mEngine->finalizeObject();
     338#else
     339            moduleSet.push_back(std::unique_ptr<Module>(kernel->getModule()));
     340#endif
     341        }
     342#ifndef ORCJIT
     343            mEngine->finalizeObject();
     344#else
     345            moduleSet.push_back(std::unique_ptr<Module>(mMainModule));
     346            auto handle = mCompileLayer->addModuleSet(std::move(moduleSet), make_unique<SectionMemoryManager>(), std::move(Resolver));
     347#endif
    223348    } catch (const std::exception & e) {
    224349        report_fatal_error(module->getName() + ": " + e.what());
     
    232357
    233358void * ParabixDriver::getMain() {
     359#ifndef ORCJIT
    234360    return mEngine->getPointerToNamedFunction("Main");
     361#else
     362    std::string MangledName;
     363    raw_string_ostream MangledNameStream(MangledName);
     364    llvm::Mangler::getNameWithPrefix(MangledNameStream, "Main", mTarget->createDataLayout());
     365    //errs() << "Mangled main: " << MangledNameStream.str() << "\n";
     366    auto MainSym = mCompileLayer->findSymbol(MangledNameStream.str(), false);
     367   
     368    assert (MainSym && "Main not found");
     369   
     370    intptr_t main = (intptr_t) MainSym.getAddress();
     371    return (void *) main;
     372#endif
    235373}
    236374
     
    240378
    241379ParabixDriver::~ParabixDriver() {
     380#ifndef ORCJIT
    242381    delete mEngine;
     382#endif
    243383    delete mCache;
    244384    delete mTarget;
    245385    delete mIROutputStream;
    246386    delete mASMOutputStream;
    247 }
     387 }
  • icGREP/icgrep-devel/icgrep/toolchain/cpudriver.h

    r5913 r5915  
    22#define CPUDRIVER_H
    33#include "driver.h"
    4 #include <llvm/IR/LegacyPassManager.h>             // for PassManager
    5 
     4#include <toolchain/toolchain.h>
    65namespace llvm { class ExecutionEngine; }
    76namespace llvm { class TargetMachine; }
    87namespace llvm { class raw_fd_ostream; }
     8
     9#include <llvm/IR/LegacyPassManager.h>
     10#if LLVM_VERSION_INTEGER >= LLVM_VERSION_CODE(3, 9, 0)
     11#define ORCJIT
     12#endif
     13#ifdef ORCJIT
     14#include <llvm/ExecutionEngine/Orc/CompileUtils.h>
     15#include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
     16#include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
     17#include <llvm/ExecutionEngine/Orc/IRTransformLayer.h>
     18typedef llvm::orc::IRCompileLayer<llvm::orc::ObjectLinkingLayer<>> CompileLayerT;
     19using OptimizeFnT = std::function<std::unique_ptr<llvm::Module>(std::unique_ptr<llvm::Module>)>;
     20typedef llvm::orc::IRTransformLayer<CompileLayerT, OptimizeFnT> OptimizeLayerT;
     21
     22#endif
    923
    1024class ParabixObjectCache;
     
    3448    llvm::Function * addLinkFunction(llvm::Module * mod, llvm::StringRef name, llvm::FunctionType * type, void * functionPtr) const override;
    3549
    36 private:
    3750    llvm::TargetMachine *                                   mTarget;
    3851    llvm::legacy::PassManager                               mPassManager;
     52
     53#ifdef ORCJIT
     54    llvm::orc::ObjectLinkingLayer<>  mObjectLayer;
     55    std::unique_ptr<CompileLayerT> mCompileLayer;
     56   
     57    //std::unique_ptr<OptimizeLayerT> mOptimizeLayer;
     58   
     59    //OptimizeLayerT::ModuleSetHandleT addModule(std::unique_ptr<llvm::Module> M);
     60
     61#else
    3962    llvm::ExecutionEngine *                                 mEngine;
     63#endif
    4064    ParabixObjectCache *                                    mCache;
    4165    std::vector<kernel::Kernel *>                           mUncachedKernel;
Note: See TracChangeset for help on using the changeset viewer.