Ignore:
Timestamp:
Sep 21, 2017, 3:10:34 PM (2 years ago)
Author:
nmedfort
Message:

Minor clean up. Bug fix for object cache when the same cached kernel is used twice in a single run. Improvement to RE Minimizer.

Location:
icGREP/icgrep-devel/icgrep/pablo
Files:
4 edited

Legend:

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

    r5620 r5646  
    1010#include <pablo/ps_assign.h>
    1111#include <pablo/pe_advance.h>
     12#include <pablo/pe_lookahead.h>
    1213#include <pablo/pe_scanthru.h>
    1314#include <pablo/pe_matchstar.h>
     
    269270            return block->createZeroes(stmt->getType()); // ¬1 ⇔ 0
    270271        }
    271     } else if (LLVM_UNLIKELY(isa<Add>(stmt) || isa<Subtract>(stmt))) {
    272        if (LLVM_UNLIKELY(isa<Integer>(stmt->getOperand(0)) && isa<Integer>(stmt->getOperand(1)))) {
    273            const Integer * const int0 = cast<Integer>(stmt->getOperand(0));
    274            const Integer * const int1 = cast<Integer>(stmt->getOperand(1));
    275            Integer::IntTy result = 0;
    276            if (isa<Add>(stmt)) {
    277                result = int0->value() + int1->value();
    278            } else {
    279                result = int0->value() - int1->value();
    280            }
    281            return block->getInteger(result);
    282        }
    283     } else if (LLVM_UNLIKELY(isa<Variadic>(stmt))) {
    284 
     272    } else if (isa<Variadic>(stmt)) {
    285273        std::sort(cast<Variadic>(stmt)->begin(), cast<Variadic>(stmt)->end());
    286 
    287274        for (unsigned i = 1; i < stmt->getNumOperands(); ) {
    288275            if (LLVM_UNLIKELY(stmt->getOperand(i - 1) == stmt->getOperand(i))) {
     
    306293            ++i;
    307294        }
    308 
    309295        if (LLVM_UNLIKELY(stmt->getNumOperands() < 2)) {
    310296            if (LLVM_LIKELY(stmt->getNumOperands() == 1)) {
     
    314300            }
    315301        }
    316 
    317302        if (LLVM_UNLIKELY(isa<Xor>(stmt))) {
    318303            bool negated = false;
     
    337322            if (LLVM_UNLIKELY(negated)) {
    338323                block->setInsertPoint(stmt);
    339                 expr = block->createNot(expr ? expr : stmt);
     324                expr = triviallyFold(block->createNot(expr ? expr : stmt), block);
    340325            }
    341326            return expr;
     
    358343            }
    359344        }
    360     } else {
    361         for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
    362             if (LLVM_UNLIKELY(isa<Zeroes>(stmt->getOperand(i)))) {
    363                 switch (stmt->getClassTypeId()) {
    364                     case TypeId::Sel:
    365                         block->setInsertPoint(stmt->getPrevNode());
    366                         switch (i) {
    367                             case 0: return stmt->getOperand(2);
    368                             case 1: return block->createAnd(block->createNot(stmt->getOperand(0)), stmt->getOperand(2));
    369                             case 2: return block->createAnd(stmt->getOperand(0), stmt->getOperand(1));
    370                         }
    371                     case TypeId::Advance:
    372                     case TypeId::ScanThru:
    373                     case TypeId::MatchStar:
    374                         return stmt->getOperand(0);
    375                     default: break;
    376                 }
    377             } else if (LLVM_UNLIKELY(isa<Ones>(stmt->getOperand(i)))) {
    378                 switch (stmt->getClassTypeId()) {
    379                     case TypeId::Sel:
    380                         block->setInsertPoint(stmt->getPrevNode());
    381                         switch (i) {
    382                             case 0: return stmt->getOperand(1);
    383                             case 1: return block->createOr(stmt->getOperand(0), stmt->getOperand(2));
    384                             case 2: return block->createOr(block->createNot(stmt->getOperand(0)), stmt->getOperand(1));
    385                         }
    386                     case TypeId::ScanThru:
    387                         if (LLVM_UNLIKELY(i == 1)) {
    388                             return block->createZeroes(stmt->getType());
    389                         }
    390                         break;
    391                     case TypeId::MatchStar:
    392                         if (LLVM_UNLIKELY(i == 0)) {
    393                             return block->createOnes(stmt->getType());
    394                         }
    395                         break;
    396                     default: break;
    397                 }
    398             }
    399         }       
     345    } else if (isa<Advance>(stmt)) {
     346        Advance * const adv = cast<Advance>(stmt);
     347        if (LLVM_UNLIKELY(isa<Zeroes>(adv->getExpression()) || adv->getAmount() == 0)) {
     348            return adv->getExpression();
     349        }
     350    } else if (isa<ScanThru>(stmt)) {
     351        ScanThru * const st = cast<ScanThru>(stmt);
     352        if (LLVM_UNLIKELY(isa<Zeroes>(st->getScanFrom()) || isa<Zeroes>(st->getScanThru()))) {
     353            return st->getScanFrom();
     354        } else if (LLVM_UNLIKELY(isa<Ones>(st->getScanThru()))) {
     355            block->setInsertPoint(stmt->getPrevNode());
     356            return block->createZeroes(stmt->getType());
     357        }
     358    } else if (isa<MatchStar>(stmt)) {
     359        MatchStar * const mstar = cast<MatchStar>(stmt);
     360        if (LLVM_UNLIKELY(isa<Zeroes>(mstar->getMarker()) || isa<Zeroes>(mstar->getCharClass()))) {
     361            return mstar->getMarker();
     362        } else if (LLVM_UNLIKELY(isa<Ones>(mstar->getMarker()))) {
     363            block->setInsertPoint(stmt->getPrevNode());
     364            return block->createOnes(stmt->getType());
     365        }
     366    } else if (isa<Lookahead>(stmt)) {
     367        Lookahead * const la = cast<Lookahead>(stmt);
     368        if (LLVM_UNLIKELY(isa<Zeroes>(la->getExpression()) || la->getAmount() == 0)) {
     369            return la->getExpression();
     370        }
     371    } else if (LLVM_UNLIKELY(isa<Sel>(stmt))) {
     372        Sel * const sel = cast<Sel>(stmt);
     373        if (LLVM_UNLIKELY(isa<Zeroes>(sel->getCondition()))) {
     374            return sel->getFalseExpr();
     375        }
     376        if (LLVM_UNLIKELY(isa<Ones>(sel->getCondition()))) {
     377            return sel->getTrueExpr();
     378        }
     379        if (LLVM_UNLIKELY(isa<Zeroes>(sel->getTrueExpr()))) {
     380            block->setInsertPoint(stmt->getPrevNode());
     381            PabloAST * const negCond = triviallyFold(block->createNot(sel->getCondition()), block);
     382            return triviallyFold(block->createAnd(sel->getFalseExpr(), negCond), block);
     383        }
     384        if (LLVM_UNLIKELY(isa<Ones>(sel->getTrueExpr()))) {
     385            block->setInsertPoint(stmt->getPrevNode());
     386            return triviallyFold(block->createOr(sel->getCondition(), sel->getFalseExpr()), block);
     387        }
     388        if (LLVM_UNLIKELY(isa<Zeroes>(sel->getFalseExpr()))) {
     389            block->setInsertPoint(stmt->getPrevNode());
     390            return triviallyFold(block->createAnd(sel->getCondition(), sel->getTrueExpr()), block);
     391        }
     392        if (LLVM_UNLIKELY(isa<Ones>(sel->getFalseExpr()))) {
     393            block->setInsertPoint(stmt->getPrevNode());
     394            PabloAST * const negCond = triviallyFold(block->createNot(sel->getCondition()), block);
     395            return triviallyFold(block->createOr(sel->getTrueExpr(), negCond), block);
     396        }
     397    } else if (LLVM_UNLIKELY(isa<Add>(stmt) || isa<Subtract>(stmt))) {
     398       if (LLVM_UNLIKELY(isa<Integer>(stmt->getOperand(0)) && isa<Integer>(stmt->getOperand(1)))) {
     399           const Integer * const int0 = cast<Integer>(stmt->getOperand(0));
     400           const Integer * const int1 = cast<Integer>(stmt->getOperand(1));
     401           Integer::IntTy result = 0;
     402           if (isa<Add>(stmt)) {
     403               result = int0->value() + int1->value();
     404           } else {
     405               result = int0->value() - int1->value();
     406           }
     407           return block->getInteger(result);
     408       }
    400409    }
    401410    return nullptr;
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r5629 r5646  
    8181        if (LLVM_UNLIKELY(isa<Lookahead>(stmt))) {
    8282            const Lookahead * const la = cast<Lookahead>(stmt);
    83             //assert ((isa<Var>(la->getExpr()) || isa<Extract>(la->getExpr())));
    84             if (LLVM_LIKELY(la->getAmount() > mKernel->getLookAhead())) {
    85                 mKernel->setLookAhead(la->getAmount());
     83            PabloAST * input = la->getExpression();
     84            if (LLVM_UNLIKELY(isa<Extract>(input))) {
     85                input = cast<Extract>(input)->getArray();
     86            }
     87            bool notFound = true;
     88            if (LLVM_LIKELY(isa<Var>(input))) {
     89                for (unsigned i = 0; i < mKernel->getNumOfInputs(); ++i) {
     90                    if (input == mKernel->getInput(i)) {
     91                        if (LLVM_LIKELY(mKernel->getLookAhead(i) < la->getAmount())) {
     92                            mKernel->setLookAhead(i, la->getAmount());
     93                        }
     94                        notFound = false;
     95                        break;
     96                    }
     97                }
     98            }
     99            if (LLVM_UNLIKELY(notFound)) {
     100                report_fatal_error("Lookahead " + stmt->getName() + " can only be performed on an input streamset");
    86101            }
    87102        } else if (LLVM_UNLIKELY(isa<Branch>(stmt))) {
     
    542557        } else if (const Lookahead * l = dyn_cast<Lookahead>(stmt)) {
    543558            Var * var = nullptr;
    544             PabloAST * stream = l->getExpr();
     559            PabloAST * stream = l->getExpression();
    545560            Value * index = iBuilder->getInt32(0);
    546561            if (LLVM_UNLIKELY(isa<Extract>(stream))) {
    547                 var = dyn_cast<Var>(cast<Extract>(stream)->getArray());
    548                 index = compileExpression(iBuilder, cast<Extract>(stream)->getIndex());
    549                 if (!var->isKernelParameter() || var->isReadNone()) {
    550                     std::string tmp;
    551                     raw_string_ostream out(tmp);
    552                     out << "Lookahead operation cannot be applied to ";
    553                     stmt->print(out);
    554                     out << " - not an input stream";
    555                     report_fatal_error(out.str());
    556                 }
    557             }
    558             if (LLVM_LIKELY(isa<Var>(stream))) {
    559                 var = cast<Var>(stream);
    560                 if (!var->isKernelParameter() || var->isReadNone()) {
    561                     std::string tmp;
    562                     raw_string_ostream out(tmp);
    563                     out << "Lookahead operation cannot be applied to ";
    564                     stmt->print(out);
    565                     out << ": ";
    566                     var->print(out);
    567                     out << " is not an input stream";
    568                     report_fatal_error(out.str());
    569                 }
     562                var = cast<Var>(cast<Extract>(stream)->getArray());
    570563            }
    571564            const auto bit_shift = (l->getAmount() % iBuilder->getBitBlockWidth());
  • icGREP/icgrep-devel/icgrep/pablo/pe_lookahead.h

    r5454 r5646  
    2424    virtual ~Lookahead() {
    2525    }
    26     inline PabloAST * getExpr() const {
     26    inline PabloAST * getExpression() const {
    2727        return getOperand(0);
    2828    }
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r5371 r5646  
    102102        } else if (const Lookahead * adv = dyn_cast<Lookahead>(stmt)) {
    103103            out << " = pablo.Lookahead(";
    104             print(adv->getExpr(), out);
     104            print(adv->getExpression(), out);
    105105            out << ", " << std::to_string(adv->getAmount()) << ")";
    106106        } else if (const MatchStar * mstar = dyn_cast<MatchStar>(stmt)) {
Note: See TracChangeset for help on using the changeset viewer.