Ignore:
Timestamp:
Aug 12, 2015, 5:02:38 PM (4 years ago)
Author:
nmedfort
Message:

Temporary check in

File:
1 edited

Legend:

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

    r4723 r4724  
    4040#include <queue>
    4141#include <unordered_map>
     42#include <pablo/printer_pablos.h>
     43#include <llvm/Analysis/PostDominators.h>
    4244
    4345using namespace pablo;
     
    9395 * @brief computePabloDependencyMetrics
    9496 ** ------------------------------------------------------------------------------------------------------------- */
    95 unsigned computePabloDependencyChainMetrics(const PabloBlock & b, std::unordered_map<const PabloAST *, unsigned> G) {
     97unsigned computePabloDependencyChainMetrics(const PabloBlock & b, std::unordered_map<const PabloAST *, unsigned> & G) {
    9698    unsigned lpl = 0;
    9799    flat_map<const PabloAST *, unsigned> L;
     
    100102        unsigned global_lpl = 0;
    101103        for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
    102             const auto l = L.find(stmt->getOperand(i));
     104            const PabloAST * const op = stmt->getOperand(i);
     105            if (isa<String>(op) || isa<Integer>(op)) {
     106                continue;
     107            }
     108            const auto l = L.find(op);
    103109            if (l != L.end()) {
    104110                local_lpl = std::max<unsigned>(local_lpl, l->second);
    105111            }
    106             const auto g = G.find(stmt->getOperand(i));
     112            const auto g = G.find(op);
    107113            if (LLVM_UNLIKELY(g == G.end())) {
    108114                throw std::runtime_error("Could not find dependency chain length for all operands!");
     
    128134std::pair<unsigned, unsigned> computePabloDependencyChainMetrics(const PabloFunction & f) {
    129135    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));
    130138    for (unsigned i = 0; i != f.getNumOfParameters(); ++i) {
    131139        G.insert(std::make_pair(f.getParameter(i), 0));
     
    134142    unsigned global_lpl = 0;
    135143    for (unsigned i = 0; i != f.getNumOfResults(); ++i) {
    136         assert (V.count(f.getParameter(i)));
    137         global_lpl = std::max<unsigned>(global_lpl, G[f.getResult(i)]);
     144        const auto e = G.find(f.getResult(i));
     145        if (e == G.end()) {
     146            throw std::runtime_error("No result computed!");
     147        }
     148        global_lpl = std::max<unsigned>(global_lpl, e->second);
    138149    }
    139150    return std::make_pair(global_lpl, local_lpl);
    140151}
    141152
    142 
    143153/** ------------------------------------------------------------------------------------------------------------- *
    144154 * @brief computeLLVMDependencyMetrics
    145155 ** ------------------------------------------------------------------------------------------------------------- */
    146 unsigned computeLLVMDependencyChainMetrics(const llvm::BasicBlock & b, std::unordered_map<const llvm::Value *, unsigned> G) {
     156unsigned computeLLVMDependencyChainMetrics(const DomTreeNode * t, std::unordered_map<const Value *, unsigned> & G) {
    147157    unsigned lpl = 0;
    148158    if (true) {
    149         flat_map<const llvm::Value *, unsigned> L;
    150         for (const llvm::Instruction & inst : b) {
     159        flat_map<const Value *, unsigned> L;
     160        const BasicBlock * b = t->getBlock();
     161        for (auto itr = b->rbegin(); itr != b->rend(); ++itr) {
    151162            unsigned local_lpl = 0;
    152163            unsigned global_lpl = 0;
    153             for (unsigned i = 0; i != inst.getNumOperands(); ++i) {
    154                 const auto l = L.find(inst.getOperand(i));
    155                 if (l != L.end()) {
    156                     local_lpl = std::max<unsigned>(local_lpl, l->second);
     164            const Instruction & inst = *itr;
     165            for (const Value * user : inst.users()) {
     166                if (LLVM_LIKELY(isa<Instruction>(user))) {
     167                    const auto l = L.find(user);
     168                    if (l != L.end()) {
     169                        local_lpl = std::max<unsigned>(local_lpl, l->second);
     170                    }
     171                    const auto g = G.find(user);
     172                    if (LLVM_UNLIKELY(g == G.end())) {
     173                        throw std::runtime_error("Could not find chain length for all users!");
     174                    }
     175                    global_lpl = std::max<unsigned>(global_lpl, g->second);
    157176                }
    158                 const auto g = G.find(inst.getOperand(i));
    159                 if (LLVM_UNLIKELY(g == G.end())) {
    160                     throw std::runtime_error("Could not find dependency chain length for all operands!");
    161                 }
    162                 global_lpl = std::max<unsigned>(global_lpl, g->second);
    163177            }
    164178            L.emplace(&inst, local_lpl + 1);
    165179            G.insert(std::make_pair(&inst, global_lpl + 1));
    166         }
    167         for (const auto & l : L) {
    168             lpl = std::max(lpl, l.second);
    169         }
    170     }
    171     const TerminatorInst * t = b.getTerminator();
    172     if (LLVM_LIKELY(isa<BranchInst>(t))) {
    173         for (unsigned i = t->getNumSuccessors(); i-- != 0; ) {
    174             lpl = std::max(lpl, computeLLVMDependencyChainMetrics(*(t->getSuccessor(i)), G));
    175         }
     180            lpl = std::max(lpl, local_lpl + 1);
     181        }
     182    }
     183    for (const DomTreeNode * pt : *t) {
     184        lpl = std::max(lpl, computeLLVMDependencyChainMetrics(pt, G));
    176185    }
    177186    return lpl;
     
    181190 * @brief computeLLVMDependencyMetrics
    182191 ** ------------------------------------------------------------------------------------------------------------- */
    183 std::pair<unsigned, unsigned> computeLLVMDependencyChainMetrics(const llvm::Function & f) {
     192std::pair<unsigned, unsigned> computeLLVMDependencyChainMetrics(llvm::Function & f) {
    184193    std::unordered_map<const llvm::Value *, unsigned> G;
    185     auto arg_itr = f.getArgumentList().begin();
    186     const Argument & input = *arg_itr++;
    187     input.dump();
    188     for (const auto user : input.users()) {
    189         user->dump();
     194
     195    auto itr = f.getArgumentList().begin();
     196    const Argument & input = *itr++;
     197    const Argument & output = *itr;
     198    for (const User * user : output.users()) {
    190199        G.insert(std::make_pair(user, 0));
    191200    }
    192     const unsigned local_lpl = computeLLVMDependencyChainMetrics(f.getEntryBlock(), G);
    193     const Argument & output = *arg_itr;
     201
     202    PostDominatorTree dt;
     203    dt.runOnFunction(f);
     204    const unsigned local_lpl = computeLLVMDependencyChainMetrics(dt.getRootNode(), G);
     205    dt.releaseMemory();
     206
    194207    unsigned global_lpl = 0;
    195     for (const auto user : output.users()) {
    196         user->dump();
    197         global_lpl = std::max<unsigned>(global_lpl, G[user]);
     208    for (const User * user : input.users()) {
     209        const auto e = G.find(user);
     210        if (e == G.end()) {
     211            throw std::runtime_error("No result computed!");
     212        }
     213        global_lpl = std::max<unsigned>(global_lpl, e->second);
    198214    }
    199215    return std::make_pair(global_lpl, local_lpl);
     
    226242    #ifdef ENABLE_MULTIPLEXING
    227243    if (EnableMultiplexing) {
    228         if (MultiplexingDistributionFile) {
    229             (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock());
    230         }
    231         AutoMultiplexing::optimize(function);
    232         Simplifier::optimize(function);
    233         if (MultiplexingDistributionFile) {
    234             (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock()) << '\n';
    235         }
    236244
    237245        if (LongestDependenceChainFile) {
     
    240248            Module module("tmp", getGlobalContext());
    241249            auto func = pc.compile(function, &module);
    242             const auto llvm_metrix = computeLLVMDependencyChainMetrics(func.second);
     250            const auto llvm_metrix = computeLLVMDependencyChainMetrics(*func.first);
    243251            (*LongestDependenceChainFile) << ',' << llvm_metrix.first << ',' << llvm_metrix.second;
     252        }
     253
     254        if (MultiplexingDistributionFile) {
     255            (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock());
     256        }
     257        AutoMultiplexing::optimize(function);
     258        Simplifier::optimize(function);
     259        if (MultiplexingDistributionFile) {
     260            (*MultiplexingDistributionFile) << ',' << getNumOfAdvances(function.getEntryBlock()) << '\n';
    244261        }
    245262    }
Note: See TracChangeset for help on using the changeset viewer.