Ignore:
Timestamp:
Aug 28, 2017, 4:00:17 PM (22 months ago)
Author:
nmedfort
Message:

Bug fixes for multigrep mode. Optional PabloKernel? branch hit counter added. Minor optimizations.

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

Legend:

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

    r5617 r5620  
    7272   
    7373MarkerType RE_Compiler::compile_local(RE * re, MarkerType marker, PabloBuilder & pb) {
    74     UCD::UnicodeSet* first = RE_Local::first(re);
    75     PabloAST * pablo_first = mCCCompiler.compileCC(makeCC(std::move(*first)));
    76     UCD::UnicodeSet* final = RE_Local::final(re);
    77     PabloAST * pablo_final = mCCCompiler.compileCC(makeCC(std::move(*final)));
    78     std::map<UCD::UnicodeSet*, UCD::UnicodeSet*> follow_map;
    79     RE_Local::follow(re, follow_map);
     74    CC * first = RE_Local::first(re);
     75    CC * final = RE_Local::final(re);
    8076
    8177    if (first == nullptr || final == nullptr) {
     
    8379        return process(re, marker, pb);
    8480    }
     81
     82    PabloAST * pablo_first = mCCCompiler.compileCC(first);
     83    PabloAST * pablo_final = mCCCompiler.compileCC(final);
     84    std::map<CC*, CC*> follow_map;
     85    RE_Local::follow(re, follow_map);
    8586
    8687    PabloAST * pablo_follow = pb.createZeroes();
  • icGREP/icgrep-devel/icgrep/re/re_local.cpp

    r5619 r5620  
    113113}
    114114
    115 void RE_Local::follow(RE * re, std::map<UCD::UnicodeSet*, UCD::UnicodeSet*> &follow_map) {
     115void RE_Local::follow(RE * re, std::map<CC *, CC*> &follow_map) {
    116116    if (Name * name = dyn_cast<Name>(re)) {
    117117        if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     
    122122    } else if (Seq * seq = dyn_cast<Seq>(re)) {
    123123        RE * re_first = *(seq->begin());
    124         std::vector<RE *> list;
    125         list.reserve(seq->size());
    126         for (auto i = seq->begin() + 1; i != seq->end(); i++) {
    127             list.push_back(*i);
    128         }
    129         RE * re_follow = makeSeq(list.begin(), list.end());
     124        RE * re_follow = makeSeq(seq->begin() + 1, seq->end());
    130125        auto e1 = final(re_first);
    131126        auto e2 = first(re_follow);
     
    133128            auto e = follow_map.find(e1);
    134129            if (e != follow_map.end()) {
    135                 *(e->second) = *(e->second) + *e2;
     130                e->second = makeCC(e->second, e2);
    136131            } else {
    137                 follow_map.insert(std::pair<UCD::UnicodeSet*, UCD::UnicodeSet*>(e1, e2));
     132                follow_map.emplace(e1, e2);
    138133            }
    139134        }
    140135        follow(re_first, follow_map);
    141136        follow(re_follow, follow_map);
    142         return;
    143137    } else if (Alt * alt = dyn_cast<Alt>(re)) {
    144138        for (auto ai = alt->begin(); ai != alt->end(); ++ai) {
    145139            follow(*ai, follow_map);
    146140        }
    147         return;
    148141    } else if (Rep * rep = dyn_cast<Rep>(re)) {
    149142        auto e1 = final(rep->getRE());
     
    152145            auto e = follow_map.find(e1);
    153146            if (e != follow_map.end()) {
    154                 *(e->second) = *(e->second) + *e2;
     147                e->second = makeCC(e->second, e2);
    155148            } else {
    156                 follow_map.insert(std::pair<UCD::UnicodeSet*, UCD::UnicodeSet*>(e1, e2));
     149                follow_map.emplace(e1, e2);
    157150            }
    158151        }
    159152        follow(rep->getRE(), follow_map);
    160         return;
    161     }
    162     return;
     153    }
    163154}
    164155
  • icGREP/icgrep-devel/icgrep/re/re_local.h

    r5619 r5620  
    1313    static CC * first(RE * re);
    1414    static CC * final(RE * re);
    15         static void follow(RE * re, std::map<UCD::UnicodeSet*, UCD::UnicodeSet*> &follow_map);
     15    static void follow(RE * re, std::map<CC*, CC*> &follow_map);
    1616        static bool isLocalLanguage(RE * re);
    1717private:
  • icGREP/icgrep-devel/icgrep/re/re_multiplex.cpp

    r5619 r5620  
    1616#include <sstream>
    1717#include <iostream>
     18#include <functional>
    1819
    1920using namespace boost::container;
     
    3132}
    3233
    33 Memoizer                mMemoizer_multiplex;
    34    
    3534RE * multiplex(RE * const re,
    3635               const std::vector<UCD::UnicodeSet> & UnicodeSets,
    37                const std::vector<std::vector<unsigned>> & exclusiveSetIDs,
    38                const std::vector<UCD::UnicodeSet> & multiplexedCCs) {
    39     if (Name * name = dyn_cast<Name>(re)) {
    40         auto f = mMemoizer_multiplex.find(name);
    41         if (f == mMemoizer_multiplex.end()) {
    42             if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    43                 if (CC * cc = dyn_cast<CC>(name->getDefinition())) {
    44                     UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
    45                     auto index = find(UnicodeSets.begin(), UnicodeSets.end(), *sets) - UnicodeSets.begin();
    46                     auto exclusive_IDs = exclusiveSetIDs[index];
    47                     CC * CC_union = makeCC();
    48                     for (auto i : exclusive_IDs) {
    49                         CC_union = makeCC(CC_union, makeCC(i));
     36               const std::vector<std::vector<unsigned>> & exclusiveSetIDs) {
     37
     38    Memoizer memoizer;
     39
     40    std::function<RE *(RE *)> multiplex = [&](RE * const re) -> RE * {
     41        if (Name * name = dyn_cast<Name>(re)) {
     42            auto f = memoizer.find(name);
     43            if (f == memoizer.end()) {
     44                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     45                    if (CC * cc = dyn_cast<CC>(name->getDefinition())) {
     46                        UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
     47                        auto index = find(UnicodeSets.begin(), UnicodeSets.end(), *sets) - UnicodeSets.begin();
     48                        auto exclusive_IDs = exclusiveSetIDs[index];
     49                        CC * CC_union = makeCC();
     50                        for (auto i : exclusive_IDs) {
     51                            CC_union = makeCC(CC_union, makeCC(i));
     52                        }
     53                        name->setDefinition(CC_union);
     54                    } else {
     55                        multiplex(name->getDefinition());
    5056                    }
    51                     name->setDefinition(CC_union);
    5257                } else {
    53                     multiplex(name->getDefinition(), UnicodeSets, exclusiveSetIDs, multiplexedCCs);
     58                    throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    5459                }
     60                return memoizer.memoize(name);
    5561            } else {
    56                 throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     62                return *f;
    5763            }
    58             mMemoizer_multiplex.memoize(name);
    59             return name;
    60         } else {
    61             return *f;
    62         }
    63     } else if (Seq * seq = dyn_cast<Seq>(re)) {
    64         for (auto si = seq->begin(); si != seq->end(); ++si) {
    65             *si = multiplex(*si, UnicodeSets, exclusiveSetIDs, multiplexedCCs);
    66         }
    67     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    68         CC * unionCC = nullptr;
    69         std::stringstream name;
    70         for (auto ai = alt->begin(); ai != alt->end(); ) {
    71             RE * re = multiplex(*ai, UnicodeSets, exclusiveSetIDs, multiplexedCCs);
    72             if (CC * cc = extractCC(re)) {
    73                 if (unionCC == nullptr) {
    74                     unionCC = cc;
     64        } else if (Seq * seq = dyn_cast<Seq>(re)) {
     65            for (auto si = seq->begin(); si != seq->end(); ++si) {
     66                *si = multiplex(*si);
     67            }
     68        } else if (Alt * alt = dyn_cast<Alt>(re)) {
     69            CC * unionCC = nullptr;
     70            std::stringstream name;
     71            for (auto ai = alt->begin(); ai != alt->end(); ) {
     72                RE * re = multiplex(*ai);
     73                if (CC * cc = extractCC(re)) {
     74                    if (unionCC == nullptr) {
     75                        unionCC = cc;
     76                    } else {
     77                        unionCC = makeCC(unionCC, cc);
     78                        name << '+';
     79                    }
     80                    if (LLVM_LIKELY(isa<Name>(re))) {
     81                        Name * n = cast<Name>(re);
     82                        if (n->hasNamespace()) {
     83                            name << n->getNamespace() << ':';
     84                        }
     85                        name << n->getName();
     86                    } else if (isa<CC>(re)) {
     87                        name << cast<CC>(re)->canonicalName(UnicodeClass);
     88                    }
     89                    ai = alt->erase(ai);
    7590                } else {
    76                     unionCC = makeCC(unionCC, cc);
    77                     name << '+';
     91                    *ai++ = re;
    7892                }
    79                 if (LLVM_LIKELY(isa<Name>(re))) {
    80                     Name * n = cast<Name>(re);
    81                     if (n->hasNamespace()) {
    82                         name << n->getNamespace() << ':';
    83                     }
    84                     name << n->getName();
    85                 } else if (isa<CC>(re)) {
    86                     name << cast<CC>(re)->canonicalName(UnicodeClass);
    87                 }
    88                 ai = alt->erase(ai);
    89             } else {
    90                 *ai++ = re;
     93            }
     94            if (unionCC) {
     95                alt->push_back(multiplex(makeName(name.str(), unionCC)));
     96            }
     97            if (alt->size() == 1) {
     98                return alt->front();
     99            }
     100        } else if (Rep * rep = dyn_cast<Rep>(re)) {
     101            rep->setRE(multiplex(rep->getRE()));
     102        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     103            a->setAsserted(multiplex(a->getAsserted()));
     104        } else if (Diff * diff = dyn_cast<Diff>(re)) {
     105            diff->setLH(multiplex(diff->getLH()));
     106            diff->setRH(multiplex(diff->getRH()));
     107            CC * lh = extractCC(diff->getLH());
     108            CC * rh = extractCC(diff->getRH());
     109            if (lh && rh) {
     110                return multiplex(makeName("diff", subtractCC(lh, rh)));
     111            }
     112        } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
     113            ix->setLH(multiplex(ix->getLH()));
     114            ix->setRH(multiplex(ix->getRH()));
     115            CC * lh = extractCC(ix->getLH());
     116            CC * rh = extractCC(ix->getRH());
     117            if (lh && rh) {
     118                return multiplex(makeName("intersect", intersectCC(lh, rh)));
    91119            }
    92120        }
    93         if (unionCC) {
    94             alt->push_back(multiplex(makeName(name.str(), unionCC), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    95         }
    96         if (alt->size() == 1) {
    97             return alt->front();
    98         }
    99     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    100         rep->setRE(multiplex(rep->getRE(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    101     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    102         a->setAsserted(multiplex(a->getAsserted(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    103     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    104         diff->setLH(multiplex(diff->getLH(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    105         diff->setRH(multiplex(diff->getRH(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    106         CC * lh = extractCC(diff->getLH());
    107         CC * rh = extractCC(diff->getRH());
    108         if (lh && rh) {
    109             return multiplex(makeName("diff", subtractCC(lh, rh)), UnicodeSets, exclusiveSetIDs, multiplexedCCs);
    110         }
    111     } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    112         ix->setLH(multiplex(ix->getLH(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    113         ix->setRH(multiplex(ix->getRH(), UnicodeSets, exclusiveSetIDs, multiplexedCCs));
    114         CC * lh = extractCC(ix->getLH());
    115         CC * rh = extractCC(ix->getRH());
    116         if (lh && rh) {
    117             return multiplex(makeName("intersect", intersectCC(lh, rh)), UnicodeSets, exclusiveSetIDs, multiplexedCCs);
    118         }
    119     }
    120     return re;
     121        return re;
     122    };
     123
     124    return multiplex(re);
    121125}   
    122126
  • icGREP/icgrep-devel/icgrep/re/re_multiplex.h

    r5619 r5620  
    99    class Name;
    1010
    11     RE * multiplex(RE * const re, const std::vector<UCD::UnicodeSet> & UnicodeSets,
    12                     const std::vector<std::vector<unsigned>> & exclusiveSetIDs,
    13                     const std::vector<UCD::UnicodeSet> & multiplexedCCs);
     11    RE * multiplex(RE * const re,
     12                   const std::vector<UCD::UnicodeSet> & UnicodeSets,
     13                   const std::vector<std::vector<unsigned>> & exclusiveSetIDs);
    1414
    1515}
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r5558 r5620  
    3232#include <llvm/Support/Casting.h>
    3333#include <llvm/Support/ErrorHandling.h>
     34#include <llvm/Support/raw_ostream.h>
    3435
    3536using namespace llvm;
     
    4344
    4445RE * RE_Parser::parse(const std::string & regular_expression, ModeFlagSet initialFlags, RE_Syntax syntax, bool ByteMode) {
     46
    4547    std::unique_ptr<RE_Parser> parser = nullptr;
    4648    switch (syntax) {
  • icGREP/icgrep-devel/icgrep/re/re_toolchain.cpp

    r5617 r5620  
    1616#include <re/re_analysis.h>
    1717#include <iostream>
     18#include <llvm/Support/raw_ostream.h>
    1819
    1920using namespace pablo;
Note: See TracChangeset for help on using the changeset viewer.