github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

ng_mcclellan: move logic into base class

Browse Source 
Move all of the Automaton logic into Automaton_Base, which is templated
on its StateSet/StateMap types.
This commit is contained in:
Justin Viiret 2016-04-20 17:11:25 +10:00 committed by Matthew Barr
parent ea7197571a
commit 75195f5f2e
1 changed files with 59 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
src/nfagraph/ng_mcclellan.cpp
View File

@ -341,18 +341,24 @@ void markToppableStarts(const NGHolder &g, const flat_set<NFAVertex> &unused,
namespace { namespace {
class Automaton_Big { template<typename Automaton_Traits>
class Automaton_Base {
public: public:
typedef dynamic_bitset<> StateSet; using StateSet = typename Automaton_Traits::StateSet;
typedef map<StateSet, dstate_id_t> StateMap; using StateMap = typename Automaton_Traits::StateMap;
Automaton_Big(const ReportManager *rm_in, const NGHolder &graph_in, Automaton_Base(const ReportManager *rm_in, const NGHolder &graph_in,
const flat_set<NFAVertex> &unused_in, bool single_trigger, const flat_set<NFAVertex> &unused_in, bool single_trigger,
const vector<vector<CharReach>> &triggers, bool prunable_in) const vector<vector<CharReach>> &triggers, bool prunable_in)
: rm(rm_in), graph(graph_in), numStates(num_vertices(graph)), : rm(rm_in), graph(graph_in), numStates(num_vertices(graph)),
unused(unused_in), init(numStates), initDS(numStates), unused(unused_in), init(Automaton_Traits::init_states(numStates)),
squash(numStates), accept(numStates), acceptEod(numStates), initDS(Automaton_Traits::init_states(numStates)),
toppable(numStates), prunable(prunable_in), dead(numStates) { squash(Automaton_Traits::init_states(numStates)),
accept(Automaton_Traits::init_states(numStates)),
acceptEod(Automaton_Traits::init_states(numStates)),
toppable(Automaton_Traits::init_states(numStates)),
dead(Automaton_Traits::init_states(numStates)),
prunable(prunable_in) {
populateInit(graph, unused, &init, &initDS, &v_by_index); populateInit(graph, unused, &init, &initDS, &v_by_index);
populateAccepts(graph, unused, &accept, &acceptEod); populateAccepts(graph, unused, &accept, &acceptEod);
@ -376,15 +382,17 @@ public:
cr_by_index = populateCR(graph, v_by_index, alpha); cr_by_index = populateCR(graph, v_by_index, alpha);
if (is_triggered(graph)) { if (is_triggered(graph)) {
dynamic_bitset<> temp(numStates);
markToppableStarts(graph, unused, single_trigger, triggers, markToppableStarts(graph, unused, single_trigger, triggers,
&toppable); &temp);
toppable = Automaton_Traits::copy_states(temp, numStates);
} }
} }
private: private:
// Convert an NFAStateSet (as used by the squash code) into a StateSet // Convert an NFAStateSet (as used by the squash code) into a StateSet
StateSet shrinkStateSet(const NFAStateSet &in) const { StateSet shrinkStateSet(const NFAStateSet &in) const {
StateSet out(dead.size()); StateSet out = Automaton_Traits::init_states(numStates);
for (size_t i = in.find_first(); i != in.npos && i < out.size(); for (size_t i = in.find_first(); i != in.npos && i < out.size();
i = in.find_next(i)) { i = in.find_next(i)) {
out.set(i); out.set(i);
@ -398,7 +406,7 @@ public:
} }
const vector<StateSet> initial() { const vector<StateSet> initial() {
vector<StateSet> rv(1, init); vector<StateSet> rv = {init};
if (start_floating != DEAD_STATE && start_floating != start_anchored) { if (start_floating != DEAD_STATE && start_floating != start_anchored) {
rv.push_back(initDS); rv.push_back(initDS);
} }
@ -446,9 +454,9 @@ public:
StateSet acceptEod; StateSet acceptEod;
StateSet toppable; /* states which are allowed to be on when a top arrives, StateSet toppable; /* states which are allowed to be on when a top arrives,
* triggered dfas only */ * triggered dfas only */
StateSet dead;
map<u32, StateSet> squash_mask; map<u32, StateSet> squash_mask;
bool prunable; bool prunable;
StateSet dead;
array<u16, ALPHABET_SIZE> alpha; array<u16, ALPHABET_SIZE> alpha;
array<u16, ALPHABET_SIZE> unalpha; array<u16, ALPHABET_SIZE> unalpha;
u16 alphasize; u16 alphasize;
@ -457,119 +465,55 @@ public:
u16 start_floating; u16 start_floating;
}; };
class Automaton_Graph { struct Big_Traits {
public: using StateSet = dynamic_bitset<>;
typedef bitfield<NFA_STATE_LIMIT> StateSet; using StateMap = map<StateSet, dstate_id_t>;
typedef ue2::unordered_map<StateSet, dstate_id_t> StateMap;
Automaton_Graph(const ReportManager *rm_in, const NGHolder &graph_in, static StateSet init_states(u32 num) {
const flat_set<NFAVertex> &unused_in, bool single_trigger, return StateSet(num);
const vector<vector<CharReach>> &triggers, bool prunable_in)
: rm(rm_in), graph(graph_in), unused(unused_in), prunable(prunable_in) {
populateInit(graph, unused, &init, &initDS, &v_by_index);
populateAccepts(graph, unused, &accept, &acceptEod);
start_anchored = DEAD_STATE + 1;
if (initDS == init) {
start_floating = start_anchored;
} else if (initDS.any()) {
start_floating = start_anchored + 1;
} else {
start_floating = DEAD_STATE;
}
calculateAlphabet(graph, alpha, unalpha, &alphasize);
assert(alphasize <= ALPHABET_SIZE);
for (const auto &sq : findSquashers(graph)) {
NFAVertex v = sq.first;
u32 vert_id = graph[v].index;
squash.set(vert_id);
squash_mask[vert_id] = shrinkStateSet(sq.second);
}
cr_by_index = populateCR(graph, v_by_index, alpha);
if (is_triggered(graph)) {
dynamic_bitset<> temp(NFA_STATE_LIMIT);
markToppableStarts(graph, unused, single_trigger, triggers, &temp);
toppable = bitfield<NFA_STATE_LIMIT>(temp);
}
} }
private: static StateSet copy_states(const dynamic_bitset<> &in, UNUSED u32 num) {
// Convert an NFAStateSet (as used by the squash code) into a StateSet assert(in.size() == num);
StateSet shrinkStateSet(const NFAStateSet &in) const { return in;
StateSet out; }
};
class Automaton_Big : public Automaton_Base<Big_Traits> {
public:
Automaton_Big(const ReportManager *rm_in, const NGHolder &graph_in,
const flat_set<NFAVertex> &unused_in, bool single_trigger,
const vector<vector<CharReach>> &triggers, bool prunable_in)
: Automaton_Base(rm_in, graph_in, unused_in, single_trigger, triggers,
prunable_in) {}
};
struct Graph_Traits {
using StateSet = bitfield<NFA_STATE_LIMIT>;
using StateMap = ue2::unordered_map<StateSet, dstate_id_t>;
static StateSet init_states(UNUSED u32 num) {
assert(num <= NFA_STATE_LIMIT);
return StateSet();
}
static StateSet copy_states(const dynamic_bitset<> &in, u32 num) {
StateSet out = init_states(num);
for (size_t i = in.find_first(); i != in.npos && i < out.size(); for (size_t i = in.find_first(); i != in.npos && i < out.size();
i = in.find_next(i)) { i = in.find_next(i)) {
out.set(i); out.set(i);
} }
return out; return out;
} }
};
class Automaton_Graph : public Automaton_Base<Graph_Traits> {
public: public:
void transition(const StateSet &in, StateSet *next) { Automaton_Graph(const ReportManager *rm_in, const NGHolder &graph_in,
transition_graph(*this, v_by_index, in, next); const flat_set<NFAVertex> &unused_in, bool single_trigger,
} const vector<vector<CharReach>> &triggers, bool prunable_in)
: Automaton_Base(rm_in, graph_in, unused_in, single_trigger, triggers,
const vector<StateSet> initial() { prunable_in) {}
vector<StateSet> rv(1, init);
if (start_floating != DEAD_STATE && start_floating != start_anchored) {
rv.push_back(initDS);
}
return rv;
}
private:
void reports_i(const StateSet &in, bool eod, flat_set<ReportID> &rv) {
StateSet acc = in & (eod ? acceptEod : accept);
for (size_t i = acc.find_first(); i != StateSet::npos;
i = acc.find_next(i)) {
NFAVertex v = v_by_index[i];
DEBUG_PRINTF("marking report\n");
const auto &my_reports = graph[v].reports;
rv.insert(my_reports.begin(), my_reports.end());
}
}
public:
void reports(const StateSet &in, flat_set<ReportID> &rv) {
reports_i(in, false, rv);
}
void reportsEod(const StateSet &in, flat_set<ReportID> &rv) {
reports_i(in, true, rv);
}
bool canPrune(const flat_set<ReportID> &test_reports) const {
if (!rm || !prunable || !canPruneEdgesFromAccept(*rm, graph)) {
return false;
}
return allExternalReports(*rm, test_reports);
}
private:
const ReportManager *rm;
public:
const NGHolder &graph;
const flat_set<NFAVertex> &unused;
vector<NFAVertex> v_by_index;
vector<CharReach> cr_by_index; /* pre alpha'ed */
StateSet init;
StateSet initDS;
StateSet squash; /* states which allow us to mask out other states */
StateSet accept;
StateSet acceptEod;
StateSet toppable; /* states which are allowed to be on when a top arrives,
* triggered dfas only */
map<u32, StateSet> squash_mask;
bool prunable;
StateSet dead;
array<u16, ALPHABET_SIZE> alpha;
array<u16, ALPHABET_SIZE> unalpha;
u16 alphasize;
u16 start_anchored;
u16 start_floating;
}; };
} // namespace } // namespace