From de201997b7b71c0aed83dc614e3ec4dc86d61602 Mon Sep 17 00:00:00 2001 From: Justin Viiret Date: Thu, 2 Jun 2016 13:24:47 +1000 Subject: [PATCH] rose_build_groups: move findGroupSquashers --- src/rose/rose_build_compile.cpp | 184 +------------------------------ src/rose/rose_build_groups.cpp | 186 ++++++++++++++++++++++++++++++++ src/rose/rose_build_groups.h | 2 + 3 files changed, 189 insertions(+), 183 deletions(-) diff --git a/src/rose/rose_build_compile.cpp b/src/rose/rose_build_compile.cpp index af8f7e96..dca7310c 100644 --- a/src/rose/rose_build_compile.cpp +++ b/src/rose/rose_build_compile.cpp @@ -34,6 +34,7 @@ #include "rose_build_castle.h" #include "rose_build_convert.h" #include "rose_build_dump.h" +#include "rose_build_groups.h" #include "rose_build_matchers.h" #include "rose_build_merge.h" #include "rose_build_role_aliasing.h" @@ -843,189 +844,6 @@ bool RoseBuildImpl::hasAnchoredTablePred(RoseVertex v) const { return false; } -/* returns true if every vertex associated with a groups also belongs to - lit_info */ -static -bool coversGroup(const RoseBuildImpl &tbi, const rose_literal_info &lit_info) { - if (lit_info.vertices.empty()) { - DEBUG_PRINTF("no vertices - does not cover\n"); - return false; - } - - if (!lit_info.group_mask) { - DEBUG_PRINTF("no group - does not cover\n"); - return false; /* no group (not a floating lit?) */ - } - - assert(popcount64(lit_info.group_mask) == 1); - - /* for each lit in group, ensure that vertices are a subset of lit_info's */ - rose_group groups = lit_info.group_mask; - while (groups) { - u32 group_id = findAndClearLSB_64(&groups); - for (u32 id : tbi.group_to_literal.at(group_id)) { - DEBUG_PRINTF(" checking against friend %u\n", id); - if (!is_subset_of(tbi.literal_info[id].vertices, - lit_info.vertices)) { - DEBUG_PRINTF("fail\n"); - return false; - } - } - } - - DEBUG_PRINTF("ok\n"); - return true; -} - -static -bool isGroupSquasher(const RoseBuildImpl &tbi, const u32 id /* literal id */, - rose_group forbidden_squash_group) { - const RoseGraph &g = tbi.g; - - const rose_literal_info &lit_info = tbi.literal_info.at(id); - - DEBUG_PRINTF("checking if %u '%s' is a group squasher %016llx\n", id, - dumpString(tbi.literals.right.at(id).s).c_str(), - lit_info.group_mask); - - if (tbi.literals.right.at(id).table == ROSE_EVENT) { - DEBUG_PRINTF("event literal, has no groups to squash\n"); - return false; - } - - if (!coversGroup(tbi, lit_info)) { - DEBUG_PRINTF("does not cover group\n"); - return false; - } - - if (lit_info.group_mask & forbidden_squash_group) { - /* probably a delayed lit */ - DEBUG_PRINTF("skipping as involves a forbidden group\n"); - return false; - } - - // Single-vertex, less constrained case than the multiple-vertex one below. - if (lit_info.vertices.size() == 1) { - const RoseVertex &v = *lit_info.vertices.begin(); - - if (tbi.hasDelayPred(v)) { /* due to rebuild issues */ - return false; - } - - /* there are two ways to be a group squasher: - * 1) only care about the first accepted match - * 2) can only match once after a pred match - * - * (2) requires analysis of the infix before v and is not implemented, - * TODO - */ - - /* Case 1 */ - - // Can't squash cases with accepts - if (!g[v].reports.empty()) { - return false; - } - - /* Can't squash cases with a suffix without analysis of the suffix. - * TODO: look at suffixes */ - if (g[v].suffix) { - return false; - } - - // Out-edges must have inf max bound, + no other shenanigans */ - for (const auto &e : out_edges_range(v, g)) { - if (g[e].maxBound != ROSE_BOUND_INF) { - return false; - } - - if (g[target(e, g)].left) { - return false; /* is an infix rose trigger, TODO: analysis */ - } - } - - DEBUG_PRINTF("%u is a path 1 group squasher\n", id); - return true; - - /* note: we could also squash the groups of its preds (if nobody else is - * using them. TODO. */ - } - - // Multiple-vertex case - for (auto v : lit_info.vertices) { - assert(!tbi.isAnyStart(v)); - - // Can't squash cases with accepts - if (!g[v].reports.empty()) { - return false; - } - - // Suffixes and leftfixes are out too as first literal may not match - // for everyone. - if (!g[v].isBoring()) { - return false; - } - - /* TODO: checks are solid but we should explain */ - if (tbi.hasDelayPred(v) || tbi.hasAnchoredTablePred(v)) { - return false; - } - - // Out-edges must have inf max bound and not directly lead to another - // vertex with this group, e.g. 'foobar.*foobar'. - for (const auto &e : out_edges_range(v, g)) { - if (g[e].maxBound != ROSE_BOUND_INF) { - return false; - } - RoseVertex t = target(e, g); - - if (g[t].left) { - return false; /* is an infix rose trigger */ - } - - for (u32 lit_id : g[t].literals) { - if (tbi.literal_info[lit_id].group_mask & lit_info.group_mask) { - return false; - } - } - } - - // In-edges must all be dot-stars with no overlap at all, as overlap - // also causes history to be used. - /* Different tables are already forbidden by previous checks */ - for (const auto &e : in_edges_range(v, g)) { - if (!(g[e].minBound == 0 && g[e].maxBound == ROSE_BOUND_INF)) { - return false; - } - - // Check overlap, if source was a literal. - RoseVertex u = source(e, g); - if (tbi.maxLiteralOverlap(u, v)) { - return false; - } - } - } - - DEBUG_PRINTF("literal %u is a multi-vertex group squasher\n", id); - return true; -} - -static -void findGroupSquashers(RoseBuildImpl &tbi) { - rose_group forbidden_squash_group = 0; - for (const auto &e : tbi.literals.right) { - if (e.second.delay) { - forbidden_squash_group |= tbi.literal_info[e.first].group_mask; - } - } - - for (u32 id = 0; id < tbi.literal_info.size(); id++) { - if (isGroupSquasher(tbi, id, forbidden_squash_group)) { - tbi.literal_info[id].squash_group = true; - } - } -} - void RoseBuildImpl::findTransientLeftfixes(void) { for (auto v : vertices_range(g)) { if (!g[v].left) { diff --git a/src/rose/rose_build_groups.cpp b/src/rose/rose_build_groups.cpp index 4fc125d2..5467e1ab 100644 --- a/src/rose/rose_build_groups.cpp +++ b/src/rose/rose_build_groups.cpp @@ -454,4 +454,190 @@ rose_group getSquashableGroups(const RoseBuildImpl &build) { return squashable_groups; } +/** + * \brief True if every vertex associated with a group also belongs to + * lit_info. + */ +static +bool coversGroup(const RoseBuildImpl &build, + const rose_literal_info &lit_info) { + if (lit_info.vertices.empty()) { + DEBUG_PRINTF("no vertices - does not cover\n"); + return false; + } + + if (!lit_info.group_mask) { + DEBUG_PRINTF("no group - does not cover\n"); + return false; /* no group (not a floating lit?) */ + } + + assert(popcount64(lit_info.group_mask) == 1); + + /* for each lit in group, ensure that vertices are a subset of lit_info's */ + rose_group groups = lit_info.group_mask; + while (groups) { + u32 group_id = findAndClearLSB_64(&groups); + for (u32 id : build.group_to_literal.at(group_id)) { + DEBUG_PRINTF(" checking against friend %u\n", id); + if (!is_subset_of(build.literal_info[id].vertices, + lit_info.vertices)) { + DEBUG_PRINTF("fail\n"); + return false; + } + } + } + + DEBUG_PRINTF("ok\n"); + return true; +} + +static +bool isGroupSquasher(const RoseBuildImpl &build, const u32 id /* literal id */, + rose_group forbidden_squash_group) { + const RoseGraph &g = build.g; + + const rose_literal_info &lit_info = build.literal_info.at(id); + + DEBUG_PRINTF("checking if %u '%s' is a group squasher %016llx\n", id, + dumpString(build.literals.right.at(id).s).c_str(), + lit_info.group_mask); + + if (build.literals.right.at(id).table == ROSE_EVENT) { + DEBUG_PRINTF("event literal, has no groups to squash\n"); + return false; + } + + if (!coversGroup(build, lit_info)) { + DEBUG_PRINTF("does not cover group\n"); + return false; + } + + if (lit_info.group_mask & forbidden_squash_group) { + /* probably a delayed lit */ + DEBUG_PRINTF("skipping as involves a forbidden group\n"); + return false; + } + + // Single-vertex, less constrained case than the multiple-vertex one below. + if (lit_info.vertices.size() == 1) { + const RoseVertex &v = *lit_info.vertices.begin(); + + if (build.hasDelayPred(v)) { /* due to rebuild issues */ + return false; + } + + /* there are two ways to be a group squasher: + * 1) only care about the first accepted match + * 2) can only match once after a pred match + * + * (2) requires analysis of the infix before v and is not implemented, + * TODO + */ + + /* Case 1 */ + + // Can't squash cases with accepts + if (!g[v].reports.empty()) { + return false; + } + + /* Can't squash cases with a suffix without analysis of the suffix. + * TODO: look at suffixes */ + if (g[v].suffix) { + return false; + } + + // Out-edges must have inf max bound, + no other shenanigans */ + for (const auto &e : out_edges_range(v, g)) { + if (g[e].maxBound != ROSE_BOUND_INF) { + return false; + } + + if (g[target(e, g)].left) { + return false; /* is an infix rose trigger, TODO: analysis */ + } + } + + DEBUG_PRINTF("%u is a path 1 group squasher\n", id); + return true; + + /* note: we could also squash the groups of its preds (if nobody else is + * using them. TODO. */ + } + + // Multiple-vertex case + for (auto v : lit_info.vertices) { + assert(!build.isAnyStart(v)); + + // Can't squash cases with accepts + if (!g[v].reports.empty()) { + return false; + } + + // Suffixes and leftfixes are out too as first literal may not match + // for everyone. + if (!g[v].isBoring()) { + return false; + } + + /* TODO: checks are solid but we should explain */ + if (build.hasDelayPred(v) || build.hasAnchoredTablePred(v)) { + return false; + } + + // Out-edges must have inf max bound and not directly lead to another + // vertex with this group, e.g. 'foobar.*foobar'. + for (const auto &e : out_edges_range(v, g)) { + if (g[e].maxBound != ROSE_BOUND_INF) { + return false; + } + RoseVertex t = target(e, g); + + if (g[t].left) { + return false; /* is an infix rose trigger */ + } + + for (u32 lit_id : g[t].literals) { + if (build.literal_info[lit_id].group_mask & + lit_info.group_mask) { + return false; + } + } + } + + // In-edges must all be dot-stars with no overlap at all, as overlap + // also causes history to be used. + /* Different tables are already forbidden by previous checks */ + for (const auto &e : in_edges_range(v, g)) { + if (!(g[e].minBound == 0 && g[e].maxBound == ROSE_BOUND_INF)) { + return false; + } + + // Check overlap, if source was a literal. + RoseVertex u = source(e, g); + if (build.maxLiteralOverlap(u, v)) { + return false; + } + } + } + + DEBUG_PRINTF("literal %u is a multi-vertex group squasher\n", id); + return true; +} + +void findGroupSquashers(RoseBuildImpl &build) { + rose_group forbidden_squash_group = 0; + for (const auto &e : build.literals.right) { + if (e.second.delay) { + forbidden_squash_group |= build.literal_info[e.first].group_mask; + } + } + + for (u32 id = 0; id < build.literal_info.size(); id++) { + if (isGroupSquasher(build, id, forbidden_squash_group)) { + build.literal_info[id].squash_group = true; + } + } +} + } // namespace ue2 diff --git a/src/rose/rose_build_groups.h b/src/rose/rose_build_groups.h index 608eda4a..f24a11c3 100644 --- a/src/rose/rose_build_groups.h +++ b/src/rose/rose_build_groups.h @@ -44,6 +44,8 @@ getVertexGroupMap(const RoseBuildImpl &build); rose_group getSquashableGroups(const RoseBuildImpl &build); +void findGroupSquashers(RoseBuildImpl &build); + } // namespace ue2 #endif // ROSE_BUILD_GROUPS_H