Ignore:
Timestamp:
Oct 5, 2014, 5:27:31 PM (5 years ago)
Author:
nmedfort
Message:

Partial implementation of 'PabloBuilder?'.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4213 r4214  
    2626#include <pablo/ps_if.h>
    2727#include <pablo/ps_while.h>
     28#include <pablo/symbol_generator.h>
    2829#include <unordered_map>
    2930#include <vector>
    3031#include <string>
    3132#include <array>
    32 #include <pablo/symbol_generator.h>
     33#include <tuple>
    3334
    3435namespace pablo {
     
    3839    CodeGenState(SymbolGenerator & symgen)
    3940    : mSymbolGenerator(symgen)
    40     , mPredecessor(nullptr)
    4141    , mAll{{makeAll(0), makeAll(1)}}
     42    , mUnary(nullptr, this)
     43    , mBinary(nullptr, this)
     44    , mTernary(nullptr, this)
    4245    {
    4346
     
    4649    CodeGenState(CodeGenState & cg)
    4750    : mSymbolGenerator(cg.mSymbolGenerator)
    48     , mPredecessor(&cg)
    4951    , mAll(cg.mAll)    // inherit the original "All" variables for simplicity
     52    , mUnary(&(cg.mUnary), this)
     53    , mBinary(&(cg.mBinary), this)
     54    , mTernary(&(cg.mTernary), this)
    5055    {
    5156
    5257    }
     58
     59    Advance * createAdvance(PabloE * expr);
    5360
    5461    inline All * createAll(const bool value) const {
     
    5663    }
    5764
     65    Assign * createAssign(const std::string name, PabloE * expr);
     66
    5867    Call * createCall(const std::string name);
    59 
    60     Var * createVar(const Assign * assign);
    6168
    6269    Var * createVar(const std::string name);
    6370
     71    Var * createVar(Assign * assign);
     72
    6473    inline PabloE * createVarIfAssign(PabloE * const input) {
    65         return isa<Assign>(input) ? createVar(cast<const Assign>(input)) : input;
     74        return isa<Assign>(input) ? createVar(cast<Assign>(input)) : input;
    6675    }
    6776
    6877    CharClass * createCharClass(const std::string name);
    69     Assign * createAssign(const std::string name, PabloE * expr);
    7078
    71 //    PabloE * createAdvance(PabloE * expr);
    72 //    PabloE * createNot(PabloE * expr);
    73 //    PabloE * createCall(const std::string name);
    74 //    PabloE * createVar(const std::string name);
    75 //    PabloE * createCharClass(const std::string name);
    76 //    PabloE * createAssign(const std::string name, PabloE * expr);
    77 //    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
    78 //    PabloE * createOr(PabloE * expr1, PabloE * expr2);
    79 //    PabloE * createXor(PabloE * expr1, PabloE * expr2);
    80 //    PabloE * createMatchStar(PabloE * expr1, PabloE * expr2);
    81 //    PabloE * createScanThru(PabloE * from, PabloE * thru);
     79    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
    8280
     81    PabloE * createNot(PabloE * expr);
    8382
     83    PabloE * createOr(PabloE * expr1, PabloE * expr2);
    8484
    85 //    struct ExpressionTable {
    86 //        inline PabloE * find(PabloE * inst) {
    87 //            switch(inst->getClassTypeId()) {
    88 //                // UNARY
    89 //                case All:       // bool
    90 //                case Advance:   // pe
    91 //                case Not:       // pe
     85    PabloE * createXor(PabloE * expr1, PabloE * expr2);
    9286
    93 //                case Call:      // string
    94 //                case Var:       // string
    95 //                case CharClass: // string
    96 //                // BINARY
    97 //                case Assign:    // string, pe
     87    MatchStar * createMatchStar(PabloE * expr1, PabloE * expr2);
    9888
    99 //                case And:       // pe, pe
    100 //                case Or:        // pe, pe
    101 //                case Xor:       // pe, pe
    102 //                case MatchStar: // pe, pe
    103 //                case ScanThru:  // pe, pe
     89    ScanThru * createScanThru(PabloE * from, PabloE * thru);
    10490
    105 //                case If:        // pe, pe list
    106 //                case While:     // pe, pe list
    107 //                // TERNARY
    108 //                case Sel:       // pe, pe, pe
    109 //            }
     91    PabloE * createSel(PabloE * condition, PabloE * trueExpr, PabloE * falseExpr);
    11092
     93    template<typename... Args>
     94    struct ExpressionMap {
     95        typedef ExpressionMap<Args...> MapType;
     96        typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
    11197
    112 //            switch (inst.getNumOperands()) {
    113 //                case 1: return _unary.find(&inst, inst.getType(), inst.getOperand(0));
    114 //                case 2: return _binary.find(&inst, inst.getOperand(0), inst.getOperand(1));
    115 //                case 3: return _ternary.find(&inst, inst.getOperand(0), inst.getOperand(1), inst.getOperand(2));
    116 //                default: return nullptr;
    117 //            }
    118 //        }
    119 //    private:
    120 //        template<typename... Args>
    121 //        struct ExpressionMap {
    122 //            typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
    123 //            inline Instruction * find(Instruction * inst, Args... args) {
    124 //                auto key = std::make_tuple(inst->getOpcode(), args...);
    125 //                auto itr = _map.find(key);
    126 //                if (itr == _map.end()) {
    127 //                    _map.insert(std::make_pair(std::move(key), inst));
    128 //                    return nullptr;
    129 //                }
    130 //                return itr->second;
    131 //            }
    132 //        private:
    133 //            std::unordered_map<Key, PabloE *>                           _map;
    134 //        };
    135 //        ExpressionMap<const PabloE *>                                   _unary;
    136 //        ExpressionMap<const PabloE *, const PabloE *>                   _binary;
    137 //        ExpressionMap<const PabloE *, const PabloE *, const PabloE *>   _ternary;
    138 //    };
     98        inline ExpressionMap(MapType * predecessor, CodeGenState * parent)
     99        : mPredecessor(predecessor)
     100        , mCodeGenState(*parent)
     101        {
    139102
    140 //    template<typename... Args>
    141 //    struct ExpressionMap {
    142 //        typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
     103        }
    143104
    144 //        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
    145 //            auto key = std::make_tuple(type, args...);
    146 //            auto itr = _map.find(key);
    147 //            if (itr == _map.end()) {
    148 //                _map.insert(std::make_pair(std::move(key), inst));
    149 //                return nullptr;
    150 //            }
    151 //            return itr->second;
    152 //        }
     105        template <class Type>
     106        inline Type * findOrMake(const PabloE::ClassTypeId type, Args... args) {
     107            auto key = std::make_tuple(type, args...);
     108            PabloE * f = find(key);
     109            if (f) {
     110                return cast<Type>(f);
     111            }
     112            Type * expr = new Type(args...);
     113            mMap.insert(std::make_pair(std::move(key), expr));
     114            return expr;
     115        }
    153116
    154 //        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
    155 //            auto key = std::make_tuple(type, args...);
    156 //            auto itr = _map.find(key);
    157 //            if (itr == _map.end()) {
    158 //                _map.insert(std::make_pair(std::move(key), inst));
    159 //                return nullptr;
    160 //            }
    161 //            return itr->second;
    162 //        }
     117        template <class Functor>
     118        inline PabloE * findOrCall(const PabloE::ClassTypeId type, Args... args) {
     119            auto key = std::make_tuple(type, args...);
     120            PabloE * f = find(key);
     121            if (f) {
     122                return f;
     123            }
     124            Functor mf(mCodeGenState);
     125            PabloE * expr = mf(args...);
     126            mMap.insert(std::make_pair(std::move(key), expr));
     127            return expr;
     128        }
    163129
    164 //    private:
    165 //        std::unordered_map<Key, PabloE *> _map;
    166 //    };
     130    private:
    167131
     132        inline PabloE * find(const Key & key) {
     133            // check this map to see if we have it
     134            auto itr = mMap.find(key);
     135            if (itr != mMap.end()) {
     136                return itr->second;
     137            }
     138            // check any previous maps to see if it exists
     139            auto * pred = mPredecessor;
     140            while (pred) {
     141                itr = pred->mMap.find(key);
     142                if (itr == pred->mMap.end()) {
     143                    pred = pred->mPredecessor;
     144                    continue;
     145                }
     146                return itr->second;
     147            }
     148            return nullptr;
     149        }
    168150
     151    private:
     152        MapType * const         mPredecessor;
     153        CodeGenState &          mCodeGenState;
     154        std::map<Key, PabloE *> mMap;
     155    };
    169156
    170157    inline void push_back(PabloE * expr) {
     
    172159    }
    173160
    174     inline std::string symgen(std::string prefix) {
    175         return mSymbolGenerator.get(prefix);
     161    inline std::string ssa(std::string prefix) { // Static Single-Assignment
     162        return mSymbolGenerator.ssa(prefix);
    176163    }
    177164
     
    180167    }
    181168
    182 protected:
    183 
    184     String * getString(const std::string string);
    185 
    186169private:   
    187     SymbolGenerator &                           mSymbolGenerator;
    188     CodeGenState * const                        mPredecessor;
    189     const std::array<All *, 2>                  mAll;
    190     std::unordered_map<std::string, String *>   mStringMap;
    191 
    192 
    193     std::list<PabloE *>                         mExpressions;
     170    SymbolGenerator &                               mSymbolGenerator;
     171    const std::array<All *, 2>                      mAll;
     172    ExpressionMap<PabloE *>                         mUnary;
     173    ExpressionMap<PabloE *, PabloE *>               mBinary;
     174    ExpressionMap<PabloE *, PabloE *, PabloE *>     mTernary;
     175    std::list<PabloE *>                             mExpressions;
    194176};
    195177
Note: See TracChangeset for help on using the changeset viewer.