source: icGREP/icgrep-devel/icgrep/pablo/expression_map.hpp @ 4432

Last change on this file since 4432 was 4432, checked in by nmedfort, 5 years ago

Temporary check in.

File size: 3.9 KB
Line 
1#ifndef EXPRESSION_MAP_HPP
2#define EXPRESSION_MAP_HPP
3
4#include <map>
5#include <tuple>
6#include <pablo/pabloAST.h>
7
8namespace pablo {
9
10template<typename... Args>
11struct ExpressionMap {
12    enum {N = sizeof...(Args)};
13    typedef ExpressionMap<Args...> MapType;
14    typedef std::tuple<PabloAST::ClassTypeId, Args...> Key;
15
16    inline ExpressionMap(MapType * predecessor)
17    : mPredecessor(predecessor)
18    {
19
20    }
21
22    inline std::pair<PabloAST *, bool> insert(PabloAST * object, const PabloAST::ClassTypeId type, Args... args) {
23        Key key = std::make_tuple(type, args...);
24        PabloAST * const entry = find(key);
25        if (entry) {
26            return std::make_pair(entry, false);
27        }
28        mMap.insert(std::make_pair(std::move(key), object));
29        return std::make_pair(object, true);
30    }
31
32    inline bool erase(const PabloAST::ClassTypeId type, Args... args) {
33        Key key = std::make_tuple(type, args...);
34        auto itr = mMap.find(key);
35        if (itr == mMap.end()) {
36            return mPredecessor ? mPredecessor->erase(type, args...) : false;
37        }
38        mMap.erase(itr);
39        return true;
40    }
41
42    inline PabloAST * find(const PabloAST::ClassTypeId type, Args... args) const {
43        Key key = std::make_tuple(type, args...);
44        return find(key);
45    }
46
47private:
48
49    inline PabloAST * find(const Key & key) const {
50        // check this map to see if we have it
51        auto itr = mMap.find(key);
52        if (itr != mMap.end()) {
53            return itr->second;
54        }
55        // check any previous maps to see if it exists
56        auto * pred = mPredecessor;
57        while (pred) {
58            itr = pred->mMap.find(key);
59            if (itr == pred->mMap.end()) {
60                pred = pred->mPredecessor;
61                continue;
62            }
63            return itr->second;
64        }
65        return nullptr;
66    }
67
68private:
69    MapType * const             mPredecessor;
70    std::map<Key, PabloAST *>   mMap;
71};
72
73struct ExpressionTable {
74
75    ExpressionTable()
76    : mUnary(nullptr)
77    , mBinary(nullptr)
78    , mTernary(nullptr)
79    {
80
81    }
82
83    ExpressionTable(ExpressionTable * predecessor)
84    : mUnary(predecessor ? &(predecessor->mUnary) : nullptr)
85    , mBinary(predecessor ? &(predecessor->mBinary) : nullptr)
86    , mTernary(predecessor ? &(predecessor->mTernary) : nullptr)
87    {
88
89    }
90
91    std::pair<PabloAST *, bool> insert(Statement * stmt) {
92        switch (stmt->getClassTypeId()) {           
93            case PabloAST::ClassTypeId::Assign:
94            case PabloAST::ClassTypeId::Call:
95            case PabloAST::ClassTypeId::Var:
96            case PabloAST::ClassTypeId::Not:
97                return mUnary.insert(stmt, stmt->getClassTypeId(), stmt->getOperand(0));
98            case PabloAST::ClassTypeId::And:
99            case PabloAST::ClassTypeId::Or:
100            case PabloAST::ClassTypeId::Xor:
101                // test whether the communative version of this statement exists
102                if (PabloAST * commExpr = mBinary.find(stmt->getClassTypeId(), stmt->getOperand(1), stmt->getOperand(0))) {
103                    return std::make_pair(commExpr, false);
104                }
105            case PabloAST::ClassTypeId::Advance:
106            case PabloAST::ClassTypeId::ScanThru:
107            case PabloAST::ClassTypeId::MatchStar:
108            case PabloAST::ClassTypeId::Next:
109                return mBinary.insert(stmt, stmt->getClassTypeId(), stmt->getOperand(0), stmt->getOperand(1));
110            case PabloAST::ClassTypeId::Sel:
111                return mTernary.insert(stmt, stmt->getClassTypeId(), stmt->getOperand(0), stmt->getOperand(1), stmt->getOperand(2));
112            default:
113                return std::make_pair(stmt, true);
114        }
115    }
116
117
118private:
119    ExpressionMap<PabloAST *>                           mUnary;
120    ExpressionMap<PabloAST *, PabloAST *>               mBinary;
121    ExpressionMap<PabloAST *, PabloAST *, PabloAST *>   mTernary;
122};
123
124}
125
126#endif // EXPRESSION_MAP_HPP
Note: See TracBrowser for help on using the repository browser.