Ignore:
Timestamp:
May 12, 2017, 4:54:11 PM (2 years ago)
Author:
nmedfort
Message:

Refactoring work + correction for getRawItemPointer

File:
1 edited

Legend:

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

    r5444 r5446  
    3535using namespace parabix;
    3636
     37using Kernel = kernel::Kernel;
     38using KernelBuilder = kernel::KernelBuilder;
     39
     40#ifndef NDEBUG
     41#define IN_DEBUG_MODE true
     42#else
     43#define IN_DEBUG_MODE false
     44#endif
     45
    3746namespace codegen {
    3847
     
    7281bool EnableAsserts;
    7382bool EnableCycleCounter;
    74 #ifndef NDEBUG
    75 #define IN_DEBUG_MODE true
    76 #else
    77 #define IN_DEBUG_MODE false
    78 #endif
    7983
    8084static cl::opt<int, true> BlockSizeOption("BlockSize", cl::location(BlockSize), cl::init(0), cl::desc("specify a block size (defaults to widest SIMD register width in bits)."), cl::cat(CodeGenOptions));
     
    147151    TargetOptions opts = InitTargetOptionsFromCodeGenFlags();
    148152    opts.MCOptions.AsmVerbose = codegen::AsmVerbose;
    149 
    150153    builder.setTargetOptions(opts);
    151     builder.setVerifyModules(false);
     154    builder.setVerifyModules(IN_DEBUG_MODE || codegen::DebugOptionIsSet(codegen::VerifyIR));
    152155    CodeGenOpt::Level optLevel = CodeGenOpt::Level::None;
    153156    switch (codegen::OptLevel) {
     
    159162    }
    160163    builder.setOptLevel(optLevel);
    161 
    162164    setAllFeatures(builder);
    163165    mEngine = builder.create();
     
    178180    mMainModule->setTargetTriple(mTarget->getTargetTriple().getTriple());
    179181
    180     iBuilder.reset(IDISA::GetIDISA_Builder(mMainModule));
     182    iBuilder.reset(IDISA::GetIDISA_Builder(*mContext, mMainModule->getTargetTriple()));
    181183    iBuilder->setDriver(this);
    182184    iBuilder->setModule(mMainModule);
     
    194196}
    195197
    196 kernel::Kernel * ParabixDriver::addKernelInstance(std::unique_ptr<kernel::Kernel> kb) {
     198Kernel * ParabixDriver::addKernelInstance(std::unique_ptr<Kernel> kb) {
    197199    mOwnedKernels.emplace_back(std::move(kb));
    198200    return mOwnedKernels.back().get();
    199201}
    200202
    201 void ParabixDriver::addKernelCall(kernel::Kernel & kb, const std::vector<StreamSetBuffer *> & inputs, const std::vector<StreamSetBuffer *> & outputs) {
     203void ParabixDriver::addKernelCall(Kernel & kb, const std::vector<StreamSetBuffer *> & inputs, const std::vector<StreamSetBuffer *> & outputs) {
    202204    assert ("addKernelCall or makeKernelCall was already run on this kernel." && (kb.getModule() == nullptr));
    203205    mPipeline.emplace_back(&kb);
    204     kb.createKernelStub(iBuilder, inputs, outputs);
    205 }
    206 
    207 void ParabixDriver::makeKernelCall(kernel::Kernel * kb, const std::vector<StreamSetBuffer *> & inputs, const std::vector<StreamSetBuffer *> & outputs) {
     206    kb.bindPorts(inputs, outputs);
     207    kb.makeModule(iBuilder);
     208}
     209
     210void ParabixDriver::makeKernelCall(Kernel * kb, const std::vector<StreamSetBuffer *> & inputs, const std::vector<StreamSetBuffer *> & outputs) {
    208211    assert ("addKernelCall or makeKernelCall was already run on this kernel." && (kb->getModule() == nullptr));
    209212    mPipeline.emplace_back(kb);   
    210     kb->createKernelStub(iBuilder, inputs, outputs);
     213    kb->bindPorts(inputs, outputs);
     214    kb->makeModule(iBuilder);
    211215}
    212216
     
    256260
    257261void ParabixDriver::linkAndFinalize() {
    258     Module * module = nullptr;
     262
     263//    using WorkQueue = boost::lockfree::queue<Kernel *>;
     264
     265    legacy::PassManager PM;
     266    if (IN_DEBUG_MODE || LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::VerifyIR))) {
     267        PM.add(createVerifierPass());
     268    }
     269    PM.add(createPromoteMemoryToRegisterPass()); //Force the use of mem2reg to promote stack variables.
     270    PM.add(createReassociatePass());             //Reassociate expressions.
     271    PM.add(createGVNPass());                     //Eliminate common subexpressions.
     272    PM.add(createInstructionCombiningPass());    //Simple peephole optimizations and bit-twiddling.
     273    PM.add(createCFGSimplificationPass());
     274
     275//    unsigned threadCount = std::thread::hardware_concurrency();
     276
     277    std::unique_ptr<raw_fd_ostream> IROutputStream(nullptr);
     278    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        }
     286        PM.add(createPrintModulePass(*IROutputStream));
     287    }
     288
     289    #ifndef USE_LLVM_3_6
     290    std::unique_ptr<raw_fd_ostream> ASMOutputStream(nullptr);
     291    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowASM))) {
     292//        threadCount = 1; // If we're dumping ASM, disable seperate compilation
     293        if (codegen::ASMOutputFilename.empty()) {
     294            ASMOutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
     295        } else {
     296            std::error_code error;
     297            ASMOutputStream.reset(new raw_fd_ostream(codegen::ASMOutputFilename, error, sys::fs::OpenFlags::F_None));
     298        }
     299        if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(PM, *ASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
     300            report_fatal_error("LLVM error: could not add emit assembly pass");
     301        }
     302    }
     303    #endif
     304
    259305    try {
    260306
    261         legacy::PassManager PM;
    262 #ifndef NDEBUG
    263         PM.add(createVerifierPass());
    264 #else
    265         if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::VerifyIR))) {
    266             PM.add(createVerifierPass());
    267         }
    268 #endif
    269         PM.add(createPromoteMemoryToRegisterPass()); //Force the use of mem2reg to promote stack variables.
    270         PM.add(createReassociatePass());             //Reassociate expressions.
    271         PM.add(createGVNPass());                     //Eliminate common subexpressions.
    272         PM.add(createInstructionCombiningPass());    //Simple peephole optimizations and bit-twiddling.
    273         PM.add(createCFGSimplificationPass());
    274 
    275         std::unique_ptr<raw_fd_ostream> IROutputStream(nullptr);
    276         if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowIR))) {
    277             if (codegen::IROutputFilename.empty()) {
    278                 IROutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
    279             } else {
    280                 std::error_code error;
    281                 IROutputStream.reset(new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None));
    282             }
    283             PM.add(createPrintModulePass(*IROutputStream));
    284         }
    285 
    286         #ifndef USE_LLVM_3_6
    287         std::unique_ptr<raw_fd_ostream> ASMOutputStream(nullptr);
    288         if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowASM))) {
    289             if (codegen::ASMOutputFilename.empty()) {
    290                 ASMOutputStream.reset(new raw_fd_ostream(STDERR_FILENO, false, false));
    291             } else {
    292                 std::error_code error;
    293                 ASMOutputStream.reset(new raw_fd_ostream(codegen::ASMOutputFilename, error, sys::fs::OpenFlags::F_None));
    294             }
    295             if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(PM, *ASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
    296                 report_fatal_error("LLVM error: could not add emit assembly pass");
    297             }
    298         }
    299         #endif
    300 
    301         for (kernel::Kernel * const kernel : mPipeline) {
     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
     368        for (Kernel * const kernel : mPipeline) {
     369
    302370            iBuilder->setKernel(kernel);
    303             module = kernel->getModule();
     371            Module * module = kernel->getModule();
    304372            bool uncachedObject = true;
    305373            if (mCache && mCache->loadCachedObjectFile(iBuilder, kernel)) {
     
    312380            }
    313381            mEngine->addModule(std::unique_ptr<Module>(module));
     382            mEngine->generateCodeForModule(module);
    314383        }
    315384
    316385        iBuilder->setKernel(nullptr);
    317         module = mMainModule;
    318         PM.run(*module);
    319 
    320         mEngine->finalizeObject();
    321 
    322     } catch (...) {
    323         module->dump();
    324         report_fatal_error("LLVM error: link or finalize.");
    325     }
    326 }
    327 
    328 const std::unique_ptr<kernel::KernelBuilder> & ParabixDriver::getBuilder() {
     386        PM.run(*mMainModule);
     387
     388//    }
     389
     390    mEngine->finalizeObject();
     391
     392    } catch (const std::exception & e) {
     393        report_fatal_error(e.what());
     394    }
     395
     396}
     397
     398const std::unique_ptr<KernelBuilder> & ParabixDriver::getBuilder() {
    329399    return iBuilder;
    330400}
     
    337407    delete mCache;
    338408}
    339 
    340 
    341 //void ParabixDriver::linkAndFinalize() {
    342 
    343 //    using KernelQueue = boost::lockfree::queue<kernel::KernelBuilder *>;
    344 
    345 //    legacy::PassManager PM;
    346 //    #ifndef NDEBUG
    347 //    PM.add(createVerifierPass());
    348 //    #endif
    349 //    PM.add(createPromoteMemoryToRegisterPass()); //Force the use of mem2reg to promote stack variables.
    350 //    PM.add(createReassociatePass());             //Reassociate expressions.
    351 //    PM.add(createGVNPass());                     //Eliminate common subexpressions.
    352 //    PM.add(createInstructionCombiningPass());    //Simple peephole optimizations and bit-twiddling.
    353 //    PM.add(createCFGSimplificationPass());
    354 
    355 //    raw_fd_ostream * IROutputStream = nullptr;
    356 //    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowIR))) {
    357 //        if (codegen::IROutputFilename.empty()) {
    358 //            IROutputStream = new raw_fd_ostream(STDERR_FILENO, false, false);
    359 //        } else {
    360 //            std::error_code error;
    361 //            IROutputStream = new raw_fd_ostream(codegen::IROutputFilename, error, sys::fs::OpenFlags::F_None);
    362 //        }
    363 //        PM.add(createPrintModulePass(*IROutputStream));
    364 //        codegen::Jobs = 1; // TODO: set Jobs to 1 for now; these should be updated to pipe to a temporary buffer when Jobs > 1
    365 //    }
    366 
    367 //    #ifndef USE_LLVM_3_6
    368 //    raw_fd_ostream * ASMOutputStream = nullptr;
    369 //    if (LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::ShowASM))) {
    370 //        if (codegen::ASMOutputFilename.empty()) {
    371 //            ASMOutputStream = new raw_fd_ostream(STDERR_FILENO, false, false);
    372 //        } else {
    373 //            std::error_code error;
    374 //            ASMOutputStream = new raw_fd_ostream(codegen::ASMOutputFilename, error, sys::fs::OpenFlags::F_None);
    375 //        }
    376 //        if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(PM, *ASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
    377 //            report_fatal_error("LLVM error: could not add emit assembly pass");
    378 //        }
    379 //        codegen::Jobs = 1; // TODO: set Jobs to 1 for now; these should be updated to pipe to a temporary buffer when Jobs > 1
    380 //    }
    381 //    #endif
    382 
    383 //    KernelQueue Q(mPipeline.size() + 1);
    384 //    for (kernel::KernelBuilder * kb : mPipeline) {
    385 //        assert (kb);
    386 //        Q.unsynchronized_push(kb);
    387 //    }
    388 
    389 //    std::thread compilation_thread[codegen::Jobs];
    390 //    for (int i = 0; i < codegen::Jobs; ++i) {
    391 //        compilation_thread[i] = std::thread([&]{
    392 //            kernel::KernelBuilder * kb = nullptr;
    393 //            Module * m = nullptr;
    394 //            try {
    395 //                while (Q.pop(kb)) {
    396 //                    m = kb->getModule();
    397 //                    bool uncachedObject = true;
    398 //                    if (mCache && mCache->loadCachedObjectFile(kb)) {
    399 //                        uncachedObject = false;
    400 //                    }
    401 //                    if (uncachedObject) {
    402 //                        Module * const cm = iBuilder->getModule();
    403 //                        iBuilder->setModule(m);
    404 //                        kb->generateKernel();
    405 //                        PM.run(*m);
    406 //                        iBuilder->setModule(cm);
    407 //                    }
    408 //                    mEngine->addModule(std::unique_ptr<Module>(m));
    409 //                }
    410 //            } catch (...) {
    411 //                // clear the queue
    412 //                while (Q.pop(kb));
    413 //                // dump the result the module to the console
    414 //                if (m) m->dump();
    415 //                throw;
    416 //            }
    417 //        });
    418 //    }
    419 
    420 //    PM.run(*mMainModule);
    421 //    for (int i = 0; i < codegen::Jobs; ++i) {
    422 //        compilation_thread[i].join();
    423 //    }
    424 //    mEngine->finalizeObject();
    425 
    426 //    delete IROutputStream;
    427 //    #ifndef USE_LLVM_3_6
    428 //    delete ASMOutputStream;
    429 //    #endif
    430 
    431 //}
    432 
    433 
    434 //            std::unique_ptr<IDISA::IDISA_Builder> idb(IDISA::GetIDISA_Builder(kb->getModule()));
    435 //            idb->setDriver(this);
    436 //            kb->setBuilder(idb.get());
Note: See TracChangeset for help on using the changeset viewer.