Ignore:
Timestamp:
Aug 21, 2015, 4:12:09 PM (4 years ago)
Author:
nmedfort
Message:

Initial stages of a simple boolean equation reassociation pass.

File:
1 edited

Legend:

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

    r4726 r4736  
    4949using namespace boost::container;
    5050
     51enum IfHierarchy {DefaultIfHierarchy, NoIfHierarchy};
     52
    5153static cl::opt<std::string>
    5254ObjectFilename("o", cl::desc("Output object filename"), cl::value_desc("filename"), cl::Required);
     
    5759static cl::opt<std::string>
    5860PrintLongestDependenceChain("ldc", cl::desc("print longest dependency chain metrics."), cl::value_desc("filename"));
     61
     62static cl::opt<IfHierarchy> IfHierarchyStrategy(cl::desc("If Hierarchy strategy:"),
     63                                                cl::values(clEnumVal(DefaultIfHierarchy, "Default"),
     64                                                           clEnumVal(NoIfHierarchy, "None"),
     65                                                           clEnumValEnd));
     66
     67
     68
    5969
    6070static raw_fd_ostream * LongestDependenceChainFile = nullptr;
     
    132142 * @brief computePabloDependencyMetrics
    133143 ** ------------------------------------------------------------------------------------------------------------- */
    134 std::pair<unsigned, unsigned> computePabloDependencyChainMetrics(const PabloFunction & f) {
     144std::pair<unsigned, unsigned> computePabloDependencyChainMetrics(const PabloFunction * f) {
    135145    std::unordered_map<const PabloAST *, unsigned> G;
    136     G.insert(std::make_pair(f.getEntryBlock().createZeroes(), 0));
    137     G.insert(std::make_pair(f.getEntryBlock().createOnes(), 0));
    138     for (unsigned i = 0; i != f.getNumOfParameters(); ++i) {
    139         G.insert(std::make_pair(f.getParameter(i), 0));
    140     }
    141     const unsigned local_lpl = computePabloDependencyChainMetrics(f.getEntryBlock(), G);
     146    G.insert(std::make_pair(f->getEntryBlock().createZeroes(), 0));
     147    G.insert(std::make_pair(f->getEntryBlock().createOnes(), 0));
     148    for (unsigned i = 0; i != f->getNumOfParameters(); ++i) {
     149        G.insert(std::make_pair(f->getParameter(i), 0));
     150    }
     151    const unsigned local_lpl = computePabloDependencyChainMetrics(f->getEntryBlock(), G);
    142152    unsigned global_lpl = 0;
    143     for (unsigned i = 0; i != f.getNumOfResults(); ++i) {
    144         const auto e = G.find(f.getResult(i));
     153    for (unsigned i = 0; i != f->getNumOfResults(); ++i) {
     154        const auto e = G.find(f->getResult(i));
    145155        if (e == G.end()) {
    146156            throw std::runtime_error("No result computed!");
     
    190200 * @brief computeLLVMDependencyMetrics
    191201 ** ------------------------------------------------------------------------------------------------------------- */
    192 std::pair<unsigned, unsigned> computeLLVMDependencyChainMetrics(llvm::Function & f) {
     202std::pair<unsigned, unsigned> computeLLVMDependencyChainMetrics(llvm::Function * f) {
    193203    std::unordered_map<const llvm::Value *, unsigned> G;
    194204
    195     auto itr = f.getArgumentList().begin();
     205    auto itr = f->getArgumentList().begin();
    196206    const Argument & input = *itr++;
    197207    const Argument & output = *itr;
     
    201211
    202212    PostDominatorTree dt;
    203     dt.runOnFunction(f);
     213    dt.runOnFunction(*f);
    204214    const unsigned local_lpl = computeLLVMDependencyChainMetrics(dt.getRootNode(), G);
    205215    dt.releaseMemory();
     
    228238        (*LongestDependenceChainFile) << name;
    229239    }
    230 
    231     PabloFunction function = PabloFunction::Create(std::move(name), 8, 1);
     240    std::cerr << name << std::endl;
     241
     242    PabloFunction * function = PabloFunction::Create(std::move(name), 8, 1);
    232243    Encoding encoding(Encoding::Type::UTF_8, 8);
    233     CC_Compiler ccCompiler(function, encoding);
     244    CC_Compiler ccCompiler(*function, encoding);
    234245    UCDCompiler ucdCompiler(ccCompiler);
    235     PabloBuilder builder(function.getEntryBlock());
     246    PabloBuilder builder(function->getEntryBlock());
    236247    // Build the unicode set function
    237     function.setResult(0, builder.createAssign("matches", ucdCompiler.generateWithDefaultIfHierarchy(set, builder)));
     248    PabloAST * result = nullptr;
     249    if (IfHierarchyStrategy == IfHierarchy::DefaultIfHierarchy) {
     250        result = ucdCompiler.generateWithDefaultIfHierarchy(set, builder);
     251    } else if (IfHierarchyStrategy == IfHierarchy::NoIfHierarchy) {
     252        result = ucdCompiler.generateWithoutIfHierarchy(set, builder);
     253    } else {
     254        throw std::runtime_error("Unknown if hierarchy strategy!");
     255    }
     256    function->setResult(0, builder.createAssign("matches", result));
    238257    // Optimize it at the pablo level
    239     Simplifier::optimize(function);
    240     CodeSinking::optimize(function);
     258    Simplifier::optimize(*function);
     259    CodeSinking::optimize(*function);
    241260
    242261    #ifdef ENABLE_MULTIPLEXING
    243262    if (EnableMultiplexing) {
    244 
    245263        if (LongestDependenceChainFile) {
    246264            const auto pablo_metrix = computePabloDependencyChainMetrics(function);
    247265            (*LongestDependenceChainFile) << ',' << pablo_metrix.first << ',' << pablo_metrix.second;
    248266            Module module("tmp", getGlobalContext());
    249             auto func = pc.compile(function, &module);
    250             const auto llvm_metrix = computeLLVMDependencyChainMetrics(*func.first);
     267            llvm::Function * func = pc.compile(function, &module);
     268            const auto llvm_metrix = computeLLVMDependencyChainMetrics(func);
    251269            (*LongestDependenceChainFile) << ',' << llvm_metrix.first << ',' << llvm_metrix.second;
    252270        }
    253271
    254272        if (MultiplexingDistributionFile) {
    255             (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock());
    256         }
    257         AutoMultiplexing::optimize(function);
    258         Simplifier::optimize(function);
     273            (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function->getEntryBlock());
     274        }
     275        AutoMultiplexing::optimize(*function);
    259276        if (MultiplexingDistributionFile) {
    260             (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock()) << '\n';
     277            (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function->getEntryBlock()) << '\n';
    261278        }
    262279    }
    263280    #endif
    264281    // Now compile the function ...
    265     auto func = pc.compile(function, module);
     282    llvm::Function * func = pc.compile(function, module);
    266283    releaseSlabAllocatorMemory();
    267 /*
     284
    268285    if (LongestDependenceChainFile) {
    269286        const auto pablo_metrix = computePabloDependencyChainMetrics(function);
    270287        (*LongestDependenceChainFile) << ',' << pablo_metrix.first << ',' << pablo_metrix.second;
    271         const auto llvm_metrix = computeLLVMDependencyChainMetrics(*func.first);
     288        const auto llvm_metrix = computeLLVMDependencyChainMetrics(func);
    272289        (*LongestDependenceChainFile) << ',' << llvm_metrix.first << ',' << llvm_metrix.second << '\n';
    273290    }
    274 */
     291
    275292}
    276293
Note: See TracChangeset for help on using the changeset viewer.