Ignore:
Timestamp:
May 16, 2017, 4:13:53 PM (2 years ago)
Author:
nmedfort
Message:

Bug fix check in for DumpTrace?, compilation of DoBlock? / DoFinalBlock? functions. Pablo CodeMotionPass? optimized and enabled by default.

File:
1 edited

Legend:

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

    r5446 r5454  
    2828#include <kernels/kernel.h>
    2929#include <sys/stat.h>
    30 #include <thread>
    31 #include <boost/lockfree/queue.hpp>
    3230#include <llvm/IR/Verifier.h>
     31//#include <toolchain/workqueue.h>
     32
    3333
    3434using namespace llvm;
     
    4949
    5050static cl::bits<DebugFlags>
    51 DebugOptions(cl::values(clEnumVal(ShowIR, "Print generated LLVM IR."),
     51DebugOptions(cl::values(clEnumVal(ShowUnoptimizedIR, "Print generated LLVM IR."),
     52                        clEnumVal(ShowIR, "Print optimized LLVM IR."),
    5253                        clEnumVal(VerifyIR, "Run the IR verification pass."),
    5354#ifndef USE_LLVM_3_6
     
    148149    std::string errMessage;
    149150    EngineBuilder builder{std::unique_ptr<Module>(mMainModule)};
     151    builder.setUseOrcMCJITReplacement(true);
    150152    builder.setErrorStr(&errMessage);
    151153    TargetOptions opts = InitTargetOptionsFromCodeGenFlags();
    152154    opts.MCOptions.AsmVerbose = codegen::AsmVerbose;
    153155    builder.setTargetOptions(opts);
    154     builder.setVerifyModules(IN_DEBUG_MODE || codegen::DebugOptionIsSet(codegen::VerifyIR));
     156    builder.setVerifyModules(false);
    155157    CodeGenOpt::Level optLevel = CodeGenOpt::Level::None;
    156158    switch (codegen::OptLevel) {
     
    174176            mCache = new ParabixObjectCache(codegen::ObjectCacheDir);
    175177        }
    176         assert (mCache);
    177178        mEngine->setObjectCache(mCache);
    178179    }
     
    261262void ParabixDriver::linkAndFinalize() {
    262263
    263 //    using WorkQueue = boost::lockfree::queue<Kernel *>;
    264 
    265264    legacy::PassManager PM;
     265    std::unique_ptr<raw_fd_ostream> IROutputStream(nullptr);
     266    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowUnoptimizedIR))) {
     267        if (codegen::IROutputFilename.empty()) {
     268            IROutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     269        } else {
     270            std::error_code error;
     271            IROutputStream.reset(new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None));
     272        }
     273        PM.add(createPrintModulePass(*IROutputStream));
     274    }
     275
    266276    if (IN_DEBUG_MODE || LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::VerifyIR))) {
    267277        PM.add(createVerifierPass());
     
    272282    PM.add(createInstructionCombiningPass());    //Simple peephole optimizations and bit-twiddling.
    273283    PM.add(createCFGSimplificationPass());
    274 
    275 //    unsigned threadCount = std::thread::hardware_concurrency();
    276 
    277     std::unique_ptr<raw_fd_ostream> IROutputStream(nullptr);
    278284    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowIR))) {
    279 //        threadCount = 1; // If we're dumping IR, disable seperate compilation
    280         if (codegen::IROutputFilename.empty()) {
    281             IROutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
    282         } else {
    283             std::error_code error;
    284             IROutputStream.reset(new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None));
     285        if (LLVM_LIKELY(IROutputStream == nullptr)) {
     286            if (codegen::IROutputFilename.empty()) {
     287                IROutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     288            } else {
     289                std::error_code error;
     290                IROutputStream.reset(new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None));
     291            }
    285292        }
    286293        PM.add(createPrintModulePass(*IROutputStream));
     
    290297    std::unique_ptr<raw_fd_ostream> ASMOutputStream(nullptr);
    291298    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowASM))) {
    292 //        threadCount = 1; // If we're dumping ASM, disable seperate compilation
    293299        if (codegen::ASMOutputFilename.empty()) {
    294300            ASMOutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     
    303309    #endif
    304310
     311    Module * module = nullptr;
     312
    305313    try {
    306314
    307 //    if (threadCount > 1) {
    308 
    309 //        WorkQueue Q(mPipeline.size());
    310 //        for (Kernel * kernel : mPipeline) {
    311 //            Q.unsynchronized_push(kernel); assert (kernel);
    312 //        }
    313 
    314 //        std::thread compilation_thread[threadCount - 1];
    315 //        for (unsigned i = 0; i < (threadCount - 1); ++i) {
    316 //            compilation_thread[i] = std::thread([&]{
    317 
    318 //                llvm::LLVMContext C;
    319 //                std::unique_ptr<KernelBuilder> kb(IDISA::GetIDISA_Builder(C, mMainModule->getTargetTriple()));
    320 //                kb->setDriver(this);
    321 
    322 //                Kernel * kernel = nullptr;
    323 //                while (Q.pop(kernel)) {
    324 //                    kb->setKernel(kernel);
    325 //                    Module * module = kernel->getModule();
    326 //                    bool uncachedObject = true;
    327 //                    if (mCache && mCache->loadCachedObjectFile(kb, kernel)) {
    328 //                        uncachedObject = false;
    329 //                    }
    330 //                    if (uncachedObject) {
    331 //                        module->setTargetTriple(mMainModule->getTargetTriple());
    332 //                        kernel->generateKernel(kb);
    333 //                        // PM.run(*module);
    334 //                        mEngine->generateCodeForModule(module);
    335 //                    }
    336 //                    // mEngine->addModule(std::unique_ptr<Module>(module));
    337 //                }
    338 //            });
    339 //        }
    340 
    341 //        // PM.run(*mMainModule);
    342 
    343 //        Kernel * kernel = nullptr;
    344 //        while (Q.pop(kernel)) {
    345 //            iBuilder->setKernel(kernel);
    346 //            Module * module = kernel->getModule();
    347 //            bool uncachedObject = true;
    348 //            if (mCache && mCache->loadCachedObjectFile(iBuilder, kernel)) {
    349 //                uncachedObject = false;
    350 //            }
    351 //            if (uncachedObject) {
    352 //                module->setTargetTriple(mMainModule->getTargetTriple());
    353 //                kernel->generateKernel(iBuilder);
    354 //                // PM.run(*module);
    355 //            }
    356 //            mEngine->addModule(std::unique_ptr<Module>(module));
    357 //            mEngine->generateCodeForModule(module);
    358 //        }
    359 
    360 //        for (unsigned i = 0; i < (threadCount - 1); ++i) {
    361 //            compilation_thread[i].join();
    362 //        }
    363 
    364 //        iBuilder->setKernel(nullptr);
    365 
    366 //    } else { // single threaded
    367 
    368315        for (Kernel * const kernel : mPipeline) {
    369 
    370316            iBuilder->setKernel(kernel);
    371             Module * module = kernel->getModule();
     317            module = kernel->getModule();
    372318            bool uncachedObject = true;
    373319            if (mCache && mCache->loadCachedObjectFile(iBuilder, kernel)) {
     
    384330
    385331        iBuilder->setKernel(nullptr);
     332        module = mMainModule;
    386333        PM.run(*mMainModule);
    387334
    388 //    }
    389 
    390     mEngine->finalizeObject();
     335        mEngine->finalizeObject();
    391336
    392337    } catch (const std::exception & e) {
     
    396341}
    397342
     343
     344//void ParabixDriver::linkAndFinalize() {
     345
     346//    legacy::PassManager PM;
     347//    if (IN_DEBUG_MODE || LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::VerifyIR))) {
     348//        PM.add(createVerifierPass());
     349//    }
     350//    PM.add(createPromoteMemoryToRegisterPass()); //Force the use of mem2reg to promote stack variables.
     351//    PM.add(createReassociatePass());             //Reassociate expressions.
     352//    PM.add(createGVNPass());                     //Eliminate common subexpressions.
     353//    PM.add(createInstructionCombiningPass());    //Simple peephole optimizations and bit-twiddling.
     354//    PM.add(createCFGSimplificationPass());
     355
     356//    unsigned threadCount = 2; //std::thread::hardware_concurrency();
     357
     358//    std::unique_ptr<raw_fd_ostream> IROutputStream(nullptr);
     359//    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowIR))) {
     360//        threadCount = 1; // If we're dumping IR, disable seperate compilation
     361//        if (codegen::IROutputFilename.empty()) {
     362//            IROutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     363//        } else {
     364//            std::error_code error;
     365//            IROutputStream.reset(new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None));
     366//        }
     367//        PM.add(createPrintModulePass(*IROutputStream));
     368//    }
     369
     370//    #ifndef USE_LLVM_3_6
     371//    std::unique_ptr<raw_fd_ostream> ASMOutputStream(nullptr);
     372//    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowASM))) {
     373//        threadCount = 1; // If we're dumping ASM, disable seperate compilation
     374//        if (codegen::ASMOutputFilename.empty()) {
     375//            ASMOutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     376//        } else {
     377//            std::error_code error;
     378//            ASMOutputStream.reset(new raw_fd_ostream(codegen::ASMOutputFilename, error, sys::fs::OpenFlags::F_None));
     379//        }
     380//        if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(PM, *ASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
     381//            report_fatal_error("LLVM error: could not add emit assembly pass");
     382//        }
     383//    }
     384//    #endif
     385
     386//    Module * module = mMainModule;
     387//    WorkQueue<Module *> Q(mPipeline.size());
     388//    std::thread compilation_thread[threadCount - 1];
     389
     390//    try {
     391
     392//        for (unsigned i = 0; i < (threadCount - 1); ++i) {
     393//            compilation_thread[i] = std::thread([this, &Q]{
     394
     395//                InitializeNativeTarget();
     396
     397//                Module * module = nullptr;
     398//                while (Q.pop(module)) {
     399//                    mEngine->addModule(std::unique_ptr<Module>(module));
     400//                    mEngine->generateCodeForModule(module);
     401//                }
     402//            });
     403//        }
     404
     405//        module = mMainModule;
     406//        iBuilder->setKernel(nullptr);
     407//        PM.run(*mMainModule);
     408//        Q.push(mMainModule);
     409
     410//        for (Kernel * const kernel : mPipeline) {
     411//            iBuilder->setKernel(kernel);
     412//            module = kernel->getModule();
     413//            bool uncachedObject = true;
     414//            if (mCache && mCache->loadCachedObjectFile(iBuilder, kernel)) {
     415//                uncachedObject = false;
     416//            }
     417//            if (uncachedObject) {
     418//                module->setTargetTriple(mMainModule->getTargetTriple());
     419//                kernel->generateKernel(iBuilder);
     420//                PM.run(*module);
     421//            }
     422//            Q.push(module);
     423//        }
     424
     425//        for (;;) {
     426//            if (Q.empty()) {
     427//                break;
     428//            } else if (Q.try_pop(module)) {
     429//                mEngine->addModule(std::unique_ptr<Module>(module));
     430//                mEngine->generateCodeForModule(module);
     431//            }
     432//        }
     433
     434//        Q.notify_all();
     435//        for (unsigned i = 0; i < (threadCount - 1); ++i) {
     436//            compilation_thread[i].join();
     437//        }
     438
     439//        assert (Q.empty());
     440
     441//        mEngine->finalizeObject();
     442
     443//    } catch (const std::exception & e) {
     444//        module->dump();
     445//        report_fatal_error(e.what());
     446//    }
     447
     448//}
     449
    398450const std::unique_ptr<KernelBuilder> & ParabixDriver::getBuilder() {
    399451    return iBuilder;
Note: See TracChangeset for help on using the changeset viewer.