Ignore:
Timestamp:
Jul 18, 2015, 10:18:34 AM (4 years ago)
Author:
nmedfort
Message:

First attempt to intergrate 'generate_predefined_ucd_functions' into build process.

File:
1 edited

Legend:

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

    r4681 r4684  
    33
    44#include <pablo/pabloAST.h>
    5 #include <llvm/ADT/ArrayRef.h>
     5#include <slab_allocator.h>
    66#include <map>
    77
     
    9393};
    9494
     95
     96struct VarArgMap {
     97
     98    friend struct ExpressionTable;
     99
     100    struct Key {
     101        inline Key(PabloAST::ClassTypeId type, unsigned args, PabloAST ** arg) : mType(type), mArgs(args), mArg(arg) {}
     102        inline Key(const Key & key) = default;
     103        inline Key(Key && key) = default;
     104        inline bool operator < (const Key & other) const {
     105            if (mType != other.mType)
     106                return mType < other.mType;
     107            if (mArgs != other.mArgs)
     108                return mArgs < other.mArgs;
     109            for (unsigned i = 0; i != mArgs; ++i) {
     110                if (mArg[i] != other.mArg[i]) {
     111                    return mArg[i] < other.mArg[i];
     112                }
     113            }
     114            return false;
     115        }
     116    private:
     117        PabloAST::ClassTypeId         mType;
     118        unsigned                      mArgs;
     119        PabloAST **                   mArg;
     120    };
     121
     122    using Allocator = LLVMAllocator;
     123    using MapAllocator = LLVMAllocatorProxy<std::pair<Key, PabloAST *>>;
     124    using Map = std::map<Key, PabloAST *>; // , std::less<Key>, MapAllocator
     125
     126    explicit VarArgMap(VarArgMap * predecessor = nullptr)
     127    : mPredecessor(predecessor) {
     128
     129    }
     130
     131    explicit VarArgMap(VarArgMap && other) noexcept
     132    : mPredecessor(other.mPredecessor)
     133    , mMap(std::move(other.mMap)) {
     134
     135    }
     136
     137    VarArgMap & operator=(VarArgMap && other) {
     138        mPredecessor = other.mPredecessor;
     139        mMap = std::move(other.mMap);
     140        return *this;
     141    }
     142
     143    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);
     146        if (f) {
     147            return f;
     148        }
     149        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);
     153        mMap.insert(std::make_pair(std::move(key), object));
     154        return object;
     155    }
     156
     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);
     159        if (entry) {
     160            return std::make_pair(entry, false);
     161        }
     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);
     165        mMap.insert(std::make_pair(std::move(key), object));
     166        return std::make_pair(object, true);
     167    }
     168
     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
     175private:
     176
     177    inline PabloAST * find(Key && key) const {
     178        // check this map to see if we have it
     179        auto itr = mMap.find(key);
     180        if (itr != mMap.end()) {
     181            return itr->second;
     182        }
     183        // check any previous maps to see if it exists
     184        auto * pred = mPredecessor;
     185        while (pred) {
     186            itr = pred->mMap.find(key);
     187            if (itr == pred->mMap.end()) {
     188                pred = pred->mPredecessor;
     189                continue;
     190            }
     191            return itr->second;
     192        }
     193        return nullptr;
     194    }
     195
     196private:
     197    VarArgMap *     mPredecessor;
     198    Allocator       mAllocator;
     199    Map             mMap;
     200};
     201
    95202struct ExpressionTable {
    96203
     
    125232    template <class Functor, typename... Params>
    126233    inline PabloAST * findUnaryOrCall(Functor && functor, const PabloAST::ClassTypeId type, PabloAST * expr, Params... params) {
    127         return mUnary.findOrCall(std::move(functor), type, expr, std::forward<Params>(params)...);
     234        return mUnary.findOrCall(std::move(functor), type,  expr , std::forward<Params>(params)...);
    128235    }
    129236
Note: See TracChangeset for help on using the changeset viewer.