Ignore:
Timestamp:
Dec 3, 2017, 12:40:40 PM (19 months ago)
Author:
nmedfort
Message:

Bug fixes and simplified MultiBlockKernel? logic

Location:
icGREP/icgrep-devel/icgrep/re
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r5730 r5755  
    3030#include "cc/cc_compiler.h"         // for CC_Compiler
    3131#include "pablo/builder.hpp"        // for PabloBuilder
    32 #include "toolchain/toolchain.h"    // for AVX2_available
     32#include <IR_Gen/idisa_target.h>    // for AVX2_available
    3333#include <llvm/Support/ErrorHandling.h>
    3434
  • icGREP/icgrep-devel/icgrep/re/re_minimizer.cpp

    r5646 r5755  
    2121using Set = boost::container::flat_set<RE *>;
    2222using Map = boost::container::flat_map<RE *, RE *>;
     23using List = std::vector<RE *>;
    2324
    2425struct PassContainer : private Memoizer {
     
    3132        RE * re = original;
    3233repeat: if (Alt * alt = dyn_cast<Alt>(re)) {
    33             Set list;
    34             list.reserve(alt->size());
     34            Set set;
     35            set.reserve(alt->size());
    3536            RE * namedCC = nullptr;
    3637            bool repeat = false;
    3738            for (RE * item : *alt) {
    3839                item = minimize(item);
    39                 if (LLVM_UNLIKELY(isa<Vector>(item) && cast<Vector>(item)->empty())) {
    40                     continue;
    41                 } else if (LLVM_UNLIKELY(isa<Alt>(item))) {
     40                if (LLVM_UNLIKELY(isa<Alt>(item))) {
     41                    if (LLVM_UNLIKELY(cast<Alt>(item)->empty())) {
     42                        continue;
     43                    }
    4244                    repeat = true;
    4345                } else { // if we have an alternation containing multiple CCs, combine them
     
    4850                    }
    4951                }
    50                 list.insert(item);
     52                set.insert(item);
    5153            }
    5254            // Combine and/or insert any named CC object into the alternation
     
    5557                    namedCC = memoize(cast<CC>(namedCC));
    5658                }
    57                 list.insert(cast<Name>(namedCC));
     59                set.insert(cast<Name>(namedCC));
    5860            }
    5961            // Pablo CSE may identify common prefixes but cannot identify common suffixes.
    60             extractCommonSuffixes(list);
    61             extractCommonPrefixes(list);
    62             re = makeAlt(list.begin(), list.end());
     62            extractCommonSuffixes(set);
     63            extractCommonPrefixes(set);
     64            re = makeAlt(set.begin(), set.end());
    6365            if (LLVM_UNLIKELY(repeat)) {
    6466                goto repeat;
    6567            }
    6668        } else if (Seq * seq = dyn_cast<Seq>(re)) {
    67             std::vector<RE *> list;
     69            List list;
    6870            list.reserve(seq->size());
    6971            bool repeat = false;
    7072            for (RE * item : *seq) {
    7173                item = minimize(item);
    72                 if (LLVM_UNLIKELY(isa<Vector>(item) && cast<Vector>(item)->empty())) {
    73                     continue;
    74                 } else if (LLVM_UNLIKELY(isa<Seq>(item))) {
     74                if (LLVM_UNLIKELY(isa<Seq>(item))) {
     75                    if (LLVM_UNLIKELY(cast<Seq>(item)->empty())) {
     76                        continue;
     77                    }
    7578                    repeat = true;
    7679                }
     
    129132
    130133    void extractCommonPrefixes(Set & source) {
    131         std::vector<RE *> combine;
    132 restart:if (LLVM_UNLIKELY(source.size() < 2)) {
     134        List combine;
     135repeat: if (LLVM_UNLIKELY(source.size() < 2)) {
    133136            return;
    134137        }
    135138        for (auto i = source.begin(); i != source.end(); ++i) {
    136             assert (combine.empty());           
     139            assert (combine.empty());
    137140            RE * const head = getHead(*i);
    138141            for (auto j = i + 1; j != source.end(); ) {
     
    178181                }
    179182                source.insert(minimize(makeSeq({ head, tail })));
    180                 goto restart;
     183                goto repeat;
    181184            }
    182185        }
     
    184187
    185188    void extractCommonSuffixes(Set & source) {
    186         std::vector<RE *> combine;
    187 restart:if (LLVM_UNLIKELY(source.size() < 2)) {
     189        List combine;
     190repeat: if (LLVM_UNLIKELY(source.size() < 2)) {
    188191            return;
    189192        }
     
    235238                }
    236239                source.insert(minimize(makeSeq({ head, tail })));
    237                 goto restart;
     240                goto repeat;
    238241            }
    239242        }
  • icGREP/icgrep-devel/icgrep/re/re_re.h

    r5750 r5755  
    4747    }
    4848    const ClassTypeId mClassTypeId;
    49 
    5049    static Allocator mAllocator;
    5150};
  • icGREP/icgrep-devel/icgrep/re/re_simplifier.cpp

    r5723 r5755  
    1414namespace re {
    1515
     16using Set = boost::container::flat_set<RE *>;
     17using List = std::vector<RE *>;
     18
    1619struct PassContainer {
    1720    RE * simplify(RE * re) {
    1821        if (Alt * alt = dyn_cast<Alt>(re)) {
    19             boost::container::flat_set<RE *> list;
    20             list.reserve(alt->size());
     22            Set set;
     23            set.reserve(alt->size());
    2124            for (RE * item : *alt) {
    2225                item = simplify(item);
     
    2427                    continue;
    2528                }
    26                 list.insert(item);
     29                set.insert(item);
    2730            }
    28             re = makeAlt(list.begin(), list.end());
     31            re = makeAlt(set.begin(), set.end());
    2932        } else if (Seq * seq = dyn_cast<Seq>(re)) {
    30             std::vector<RE *> list;
     33            List list;
    3134            list.reserve(seq->size());
    3235            for (RE * item : *seq) {
Note: See TracChangeset for help on using the changeset viewer.