Changeset 4772

Timestamp:

Sep 15, 2015, 4:41:40 PM (4 years ago)

Author:

nmedfort

Message:

Minor clean-up revisions.

Location:

icGREP/icgrep-devel/icgrep/pablo/optimizers

Files:

• booleanreassociationpass.cpp (modified) (6 diffs)
• pablo_automultiplexing.cpp (modified) (4 diffs)
• pablo_bddminimization.cpp (modified) (2 diffs)

icGREP/icgrep-devel/icgrep/pablo/optimizers/booleanreassociationpass.cpp

@@ -14 +14 @@
 #include <iostream>
 #include <pablo/printer_pablos.h>
-#include "graph-facade.hpp"
 
 using namespace boost;
@@ -39 +38 @@
  * @brief helper functions
  ** ------------------------------------------------------------------------------------------------------------- */
-template <class Graph>
-static VertexSet incomingVertexSet(const Vertex u, const Graph & G) {
-    VertexSet V;
-    V.reserve(G.in_degree(u));
-    for (auto e : make_iterator_range(G.in_edges(u))) {
-        V.push_back(G.source(e));
-    }
-    std::sort(V.begin(), V.end());
-    return std::move(V);
-}
-
-template <class Graph>
-static VertexSet outgoingVertexSet(const Vertex u, const Graph & G) {
-    VertexSet V;
-    V.reserve(G.out_degree(u));
-    for (auto e : make_iterator_range(G.out_edges(u))) {
-        V.push_back(G.target(e));
-    }
-    std::sort(V.begin(), V.end());
-    return std::move(V);
-}
-
-template <class Graph>
-static VertexSet sinks(const Graph & G) {
-    VertexSet V;
-    for (const Vertex u : make_iterator_range(vertices(G))) {
-        if (out_degree(u, G) == 0) {
-            V.push_back(u);
-        }
-    }
-    std::sort(V.begin(), V.end());
-    return std::move(V);
-}
-
 template<typename Iterator>
 inline Graph::edge_descriptor first(const std::pair<Iterator, Iterator> & range) {
@@ -88 +53 @@
 
 inline void add_edge(PabloAST * expr, const Vertex u, const Vertex v, Graph & G) {
-    // assert (u != v);
-    // assert (no_edge(v, u, G));
+    assert (u != v);
+    assert (no_edge(v, u, G));
     // Make sure each edge is unique
     for (auto e : make_iterator_range(out_edges(u, G))) {
@@ -562 +527 @@
     IntersectionSets B1;
     for (auto u : A) {
-        B1.insert(std::move(incomingVertexSet(u, G)));
+        VertexSet V;
+        V.reserve(in_degree(u, G));
+        for (auto e : make_iterator_range(in_edges(u, G))) {
+            V.push_back(source(e, G));
+        }
+        std::sort(V.begin(), V.end());
+        B1.insert(std::move(V));
     }
 
@@ -607 +578 @@
         VertexSet Ai(A);
         for (const Vertex u : *Bi) {
-            VertexSet Aj = outgoingVertexSet(u, G);
+            VertexSet Aj;
+            Aj.reserve(out_degree(u, G));
+            for (auto e : make_iterator_range(out_edges(u, G))) {
+                Aj.push_back(target(e, G));
+            }
+            std::sort(Aj.begin(), Aj.end());
+
             VertexSet Ak;
             std::set_intersection(Ai.begin(), Ai.end(), Aj.begin(), Aj.end(), std::back_inserter(Ak));
+
             Ai.swap(Ak);
         }
@@ -721 +699 @@
  ** ------------------------------------------------------------------------------------------------------------- */
 static DistributionSets safeDistributionSets(const Graph & G, DistributionGraph & H) {
-    const auto F = makeGraphFacade(H);
+
+    VertexSet sinks;
+    for (const Vertex u : make_iterator_range(vertices(G))) {
+        if (out_degree(u, G) == 0) {
+            sinks.push_back(u);
+        }
+    }
+    std::sort(sinks.begin(), sinks.end());
+
     DistributionSets T;
-    BicliqueSet lowerSet = independentCliqueSets<1>(removeUnhelpfulBicliques(enumerateBicliques(F, sinks(H)), G, H), 1);
+    BicliqueSet lowerSet = independentCliqueSets<1>(removeUnhelpfulBicliques(enumerateBicliques(H, sinks), G, H), 1);
     for (Biclique & lower : lowerSet) {
-        BicliqueSet upperSet = independentCliqueSets<0>(enumerateBicliques(F, std::get<1>(lower)), 2);
+        BicliqueSet upperSet = independentCliqueSets<0>(enumerateBicliques(H, std::get<1>(lower)), 2);
         for (Biclique & upper : upperSet) {
             T.emplace_back(std::move(std::get<1>(upper)), std::move(std::get<0>(upper)), std::get<0>(lower));

icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_automultiplexing.cpp

@@ -17 +17 @@
 #include <unordered_set>
 #include <pablo/optimizers/pablo_simplifier.hpp>
-#include <pablo/optimizers/pablo_bddminimization.h>
-
 
 using namespace llvm;
@@ -104 +102 @@
 namespace pablo {
 
+using TypeId = PabloAST::ClassTypeId;
+
 bool AutoMultiplexing::optimize(PabloFunction & function) {
-
-    BDDMinimizationPass::optimize(function);
 
     // std::random_device rd;
@@ -202 +200 @@
 
             switch (stmt->getClassTypeId()) {
-                case PabloAST::ClassTypeId::Advance:
+                case TypeId::Advance:
                     mAdvanceMap.emplace(stmt, m);
                     map.emplace(stmt, m++);
-                case PabloAST::ClassTypeId::Call:
-                case PabloAST::ClassTypeId::ScanThru:
-                case PabloAST::ClassTypeId::MatchStar:
+                case TypeId::Call:
+                case TypeId::ScanThru:
+                case TypeId::MatchStar:
                     variableCount++;
                     break;
@@ -401 +399 @@
 
     switch (stmt->getClassTypeId()) {
-        case PabloAST::ClassTypeId::Assign:
-        case PabloAST::ClassTypeId::Next:
+        case TypeId::Assign:
+        case TypeId::Next:
             bdd = input[0];
             break;
-        case PabloAST::ClassTypeId::And:
+        case TypeId::And:
             bdd = And(input[0], input[1]);
             break;        
-        case PabloAST::ClassTypeId::Or:
+        case TypeId::Or:
             bdd = Or(input[0], input[1]);
             break;
-        case PabloAST::ClassTypeId::Xor:
+        case TypeId::Xor:
             bdd = Xor(input[0], input[1]);
             break;
-        case PabloAST::ClassTypeId::Not:
+        case TypeId::Not:
             bdd = Not(input[0]);
             break;
-        case PabloAST::ClassTypeId::Sel:
+        case TypeId::Sel:
             bdd = Ite(input[0], input[1], input[2]);
             break;
-        case PabloAST::ClassTypeId::ScanThru:
+        case TypeId::ScanThru:
             // It may be possible use "Not(input[1])" for ScanThrus if we rule out the possibility
             // of a contradition being erroneously calculated later. An example of this
             // would be ¬(ScanThru(c,m) √ m)
-        case PabloAST::ClassTypeId::MatchStar:
-        case PabloAST::ClassTypeId::Call:
+        case TypeId::MatchStar:
+        case TypeId::Call:
             bdd = NewVar();
             mRecentCharacterizations.emplace_back(stmt, bdd);
             return bdd;
-        case PabloAST::ClassTypeId::Advance:
+        case TypeId::Advance:
             // This returns so that it doesn't mistakeningly replace the Advance with 0 or add it
             // to the list of recent characterizations.

icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_bddminimization.cpp

@@ -27 +27 @@
     BDDMinimizationPass am;
     am.eliminateLogicallyEquivalentStatements(function);
-
     am.shutdown();
     return Simplifier::optimize(function);
@@ -57 +56 @@
             }
             switch (stmt->getClassTypeId()) {
-                case TypeId::Assign:
-                case TypeId::Next:
                 case TypeId::Advance:
                 case TypeId::Call: