Changeset 4771


Ignore:
Timestamp:
Sep 15, 2015, 4:27:23 PM (3 years ago)
Author:
nmedfort
Message:

Bug fixes for reassociation pass; passes make check.

Location:
icGREP/icgrep-devel/icgrep/pablo
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.cpp

    r4766 r4771  
    2626};
    2727
    28 void isTopologicallyOrdered(const PabloBlock & block, const OrderingVerifier & parent) {
     28void isTopologicallyOrdered(const PabloBlock & block, const OrderingVerifier & parent, const bool ignoreUnusedStatements) {
    2929    OrderingVerifier ov(parent);
    3030    for (const Statement * stmt : block) {
     31        if (stmt->getNumUses() == 0 && ignoreUnusedStatements) {
     32            continue;
     33        }
     34        if (LLVM_UNLIKELY(isa<While>(stmt))) {
     35            isTopologicallyOrdered(cast<While>(stmt)->getBody(), ov, ignoreUnusedStatements);
     36            for (const Next * var : cast<While>(stmt)->getVariants()) {
     37                ov.insert(var);
     38            }
     39        }
    3140        for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
    3241            const PabloAST * op = stmt->getOperand(i);
     
    4453        ov.insert(stmt);
    4554        if (LLVM_UNLIKELY(isa<If>(stmt))) {
    46             isTopologicallyOrdered(cast<If>(stmt)->getBody(), ov);
     55            isTopologicallyOrdered(cast<If>(stmt)->getBody(), ov, ignoreUnusedStatements);
    4756            for (const Assign * def : cast<If>(stmt)->getDefined()) {
    4857                ov.insert(def);
    49             }
    50         } else if (LLVM_UNLIKELY(isa<While>(stmt))) {
    51             isTopologicallyOrdered(cast<While>(stmt)->getBody(), ov);
    52             for (const Next * var : cast<While>(stmt)->getVariants()) {
    53                 ov.insert(var);
    5458            }
    5559        }
     
    5761}
    5862
    59 void isTopologicallyOrdered(const PabloFunction & function) {
     63void isTopologicallyOrdered(const PabloFunction & function, const bool ignoreUnusedStatements) {
    6064    OrderingVerifier ov;
    6165    for (unsigned i = 0; i != function.getNumOfParameters(); ++i) {
    6266        ov.insert(function.getParameter(i));
    6367    }
    64     isTopologicallyOrdered(function.getEntryBlock(), ov);
     68    isTopologicallyOrdered(function.getEntryBlock(), ov, ignoreUnusedStatements);
    6569}
    6670
    67 void PabloVerifier::verify(const PabloFunction & function) {
    68     isTopologicallyOrdered(function);
     71void PabloVerifier::verify(const PabloFunction & function, const bool ignoreUnusedStatements) {
     72    isTopologicallyOrdered(function, ignoreUnusedStatements);
    6973}
    7074
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.hpp

    r4766 r4771  
    88class PabloVerifier {
    99public:
    10     static void verify(const PabloFunction & function);
     10    static void verify(const PabloFunction & function, const bool ignoreUnusedStatements = true);
    1111private:
    1212
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/booleanreassociationpass.cpp

    r4770 r4771  
    66#include <boost/graph/filtered_graph.hpp>
    77#include <boost/graph/topological_sort.hpp>
     8#include <boost/graph/strong_components.hpp>
    89#include <pablo/optimizers/pablo_simplifier.hpp>
    910#include <pablo/analysis/pabloverifier.hpp>
     
    7879}
    7980
     81inline bool has_edge(const Vertex u, const Vertex v, const Graph & G) {
     82    return edge(u, v, G).second == true;
     83}
     84
     85inline bool no_edge(const Vertex u, const Vertex v, const Graph & G) {
     86    return edge(u, v, G).second == false;
     87}
     88
    8089inline void add_edge(PabloAST * expr, const Vertex u, const Vertex v, Graph & G) {
    81     assert (u != v);
    82     G[add_edge(u, v, G).first] = expr;
    83 }
     90    // assert (u != v);
     91    // assert (no_edge(v, u, G));
     92    // Make sure each edge is unique
     93    for (auto e : make_iterator_range(out_edges(u, G))) {
     94        if (LLVM_UNLIKELY(target(e, G) == v && (G[e] == nullptr || G[e] == expr))) {
     95            G[e] = expr;
     96            return;
     97        }
     98    }
     99    G[std::get<0>(add_edge(u, v, G))] = expr;
     100}
     101
    84102
    85103/** ------------------------------------------------------------------------------------------------------------- *
     
    154172 ** ------------------------------------------------------------------------------------------------------------- */
    155173inline bool BooleanReassociationPass::isOptimizable(const VertexData & data) {
    156     switch (data.first) {
     174    switch (std::get<0>(data)) {
    157175        case PabloAST::ClassTypeId::And:
    158176        case PabloAST::ClassTypeId::Or:
     
    165183
    166184inline bool isNegated(const BooleanReassociationPass::VertexData & data) {
    167     return (data.first == TypeId::Not) && (data.second != nullptr);
     185    return (std::get<0>(data) == TypeId::Not) && (std::get<1>(data) != nullptr);
    168186}
    169187
    170188inline bool BooleanReassociationPass::isMutable(const VertexData & data, const PabloBlock &) {
    171     return (data.first != TypeId::Var);
     189    return (std::get<0>(data) != TypeId::Var);
    172190}
    173191
    174192inline bool BooleanReassociationPass::isNonEscaping(const VertexData & data) {
    175     return data.first != TypeId::Assign && data.first != TypeId::Next;
     193    return std::get<0>(data) != TypeId::Assign && std::get<0>(data) != TypeId::Next;
    176194}
    177195
    178196inline bool BooleanReassociationPass::isSameType(const VertexData & data1, const VertexData & data2) {
    179     return data1.first == data2.first;
     197    return std::get<0>(data1) == std::get<0>(data2);
    180198}
    181199
     
    199217static void printGraph(const PabloBlock & block, const Graph & G, const std::string name) {
    200218    raw_os_ostream out(std::cerr);
    201     std::vector<unsigned> visible(num_vertices(G), false);
     219
     220    std::vector<unsigned> c(num_vertices(G));
     221    strong_components(G, make_iterator_property_map(c.begin(), get(vertex_index, G), c[0]));
     222
    202223    out << "digraph " << name << " {\n";
    203224    for (auto u : make_iterator_range(vertices(G))) {
     
    205226            continue;
    206227        }
    207         visible[u] = true;
    208 
    209228        out << "v" << u << " [label=\"" << u << ": ";
    210229        PabloAST * expr;
     
    230249                    break;
    231250            }
    232         } else if (G[u].first != TypeId::Var) {
     251        } else if (std::get<0>(G[u]) != TypeId::Var) {
    233252            if (LLVM_UNLIKELY(isa<If>(expr))) {
    234253                out << "If ";
     
    257276    }
    258277    for (auto e : make_iterator_range(edges(G))) {
    259         if (visible[source(e, G)] && visible[target(e, G)]) {
    260             out << "v" << source(e, G) << " -> v" << target(e, G);
    261         }
    262         if (G[e]) {
    263              out << " [label=\"";
    264              PabloPrinter::print(G[e], out);
    265              out << "\"]";
     278        const auto s = source(e, G);
     279        const auto t = target(e, G);
     280        out << "v" << s << " -> v" << t;
     281        bool cyclic = (c[s] == c[t]);
     282        if (G[e] || cyclic) {
     283            out << " [";
     284             if (G[e]) {
     285                out << "label=\"";
     286                PabloPrinter::print(G[e], out);
     287                out << "\" ";
     288             }
     289             if (cyclic) {
     290                out << "color=red ";
     291             }
     292             out << "]";
    266293        }
    267294        out << ";\n";
     
    272299        out << "{ rank=same;";
    273300        for (auto u : make_iterator_range(vertices(G))) {
    274             if (visible[u] && in_degree(u, G) == 0 && out_degree(u, G) != 0) {
     301            if (in_degree(u, G) == 0 && out_degree(u, G) != 0) {
    275302                out << " v" << u;
    276303            }
     
    280307        out << "{ rank=same;";
    281308        for (auto u : make_iterator_range(vertices(G))) {
    282             if (visible[u] && out_degree(u, G) == 0 && in_degree(u, G) != 0) {
     309            if (out_degree(u, G) == 0 && in_degree(u, G) != 0) {
    283310                out << " v" << u;
    284311            }
     
    298325    flat_set<PabloAST *> sources;
    299326    for (const auto e : make_iterator_range(in_edges(u, G))) {
    300         PabloAST * expr = G[source(e, G)].second;
     327        PabloAST * expr = std::get<1>(G[source(e, G)]);
    301328        assert ("G contains a null input variable!" && (expr != nullptr));
    302329        sources.insert(expr);
    303330    }
    304331    circular_buffer<PabloAST *> Q(sources.begin(), sources.end());
    305     const TypeId typeId = G[u].first;
     332    const TypeId typeId = std::get<0>(G[u]);
    306333    while (Q.size() > 1) {
    307334        PabloAST * e1 = Q.front(); Q.pop_front();
     
    322349    PabloAST * const result = Q.front();
    323350    assert (result);
    324     G[u].second = result;
     351    std::get<1>(G[u]) = result;
    325352    return result;
    326353}
     
    331358inline void BooleanReassociationPass::processScope(PabloFunction & function, PabloBlock & block) {
    332359    Graph G;
    333 
    334 //    raw_os_ostream out(std::cerr);
    335 //    out << "============================================================\n";
    336 //    PabloPrinter::print(block.statements(), " > ", out);
    337 //    out << "------------------------------------------------------------\n";
    338 //    out.flush();
    339 
    340     summarizeAST(block, G);
    341     redistributeAST(block, G);
    342360
    343361    circular_buffer<Vertex> Q(num_vertices(G));
     
    348366        const Vertex u = Q.back(); Q.pop_back();
    349367        if (LLVM_LIKELY(isMutable(G[u], block))) {
    350 //            out << "Mutable: " << u << ": ";
    351 //            PabloPrinter::print(G[u].second, out);
    352 //            out << '\n';
    353 //            out.flush();
    354368            Statement * stmt = nullptr;
    355369            if (isOptimizable(G[u])) {
     
    361375                }
    362376            } else { // update any potential mappings
    363                 stmt = cast<Statement>(G[u].second);
     377                stmt = cast<Statement>(std::get<1>(G[u]));
    364378            }
    365379            assert (stmt);
     
    367381            for (auto e : make_iterator_range(out_edges(u, G))) {
    368382                if (G[e] && G[e] != stmt) {
    369                     PabloAST * expr = G[target(e, G)].second;
     383                    PabloAST * expr = std::get<1>(G[target(e, G)]);
    370384                    if (expr) { // processing a yet-to-be created value
    371385                        cast<Statement>(expr)->replaceUsesOfWith(G[e], stmt);
     
    376390        }
    377391    }
    378 
    379 //    Simplifier::deadCodeElimination(block);
    380 
    381 //    out << "------------------------------------------------------------\n";
    382 //    PabloPrinter::print(block.statements(), " < ", out);
    383 //    out.flush();
    384 
    385 //    PabloVerifier::verify(function);
    386392}
    387393
     
    418424            }
    419425            const Vertex v = getVertex(op, G, M, block);
    420             if (!edge(v, u, G).second) {
    421                 add_edge(op, v, u, G);
    422             }
     426            add_edge(op, v, u, G);
    423427            // If this operand is a Not operation that is not in this PabloBlock,
    424428            // pull its input operand in. It may lead to future optimizations.
    425429            if (LLVM_UNLIKELY(isa<Not>(op) && !inCurrentBlock(cast<Not>(op), block))) {
    426                 PabloAST * const neg = cast<Not>(op)->getExpr();
    427                 const Vertex w = getVertex(neg, G, M, block);
    428                 if (!edge(w, v, G).second) {
    429                     add_edge(neg, w, v, G);
    430                 }
     430                PabloAST * const negatedValue = cast<Not>(op)->getExpr();
     431                add_edge(negatedValue, getVertex(negatedValue, G, M, block), v, G);
    431432            }
    432433        }
     
    438439            }
    439440        } else if (isa<While>(stmt)) {
     441            // To keep G a DAG, we need to do a bit of surgery on loop variants because
     442            // the next variables it produces can be used within the condition. Instead,
     443            // we make the loop dependent on the original value of each Next node and
     444            // the Next node dependent on the loop.
    440445            for (Next * var : cast<const While>(stmt)->getVariants()) {
    441446                const Vertex v = getVertex(var, G, M, block);
     447                assert (in_degree(v, G) == 1);
     448                add_edge(nullptr, source(first(in_edges(v, G)), G), u, G);
     449                remove_edge(v, u, G);
    442450                add_edge(var, u, v, G);
    443451                resolveUsages(v, var, block, G, M, stmt);
     
    448456    }
    449457    std::vector<Vertex> mapping(num_vertices(G));
    450     summarizeGraph(G, mapping);
     458    summarizeGraph(block, G, mapping);
    451459}
    452460
     
    470478                            throw std::runtime_error("Failed to resolve scope block!");
    471479                        }
    472                         Statement * branch = f->second;
     480                        Statement * const branch = f->second;
    473481                        if (LLVM_UNLIKELY(branch == ignoreIfThis)) {
    474482                            break;
    475483                        }
    476484                        // Add in a Var denoting the user of this expression so that it can be updated if expr changes.
    477                         const Vertex v = getVertex(user, G, M, block);
     485                        const Vertex v = getVertex(user, G, M, block);                       
    478486                        add_edge(expr, u, v, G);
     487
    479488                        const Vertex w = getVertex(branch, G, M, block);
    480489                        add_edge(nullptr, v, w, G);
     
    491500 * @brief summarizeGraph
    492501 ** ------------------------------------------------------------------------------------------------------------- */
    493 inline void BooleanReassociationPass::summarizeGraph(Graph & G, std::vector<Vertex> & mapping) {
     502inline void BooleanReassociationPass::summarizeGraph(const PabloBlock & block, Graph & G, std::vector<Vertex> & mapping) {
    494503    std::vector<Vertex> reverse_topological_ordering;
    495504    reverse_topological_ordering.reserve(num_vertices(G));
     505
    496506    topological_sort(G, std::back_inserter(reverse_topological_ordering));
    497507    assert(mapping.size() >= num_vertices(G));
     
    513523                    }
    514524                    clear_vertex(u, G);
    515                     G[u].first = TypeId::Var;
     525                    std::get<0>(G[u]) = TypeId::Var;
    516526                    mapping[u] = v;
    517527                    continue;
     
    527537                        }
    528538                        clear_vertex(u, G);
    529                         G[u].first = TypeId::Var;
     539                        std::get<0>(G[u]) = TypeId::Var;
    530540                        mapping[u] = v;
    531541                    }
     
    534544        } else if (isNonEscaping(G[u])) {
    535545            clear_in_edges(u, G);
    536             G[u].first = TypeId::Var;
    537         }
    538     }
     546            std::get<0>(G[u]) = TypeId::Var;
     547        }
     548    }   
    539549}
    540550
     
    729739    DistributionMap M;
    730740    for (const Vertex u : make_iterator_range(vertices(G))) {
    731         const TypeId outerTypeId = G[u].first;
     741        const TypeId outerTypeId = std::get<0>(G[u]);
    732742        if (outerTypeId == TypeId::And || outerTypeId == TypeId::Or) {
    733743            const TypeId innerTypeId = (outerTypeId == TypeId::And) ? TypeId::Or : TypeId::And;
     
    735745            for (auto e : make_iterator_range(in_edges(u, G))) {
    736746                const Vertex v = source(e, G);
    737                 if (LLVM_UNLIKELY(G[v].first == innerTypeId)) {
     747                if (LLVM_UNLIKELY(std::get<0>(G[v]) == innerTypeId)) {
    738748                    bool safe = true;
    739749                    for (const auto e : make_iterator_range(out_edges(v, G))) {
    740                         if (G[target(e, G)].first != outerTypeId) {
     750                        if (std::get<0>(G[target(e, G)]) != outerTypeId) {
    741751                            safe = false;
    742752                            break;
     
    768778                if (anyOpportunities) {
    769779                    for (const auto ob : observedMoreThanOnce) {
    770                         if (ob.second) {
    771                             const Vertex w = ob.first;
     780                        if (std::get<1>(ob)) {
     781                            const Vertex w = std::get<0>(ob);
    772782                            for (auto e : make_iterator_range(out_edges(w, G))) {
    773783                                const Vertex v = target(e, G);
     
    786796}
    787797
    788 
    789 
    790798/** ------------------------------------------------------------------------------------------------------------- *
    791799 * @brief redistributeAST
     
    795803void BooleanReassociationPass::redistributeAST(const PabloBlock & block, Graph & G) const {
    796804
    797 //    printGraph(block, G, "G0");
    798 
    799 //    unsigned count = 0;
    800 
    801805    std::vector<Vertex> mapping(num_vertices(G) + 16);
    802806    std::iota(mapping.begin(), mapping.end(), 0); // 0,1,.....n
     
    818822            break;
    819823        }
    820 
    821 //        raw_os_ostream out(std::cerr);
    822 //        out << "DISTRIBUTION SETS: " << distributionSets.size() << '\n';
    823 
    824 //        ++count;
    825 
    826 //        unsigned subcount = 0;
    827824
    828825        for (const DistributionSet & set : distributionSets) {
     
    833830            const VertexSet & sinks = std::get<2>(set);
    834831
    835 //            out << "SOURCES:";
    836 //            for (const Vertex u : sources) {
    837 //                const Vertex x = mapping[H[u]];
    838 //                out << " " << x << ": "; PabloPrinter::print(G[x].second, out);
    839 //            }
    840 //            out << "\n";
    841 //            out << "INTERMEDIARY:";
    842 //            for (const Vertex u : intermediary) {
    843 //                const Vertex x = mapping[H[u]];
    844 //                out << " " << x << ": "; PabloPrinter::print(G[x].second, out);
    845 //            }
    846 //            out << "\n";
    847 //            out << "SINKS:";
    848 //            for (const Vertex u : sinks) {
    849 //                const Vertex x = mapping[H[u]];
    850 //                out << " " << x << ": "; PabloPrinter::print(G[x].second, out);
    851 //            }
    852 //            out << "\n";
    853 //            out.flush();
    854 
    855             const TypeId outerTypeId = G[mapping[H[sinks.front()]]].first;
     832            const TypeId outerTypeId = std::get<0>(G[mapping[H[sinks.front()]]]);
    856833            assert (outerTypeId == TypeId::And || outerTypeId == TypeId::Or);
    857834            const TypeId innerTypeId = (outerTypeId == TypeId::Or) ? TypeId::And : TypeId::Or;
     
    866843            for (const Vertex i : intermediary) {
    867844                const auto u = mapping[H[i]];
    868                 assert (G[u].first == innerTypeId);
     845                assert (std::get<0>(G[u]) == innerTypeId);
    869846                for (const Vertex t : sinks) {
    870                     const auto v = mapping[H[t]];
    871                     assert (G[v].first == outerTypeId);
    872                     for (auto e : make_iterator_range(out_edges(u, G))) {
    873                         if (target(e, G) == v) {
    874                             assert (u != v);
    875                             remove_edge(e, G);
    876                         }
    877                     }
     847                    assert (std::get<0>(G[mapping[H[t]]]) == outerTypeId);
     848                    remove_edge(u, mapping[H[t]], G);
    878849                }
    879850                add_edge(nullptr, u, x, G);
     
    883854                const auto u = mapping[H[s]];
    884855                for (const Vertex i : intermediary) {
    885                     const auto v = mapping[H[i]];
    886                     for (auto e : make_iterator_range(out_edges(u, G))) {
    887                         if (target(e, G) == v) {
    888                             assert (u != v);
    889                             remove_edge(e, G);
    890                         }
    891                     }
     856                    remove_edge(u, mapping[H[i]], G);
    892857                }
    893858                add_edge(nullptr, u, y, G);
     
    898863            for (const Vertex t : sinks) {
    899864                const auto v = mapping[H[t]];
    900                 add_edge(G[v].second, y, v, G);
    901             }
    902 
    903             summarizeGraph(G, mapping);
    904 
    905 //            printGraph(block, G, "G" + std::to_string(count) + "_" + std::to_string(++subcount));
    906         }
    907     }
    908 }
    909 
    910 }
     865                add_edge(std::get<1>(G[v]), y, v, G);
     866            }
     867
     868            summarizeGraph(block, G, mapping);
     869        }
     870    }
     871}
     872
     873}
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/booleanreassociationpass.h

    r4769 r4771  
    2525    void processScope(PabloFunction & function, PabloBlock & block);
    2626    void summarizeAST(PabloBlock & block, Graph & G) const;
    27     static void summarizeGraph(Graph & G, std::vector<Vertex> & mapping);
     27    static void summarizeGraph(const PabloBlock & block, Graph & G, std::vector<Vertex> & mapping);
    2828    void resolveUsages(const Vertex u, PabloAST * expr, PabloBlock & block, Graph & G, Map & M, Statement * ignoreIfThis = nullptr) const;
    2929    void redistributeAST(const PabloBlock & block, Graph & G) const;
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_bddminimization.cpp

    r4770 r4771  
    7979    // Initialize the BDD engine ...
    8080    mManager = Cudd_Init(variableCount + function.getNumOfParameters() - function.getNumOfResults(), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
     81    mVariables = 0;
    8182    Cudd_MakeTreeNode(mManager, 0, function.getNumOfParameters(), MTR_DEFAULT);
    8283    // Map the predefined 0/1 entries
     
    138139        stmt = stmt->getNextNode();
    139140    }   
    140     // Cudd_ReduceHeap(mManager, CUDD_REORDER_SIFT, 1);
    141141}
    142142
     
    211211
    212212/** ------------------------------------------------------------------------------------------------------------- *
    213  * @brief identifyHiddenContradicionsAndTautologies
    214  *
    215  * This function attempts to scan through the AST and identify statements such as (A op2 B) op1 (¬A op3 C), where
    216  * op1, op2 and op3 are And, Or or Xor operations.
    217  ** ------------------------------------------------------------------------------------------------------------- */
    218 void BDDMinimizationPass::identifyHiddenContradicionsAndTautologies(PabloBlock & block) {
    219 
    220     using Graph = adjacency_list<hash_setS, vecS, bidirectionalS, PabloAST *>;
    221     using Vertex = Graph::vertex_descriptor;
    222     using Map = std::unordered_map<const PabloAST *, Vertex>;
    223 
    224     Graph G;
    225     Map M;
    226     for (Statement * stmt : block) {
    227         const TypeId typeId = stmt->getClassTypeId();
    228         if (typeId == TypeId::And || typeId == TypeId::Or || typeId == TypeId::Xor) {
    229             const auto u = add_vertex(stmt, G);
    230             M.insert(std::make_pair(stmt, u));
    231             for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
    232                 const auto f = M.find(stmt->getOperand(i));
    233                 if (f != M.end()) {
    234                     add_edge(f->second, u, G);
    235                 }
    236             }
    237         }
    238     }
    239 
    240     if (num_edges(G) == 0) {
    241         return;
    242     }
    243 
    244     std::vector<Vertex> ordering;
    245     ordering.reserve(num_vertices(G));
    246     topological_sort(G, std::back_inserter(ordering));
    247 
    248     std::vector<unsigned> component(num_vertices(G));
    249     unsigned components = 0;
    250     for (auto u : ordering) {
    251         if (out_degree(u, G) != G[u]->users().size()) {
    252             assert (out_degree(u, G) > G[u]->users().size());
    253             component[u] = ++components;
    254         }
    255     }
    256 
    257     // ....
    258 
    259 
    260 }
    261 
    262 /** ------------------------------------------------------------------------------------------------------------- *
    263213 * @brief CUDD wrappers
    264214 ** ------------------------------------------------------------------------------------------------------------- */
     
    272222}
    273223
    274 inline DdNode * BDDMinimizationPass::NewVar(const PabloAST * expr) {
    275     DdNode * var = Cudd_bddIthVar(mManager, mVariables.size());
    276     mVariables.push_back(const_cast<PabloAST *>(expr));
    277     return var;
     224inline DdNode * BDDMinimizationPass::NewVar(const PabloAST *) {
     225    return Cudd_bddIthVar(mManager, mVariables++);
    278226}
    279227
     
    318266    Cudd_Quit(mManager);
    319267    mCharacterizationMap.clear();
    320     mVariables.clear();
    321268}
    322269
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_bddminimization.h

    r4770 r4771  
    5858    DdNode * Not(DdNode * x) const;
    5959    DdNode * Ite(DdNode * const x, DdNode * const y, DdNode * const z);
    60     DdNode * NewVar(const PabloAST * expr);
     60    DdNode * NewVar(const PabloAST *);
    6161    bool noSatisfyingAssignment(DdNode * const x);
    6262    void shutdown();
    6363private:
    6464    DdManager *                     mManager;
    65     std::vector<PabloAST *>         mVariables;
     65    unsigned                        mVariables;
    6666    CharacterizationMap             mCharacterizationMap;
    6767};
Note: See TracChangeset for help on using the changeset viewer.