Ignore:
Timestamp:
Aug 6, 2015, 3:39:27 PM (4 years ago)
Author:
cameron
Message:

Mod64 approximation mode

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

Legend:

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

    r4715 r4716  
    1818        if (Advance * adv = dyn_cast<Advance>(stmt)) {
    1919            unsigned shift_amount = adv->getAdvanceAmount();
    20             if (shift_amount == 1) {
    21                 adv->setLocalAdvanceIndex(advance1.entries);
    22                 advance1.entries++;               
    23             }
    24             else if (shift_amount < LongAdvanceBase) {
    25                 // short Advance
    26                 if (mITEMS_PER_PACK >= LongAdvanceBase) {
    27                     // Packing is possible.   We will use the allocated bit position as
    28                     // the index.
    29                     if (roomInFinalPack(shortAdvance.allocatedBits) < shift_amount) {
    30                         // Start a new pack.
    31                         shortAdvance.allocatedBits = alignCeiling(shortAdvance.allocatedBits, mPACK_SIZE);
     20            if (!adv->isMod64()) {
     21                if (shift_amount == 1) {
     22                    adv->setLocalAdvanceIndex(advance1.entries);
     23                    advance1.entries++;               
     24                }
     25                else if (shift_amount < LongAdvanceBase) {
     26                    // short Advance
     27                    if (mITEMS_PER_PACK >= LongAdvanceBase) {
     28                        // Packing is possible.   We will use the allocated bit position as
     29                        // the index.
     30                        if (roomInFinalPack(shortAdvance.allocatedBits) < shift_amount) {
     31                            // Start a new pack.
     32                            shortAdvance.allocatedBits = alignCeiling(shortAdvance.allocatedBits, mPACK_SIZE);
     33                        }
     34                        adv->setLocalAdvanceIndex(shortAdvance.allocatedBits);
    3235                    }
    33                     adv->setLocalAdvanceIndex(shortAdvance.allocatedBits);
     36                    else {
     37                        adv->setLocalAdvanceIndex(shortAdvance.entries);
     38                    }
     39                    shortAdvance.entries++;
     40                    shortAdvance.allocatedBits += shift_amount;
    3441                }
    3542                else {
    36                     adv->setLocalAdvanceIndex(shortAdvance.entries);
     43                    adv->setLocalAdvanceIndex(longAdvance.allocatedBitBlocks);
     44                    longAdvance.entries++;
     45                    longAdvance.allocatedBitBlocks += longAdvanceBufferSize(shift_amount);
    3746                }
    38                 shortAdvance.entries++;
    39                 shortAdvance.allocatedBits += shift_amount;
    40             }
    41             else {
    42                 adv->setLocalAdvanceIndex(longAdvance.allocatedBitBlocks);
    43                 longAdvance.entries++;
    44                 longAdvance.allocatedBitBlocks += longAdvanceBufferSize(shift_amount);
    4547            }
    4648        }
    4749        else if (MatchStar * m = dyn_cast<MatchStar>(stmt)) {
    48             m->setLocalCarryIndex(addWithCarry.entries);
    49             ++addWithCarry.entries;
     50            if (!m->isMod64()) {
     51                m->setLocalCarryIndex(addWithCarry.entries);
     52                ++addWithCarry.entries;
     53            }
    5054        }
    5155        else if (ScanThru * s = dyn_cast<ScanThru>(stmt)) {
    52             s->setLocalCarryIndex(addWithCarry.entries);
    53             ++addWithCarry.entries;
     56            if (!s->isMod64()) {
     57                s->setLocalCarryIndex(addWithCarry.entries);
     58                ++addWithCarry.entries;
     59            }
    5460        }
    5561    }
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4710 r4716  
    603603        Value* strm_value = compileExpression(adv->getExpr());
    604604        int shift = adv->getAdvanceAmount();
    605         unsigned advance_index = adv->getLocalAdvanceIndex();
    606         expr = mCarryManager->advanceCarryInCarryOut(advance_index, shift, strm_value);
     605        if (adv->isMod64()) {
     606            expr = iBuilder.simd_slli(64, strm_value, shift);
     607        }
     608        else {
     609            unsigned advance_index = adv->getLocalAdvanceIndex();
     610            expr = mCarryManager->advanceCarryInCarryOut(advance_index, shift, strm_value);
     611        }
    607612    }
    608613    else if (const MatchStar * mstar = dyn_cast<MatchStar>(stmt)) {
     
    610615        Value * cc = compileExpression(mstar->getCharClass());
    611616        Value * marker_and_cc = mBuilder->CreateAnd(marker, cc);
    612         unsigned carry_index = mstar->getLocalCarryIndex();
    613         Value * sum = mCarryManager->addCarryInCarryOut(carry_index, marker_and_cc, cc);
     617        Value * sum = nullptr;
     618        if (mstar->isMod64()) {
     619            sum = iBuilder.simd_add(64, marker_and_cc, cc);
     620        }
     621        else {
     622            unsigned carry_index = mstar->getLocalCarryIndex();
     623            sum = mCarryManager->addCarryInCarryOut(carry_index, marker_and_cc, cc);
     624        }
    614625        expr = mBuilder->CreateOr(mBuilder->CreateXor(sum, cc), marker, "matchstar");
    615626    }
     
    617628        Value * marker_expr = compileExpression(sthru->getScanFrom());
    618629        Value * cc_expr = compileExpression(sthru->getScanThru());
    619         unsigned carry_index = sthru->getLocalCarryIndex();
    620         Value * sum = mCarryManager->addCarryInCarryOut(carry_index, marker_expr, cc_expr);
     630        Value * sum = nullptr;
     631        if (sthru->isMod64()) {
     632            sum = iBuilder.simd_add(64, marker_expr, cc_expr);
     633        }
     634        else {
     635            unsigned carry_index = sthru->getLocalCarryIndex();
     636            sum = mCarryManager->addCarryInCarryOut(carry_index, marker_expr, cc_expr);
     637        }
    621638        expr = mBuilder->CreateAnd(sum, genNot(cc_expr), "scanthru");
    622639    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4699 r4716  
    3737        return localAdvanceIndex;
    3838    }
     39    inline void setMod64() {
     40        isMod64approx = true;
     41    }
     42    inline bool isMod64() const {
     43        return isMod64approx;
     44    }
    3945protected:
    4046    Advance(PabloAST * expr, PabloAST * shiftAmount, String * name)
    4147    : Statement(ClassTypeId::Advance, {expr, shiftAmount}, name)
     48   , isMod64approx(false)
    4249    {
    4350        assert(isa<Integer>(shiftAmount));
    4451    }
    4552private:
     53    bool isMod64approx;
    4654    unsigned localAdvanceIndex;
    4755};
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4650 r4716  
    3333        return localCarryIndex;
    3434    }
     35    inline void setMod64() {
     36        isMod64approx = true;
     37    }
     38    inline bool isMod64() const {
     39        return isMod64approx;
     40    }
    3541    virtual ~MatchStar() {}
    3642protected:
    3743    MatchStar(PabloAST * marker, PabloAST * cc, String * name)
    3844    : Statement(ClassTypeId::MatchStar, {marker, cc}, name)
     45    , isMod64approx(false)
    3946    {
    4047
    4148    }
    4249private:
     50    bool isMod64approx;
    4351    unsigned localCarryIndex;
    4452};
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4650 r4716  
    3535        return localCarryIndex;
    3636    }
     37    inline void setMod64() {
     38        isMod64approx = true;
     39    }
     40    inline bool isMod64() const {
     41        return isMod64approx;
     42    }
    3743protected:
    3844    ScanThru(PabloAST * from, PabloAST * thru, String * name)
    3945    : Statement(ClassTypeId::ScanThru, {from, thru}, name)
     46    , isMod64approx(false)
    4047    {
    4148
    4249    }
    4350private:
     51    bool isMod64approx;
    4452    unsigned localCarryIndex;
    4553};
Note: See TracChangeset for help on using the changeset viewer.