Ignore:
Timestamp:
Jul 23, 2015, 4:47:59 PM (4 years ago)
Author:
nmedfort
Message:

Temporary check in.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/expression_map.hpp

    r4684 r4692  
    9898    friend struct ExpressionTable;
    9999
     100    using Allocator = LLVMAllocator;
     101
    100102    struct Key {
    101         inline Key(PabloAST::ClassTypeId type, unsigned args, PabloAST ** arg) : mType(type), mArgs(args), mArg(arg) {}
     103
     104        inline Key(PabloAST::ClassTypeId type, const PabloAST * arg1, const std::vector<PabloAST *> & args, Allocator & allocator)
     105        : mType(type)
     106        , mArgs(1 + args.size())
     107        , mArg(allocator.Allocate<const PabloAST *>(mArgs)) {
     108            unsigned i = 1;
     109            mArg[0] = arg1;
     110            for (PabloAST * arg : args) {
     111                mArg[i++] = arg;
     112            }
     113        }
     114
    102115        inline Key(const Key & key) = default;
     116
    103117        inline Key(Key && key) = default;
     118
    104119        inline bool operator < (const Key & other) const {
    105             if (mType != other.mType)
     120            if (mType != other.mType) {
    106121                return mType < other.mType;
    107             if (mArgs != other.mArgs)
     122            } else if (mArgs != other.mArgs) {
    108123                return mArgs < other.mArgs;
     124            }
    109125            for (unsigned i = 0; i != mArgs; ++i) {
    110126                if (mArg[i] != other.mArg[i]) {
     
    114130            return false;
    115131        }
    116     private:
    117         PabloAST::ClassTypeId         mType;
    118         unsigned                      mArgs;
    119         PabloAST **                   mArg;
     132
     133        const PabloAST::ClassTypeId   mType;
     134        const unsigned                mArgs;
     135        const PabloAST **             mArg;
    120136    };
    121137
    122     using Allocator = LLVMAllocator;
    123     using MapAllocator = LLVMAllocatorProxy<std::pair<Key, PabloAST *>>;
    124     using Map = std::map<Key, PabloAST *>; // , std::less<Key>, MapAllocator
     138    using Map = std::map<Key, PabloAST *>;
    125139
    126140    explicit VarArgMap(VarArgMap * predecessor = nullptr)
     
    142156
    143157    template <class Functor, typename... Params>
    144     inline PabloAST * findOrCall(Functor && functor, const PabloAST::ClassTypeId type, std::initializer_list<PabloAST *> args, Params... params) {
    145         PabloAST * const f = find(type, args);
     158    inline PabloAST * findOrCall(Functor && functor, const PabloAST::ClassTypeId type, const PabloAST * arg1, const std::vector<PabloAST *> & args, Params... params) {
     159        Key key(type, arg1, args, mAllocator);
     160        PabloAST * const f = find(key);
    146161        if (f) {
     162            mAllocator.Deallocate<const PabloAST *>(key.mArg);
    147163            return f;
    148164        }
    149165        PabloAST * const object = functor(args, std::forward<Params>(params)...);
    150         PabloAST ** const args_copy = mAllocator.Allocate<PabloAST *>(args.size());
    151         std::copy(args.begin(), args.end(), args_copy);
    152         Key key(type, args.size(), args_copy);
    153166        mMap.insert(std::make_pair(std::move(key), object));
    154167        return object;
    155168    }
    156169
    157     inline std::pair<PabloAST *, bool> findOrAdd(PabloAST * object, const PabloAST::ClassTypeId type, std::initializer_list<PabloAST *> args) {
    158         PabloAST * const entry = find(type, args);
     170    inline std::pair<PabloAST *, bool> findOrAdd(PabloAST * object, const PabloAST::ClassTypeId type, PabloAST * arg1, const std::vector<PabloAST *> & args) {
     171        Key key(type, arg1, args, mAllocator);
     172        PabloAST * const entry = find(key);
    159173        if (entry) {
     174            mAllocator.Deallocate<const PabloAST *>(key.mArg);
    160175            return std::make_pair(entry, false);
    161176        }
    162         PabloAST ** const args_copy = mAllocator.Allocate<PabloAST *>(args.size());
    163         std::copy(args.begin(), args.end(), args_copy);
    164         Key key(type, args.size(), args_copy);
    165177        mMap.insert(std::make_pair(std::move(key), object));
    166178        return std::make_pair(object, true);
    167179    }
    168180
    169     inline PabloAST * find(const PabloAST::ClassTypeId type, const std::initializer_list<PabloAST *> args) const {
    170         PabloAST * value[args.size()];
    171         std::copy(args.begin(), args.end(), value);
    172         return find(std::move(Key(type, args.size(), value)));
    173     }
    174 
    175 private:
    176 
    177     inline PabloAST * find(Key && key) const {
     181private:
     182
     183    inline PabloAST * find(const Key & key) const {
    178184        // check this map to see if we have it
    179185        auto itr = mMap.find(key);
     
    196202private:
    197203    VarArgMap *     mPredecessor;
     204    Map             mMap;
    198205    Allocator       mAllocator;
    199     Map             mMap;
    200206};
    201207
     
    207213            mBinary.mPredecessor = &(predecessor->mBinary);
    208214            mTernary.mPredecessor = &(predecessor->mTernary);
    209             mUnaryVariable.mPredecessor = &(predecessor->mUnaryVariable);
     215            mVariable.mPredecessor = &(predecessor->mVariable);
    210216        }
    211217    }
     
    217223    , mBinary(std::move(other.mBinary))
    218224    , mTernary(std::move(other.mTernary))
    219     , mUnaryVariable(std::move(other.mUnaryVariable)) {
     225    , mVariable(std::move(other.mVariable)) {
    220226
    221227    }
     
    225231        mBinary = std::move(other.mBinary);
    226232        mTernary = std::move(other.mTernary);
    227         mUnaryVariable = std::move(other.mUnaryVariable);
     233        mVariable = std::move(other.mVariable);
    228234        return *this;
    229235    }
    230 
    231236
    232237    template <class Functor, typename... Params>
     
    236241
    237242    template <class Functor, typename... Params>
    238     inline PabloAST * findUnaryVariableOrCall(Functor && functor, const PabloAST::ClassTypeId type, PabloAST * expr, const std::vector<PabloAST *> & args, Params... params) {
    239         return mUnaryVariable.findOrCall(std::move(functor), type, expr, args, std::forward<Params>(params)...);
    240     }
    241 
    242     template <class Functor, typename... Params>
    243243    inline PabloAST * findBinaryOrCall(Functor && functor, const PabloAST::ClassTypeId type, PabloAST * expr1, PabloAST * expr2, Params... params) {
    244244        return mBinary.findOrCall(std::move(functor), type, expr1, expr2, std::forward<Params>(params)...);
     
    250250    }
    251251
     252    template <class Functor, typename... Params>
     253    inline PabloAST * findVariableOrCall(Functor && functor, const PabloAST::ClassTypeId type, const PabloAST * arg1, const std::vector<PabloAST *> & args, Params... params) {
     254        return mVariable.findOrCall(std::move(functor), type, arg1, args, std::forward<Params>(params)...);
     255    }
    252256
    253257    std::pair<PabloAST *, bool> findOrAdd(Statement * stmt) {
     
    260264            case PabloAST::ClassTypeId::Or:
    261265            case PabloAST::ClassTypeId::Xor:
    262                 // test whether the communative version of this statement exists
    263                 if (PabloAST * commExpr = mBinary.find(stmt->getClassTypeId(), stmt->getOperand(1), stmt->getOperand(0))) {
    264                     return std::make_pair(commExpr, false);
    265                 }
    266266            case PabloAST::ClassTypeId::Advance:
    267267            case PabloAST::ClassTypeId::ScanThru:
     
    280280
    281281private:
    282     FixedArgMap<PabloAST *>                                     mUnary;
    283     FixedArgMap<PabloAST *, PabloAST *>                         mBinary;
    284     FixedArgMap<PabloAST *, PabloAST *, PabloAST *>             mTernary;
    285     FixedArgMap<PabloAST *, const std::vector<PabloAST *> &>    mUnaryVariable;
     282    FixedArgMap<PabloAST *>                             mUnary;
     283    FixedArgMap<PabloAST *, PabloAST *>                 mBinary;
     284    FixedArgMap<PabloAST *, PabloAST *, PabloAST *>     mTernary;
     285    VarArgMap                                           mVariable;
    286286};
    287287
Note: See TracChangeset for help on using the changeset viewer.