Ignore:
Timestamp:
Dec 1, 2015, 5:13:00 PM (4 years ago)
Author:
nmedfort
Message:

Bug fixes

Location:
icGREP/icgrep-devel/icgrep/pablo/optimizers
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/distributivepass.cpp

    r4885 r4886  
    77#include <boost/container/flat_map.hpp>
    88#include <boost/graph/adjacency_list.hpp>
    9 
    10 #include <pablo/printer_pablos.h>
    11 #include <iostream>
    129
    1310using namespace boost;
     
    335332        block->setInsertPoint(cast<Variadic>(G[sinks.front()])->getPrevNode());
    336333        if (isa<And>(G[sinks.front()])) {
    337             outerOp = block->createAnd(intermediary.size(), PabloBlock::createOnes());
    338             innerOp = block->createOr(sources.size() + 1, outerOp);
     334            outerOp = block->createAnd(intermediary.size());
     335            innerOp = block->createOr(sources.size() + 1);
    339336        } else {
    340             outerOp = block->createOr(intermediary.size(), PabloBlock::createZeroes());
    341             innerOp = block->createAnd(sources.size() + 1, outerOp);
    342         }
    343 
    344         unsigned i = 0;
     337            outerOp = block->createOr(intermediary.size());
     338            innerOp = block->createAnd(sources.size() + 1);
     339        }
     340
    345341        for (const Vertex u : intermediary) {
    346342            for (const Vertex v : sinks) {
    347343                cast<Variadic>(G[v])->deleteOperand(G[u]);
    348344            }
    349             outerOp->setOperand(i++, cast<Variadic>(G[u]));
    350         }
    351 
    352         i = 0;
     345            outerOp->addOperand(G[u]);
     346        }
     347
    353348        for (const Vertex u : sources) {
    354349            for (const Vertex v : intermediary) {
    355350                cast<Variadic>(G[v])->deleteOperand(G[u]);
    356351            }
    357             innerOp->setOperand(i++, G[u]);
    358         }
     352            innerOp->addOperand(G[u]);
     353        }
     354        innerOp->addOperand(outerOp);
     355
    359356        for (const Vertex u : sinks) {
    360357            cast<Variadic>(G[u])->addOperand(innerOp);
     
    387384    PabloVerifier::verify(function, "post-distribution");
    388385    #endif
     386
    389387    Simplifier::optimize(function);
    390388    return modified;
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.cpp

    r4885 r4886  
    5454
    5555/** ------------------------------------------------------------------------------------------------------------- *
    56  * @brief foldReassociativeFunction
    57  ** ------------------------------------------------------------------------------------------------------------- */
    58 PabloAST * Simplifier::foldReassociativeFunction(Variadic * const var, PabloBlock * const block) {
     56 * @brief fold
     57 ** ------------------------------------------------------------------------------------------------------------- */
     58inline PabloAST * Simplifier::fold(Variadic * const var, PabloBlock * const block) {
    5959
    6060    assert (var);
     
    8080            if (LLVM_UNLIKELY(isa<Xor>(var))) {
    8181                var->removeOperand(i - 1);
    82                 if (LLVM_UNLIKELY(var->getNumOperands() == 0)) {
    83                     return PabloBlock::createZeroes();
    84                 }
    8582            }
    8683            continue;
     
    133130    if (LLVM_UNLIKELY(negated)) {
    134131        block->setInsertPoint(var);
    135         if (replacement) {
    136             replacement = block->createNot(replacement);
    137         } else {
    138             var->replaceAllUsesWith(block->createNot(var));
    139         }
     132        replacement = block->createNot(replacement ? replacement : var);
    140133    }
    141134    return replacement;
     
    143136
    144137/** ------------------------------------------------------------------------------------------------------------- *
    145  * @brief canTriviallyFold
    146  ** ------------------------------------------------------------------------------------------------------------- */
    147 inline static PabloAST * canTriviallyFold(Statement * stmt, PabloBlock * block) {
    148     for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
    149         if (LLVM_UNLIKELY(isa<Zeroes>(stmt->getOperand(i)))) {
    150             switch (stmt->getClassTypeId()) {
    151                 case PabloAST::ClassTypeId::Advance:
    152                     return block->createZeroes();
    153                 case PabloAST::ClassTypeId::Not:
    154                     return block->createOnes();
    155                 case PabloAST::ClassTypeId::Sel:
    156                     block->setInsertPoint(stmt->getPrevNode());
    157                     switch (i) {
    158                         case 0: return stmt->getOperand(2);
    159                         case 1: return block->createAnd(block->createNot(stmt->getOperand(0)), stmt->getOperand(2));
    160                         case 2: return block->createAnd(stmt->getOperand(0), stmt->getOperand(1));
    161                     }
    162                 case PabloAST::ClassTypeId::ScanThru:
    163                 case PabloAST::ClassTypeId::MatchStar:
    164                     return stmt->getOperand(0);
    165                 default: break;
    166             }
    167         } else if (LLVM_UNLIKELY(isa<Ones>(stmt->getOperand(i)))) {
    168             block->setInsertPoint(stmt->getPrevNode());
    169             switch (stmt->getClassTypeId()) {
    170                 case PabloAST::ClassTypeId::Not:
    171                     return block->createZeroes();
    172                 case PabloAST::ClassTypeId::Sel:
    173                     block->setInsertPoint(stmt->getPrevNode());
    174                     switch (i) {
    175                         case 0: return stmt->getOperand(1);
    176                         case 1: return block->createOr(stmt->getOperand(0), stmt->getOperand(2));
    177                         case 2: return block->createOr(block->createNot(stmt->getOperand(0)), stmt->getOperand(1));
    178                     }
    179                 case PabloAST::ClassTypeId::ScanThru:
    180                     if (i == 1) {
     138 * @brief fold
     139 ** ------------------------------------------------------------------------------------------------------------- */
     140inline PabloAST * Simplifier::fold(Statement * stmt, PabloBlock * block) {
     141    if (isReassociative(stmt)) {
     142        return fold(cast<Variadic>(stmt), block);
     143    } else {
     144        for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
     145            if (LLVM_UNLIKELY(isa<Zeroes>(stmt->getOperand(i)))) {
     146                switch (stmt->getClassTypeId()) {
     147                    case PabloAST::ClassTypeId::Advance:
    181148                        return block->createZeroes();
    182                     }
    183                     break;
    184                 case PabloAST::ClassTypeId::MatchStar:
    185                     if (i == 0) {
     149                    case PabloAST::ClassTypeId::Not:
    186150                        return block->createOnes();
    187                     }
    188                     break;
    189                 default: break;
    190             }
    191         }
    192     }
    193     return nullptr;
     151                    case PabloAST::ClassTypeId::Sel:
     152                        block->setInsertPoint(stmt->getPrevNode());
     153                        switch (i) {
     154                            case 0: return stmt->getOperand(2);
     155                            case 1: return block->createAnd(block->createNot(stmt->getOperand(0)), stmt->getOperand(2));
     156                            case 2: return block->createAnd(stmt->getOperand(0), stmt->getOperand(1));
     157                        }
     158                    case PabloAST::ClassTypeId::ScanThru:
     159                    case PabloAST::ClassTypeId::MatchStar:
     160                        return stmt->getOperand(0);
     161                    default: break;
     162                }
     163            } else if (LLVM_UNLIKELY(isa<Ones>(stmt->getOperand(i)))) {
     164                block->setInsertPoint(stmt->getPrevNode());
     165                switch (stmt->getClassTypeId()) {
     166                    case PabloAST::ClassTypeId::Not:
     167                        return block->createZeroes();
     168                    case PabloAST::ClassTypeId::Sel:
     169                        block->setInsertPoint(stmt->getPrevNode());
     170                        switch (i) {
     171                            case 0: return stmt->getOperand(1);
     172                            case 1: return block->createOr(stmt->getOperand(0), stmt->getOperand(2));
     173                            case 2: return block->createOr(block->createNot(stmt->getOperand(0)), stmt->getOperand(1));
     174                        }
     175                    case PabloAST::ClassTypeId::ScanThru:
     176                        if (i == 1) {
     177                            return block->createZeroes();
     178                        }
     179                        break;
     180                    case PabloAST::ClassTypeId::MatchStar:
     181                        if (i == 0) {
     182                            return block->createOnes();
     183                        }
     184                        break;
     185                    default: break;
     186                }
     187            }
     188        }
     189        return nullptr;
     190    }
    194191}
    195192
     
    383380            // statements into the body.
    384381        } else {
    385             PabloAST * folded = nullptr;
    386             if (isReassociative(stmt)) {
    387                 folded =  foldReassociativeFunction(cast<Variadic>(stmt), block);
    388             } else {
    389                 folded = canTriviallyFold(stmt, block);
    390             }
    391             if (folded) {
     382            if (PabloAST * folded = fold(stmt, block)) {
    392383                // If we determine we can fold this statement,
    393384                Statement * const prior = stmt->getPrevNode();
    394385                stmt->replaceWith(folded, true);
    395                 stmt = prior ? prior->getNextNode() : block->front();
     386                stmt = LLVM_LIKELY(prior != nullptr) ? prior->getNextNode() : block->front();
    396387                continue;
    397388            }
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.hpp

    r4880 r4886  
    1616private:
    1717    static void eliminateRedundantCode(PabloBlock * const block, ExpressionTable * predecessor = nullptr);
    18     static PabloAST * foldReassociativeFunction(Variadic * const var, PabloBlock * const block);
     18    static PabloAST * fold(Variadic * const var, PabloBlock * const block);
     19    static PabloAST * fold(Statement * const stmt, PabloBlock * const block);
    1920    static void deadCodeElimination(PabloBlock * const block);
    2021    static void strengthReduction(PabloBlock * const block);
Note: See TracChangeset for help on using the changeset viewer.