Changeset 4747


Ignore:
Timestamp:
Aug 24, 2015, 10:42:13 AM (4 years ago)
Author:
nmedfort
Message:

Temporary check in.

Location:
icGREP/icgrep-devel/icgrep/pablo/optimizers
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/booleanreassociationpass.cpp

    r4744 r4747  
    11#include "booleanreassociationpass.h"
    2 #include <pablo/printer_pablos.h>
    32#include <boost/container/flat_set.hpp>
    43#include <boost/container/flat_map.hpp>
    5 #include <iostream>
    64#include <boost/circular_buffer.hpp>
    7 #include <queue>
    85#include <pablo/builder.hpp>
    96#include <boost/graph/adjacency_list.hpp>
    107#include <boost/graph/topological_sort.hpp>
     8#include <queue>
    119
    1210using namespace boost;
     
    2927        terminals.push_back(function.getResult(i));
    3028    }
    31     return scan(function.getEntryBlock(), std::move(terminals));
     29    scan(function.getEntryBlock(), std::move(terminals));
    3230}
    3331
     
    5149 ** ------------------------------------------------------------------------------------------------------------- */
    5250static inline bool isaBooleanOperation(const PabloAST * const expr) {
     51    assert (expr);
    5352    switch (expr->getClassTypeId()) {
    5453        case PabloAST::ClassTypeId::And:
     
    7271    if (LLVM_UNLIKELY(component[u] != component[v])) {
    7372        return true;
    74     } else if (LLVM_UNLIKELY(out_degree(v, G) && in_degree(u, G) && G[u]->getClassTypeId() != G[v]->getClassTypeId())) {
     73    } else if (LLVM_UNLIKELY((in_degree(u, G) != 0) && (G[u]->getClassTypeId() != G[v]->getClassTypeId()))) {
    7574        return true;
    7675    }
     
    101100            builder.record(stmt);
    102101        }
     102
    103103    }
    104104
     
    117117
    118118        VertexQueue Q;
    119 
     119        unsigned count = 0;
    120120        for (Statement * const term : terminals) {
     121            assert (term);
     122            assert (Q.size() == count);
    121123            if (isaBooleanOperation(term)) {
    122                 if (LLVM_LIKELY(M.count(term) == 0)) {
     124                if (LLVM_LIKELY(M.count(term) == 0)) {                   
    123125                    const auto v = add_vertex(term, G);
     126                    assert (v < num_vertices(G));
    124127                    M.insert(std::make_pair(term, v));
    125128                    Q.push(v);
     129                    ++count;
    126130                }
    127131            } else {
    128132                for (unsigned i = 0; i != term->getNumOperands(); ++i) {
    129133                    PabloAST * const op = term->getOperand(i);
     134                    assert (op);
    130135                    if (LLVM_LIKELY(isa<Statement>(op) && M.count(op) == 0)) {
    131136                        const auto v = add_vertex(op, G);
     137                        assert (v < num_vertices(G));
    132138                        M.insert(std::make_pair(op, v));
    133139                        Q.push(v);
    134                     }
    135                 }
    136             }
     140                        ++count;
     141                    }
     142                }
     143            }           
    137144        }
    138145
    139146        for (;;) {
     147            assert (Q.size() == count);
    140148            const Vertex u = Q.front(); Q.pop();
     149            --count;
     150            assert (u < num_vertices(G));
    141151            if (isaBooleanOperation(G[u])) {
    142152                // Scan through the use-def chains to locate any chains of rearrangable expressions and their inputs
     
    147157                    if (f == M.end()) {
    148158                        const auto v = add_vertex(op, G);
     159                        assert (v < num_vertices(G));
    149160                        f = M.insert(std::make_pair(op, v)).first;
    150161                        if (op->getClassTypeId() == stmt->getClassTypeId() && cast<Statement>(op)->getParent() == &block) {
    151162                            Q.push(v);
     163                            ++count;
    152164                        }
    153165                    }
     
    189201            EdgeQueue Q;
    190202            graph_traits<Graph>::edge_iterator ei, ei_end;
    191 
    192203            for (std::tie(ei, ei_end) = edges(G); ei != ei_end; ) {
    193204                const Graph::edge_descriptor e = *ei++;
     
    283294                // Should we optimize this portion of the AST?
    284295                if (maxPathLength > ceil_log2(V.size())) {
     296
    285297                    Statement * stmt = cast<Statement>(G[u]);
     298
    286299                    circular_buffer<PabloAST *> Q(V.size());
    287300                    for (PabloAST * var : V) {
     
    309322                        }
    310323                    }
    311                     stmt->replaceAllUsesWith(Q.front());
     324                    stmt->replaceWith(Q.front(), true, false);
    312325                    modifiedAST = true;
    313326                }
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_automultiplexing.cpp

    r4738 r4747  
    720720void AutoMultiplexing::selectMultiplexSets(RNG &) {
    721721
    722 
    723     using OutEdgeIterator = graph_traits<MultiplexSetGraph>::out_edge_iterator;
    724722    using InEdgeIterator = graph_traits<MultiplexSetGraph>::in_edge_iterator;
    725723    using degree_t = MultiplexSetGraph::degree_size_type;
     
    826824    bool hasSubsetConstraint = false;
    827825
    828     graph_traits<SubsetGraph>::edge_iterator ei, ei_end;
    829     for (std::tie(ei, ei_end) = edges(mSubsetGraph); ei != ei_end; ++ei) {
    830         const auto u = source(*ei, mSubsetGraph);
    831         const auto v = target(*ei, mSubsetGraph);
    832         graph_traits<MultiplexSetGraph>::in_edge_iterator ej, ej_end;
     826    for (auto ei : make_iterator_range(edges(mSubsetGraph))) {
     827        const auto u = source(ei, mSubsetGraph);
     828        const auto v = target(ei, mSubsetGraph);
    833829        // If both the source and target of ei are adjacent to the same vertex, that vertex must be the
    834830        // "set vertex". Add the edge between the vertices.
    835         for (std::tie(ej, ej_end) = in_edges(u, mMultiplexSetGraph); ej != ej_end; ++ej) {
    836             auto w = target(*ej, mMultiplexSetGraph);
     831        for (auto ej : make_iterator_range(in_edges(u, mMultiplexSetGraph))) {
     832            auto w = target(ej, mMultiplexSetGraph);
    837833            // Only check (v, w) if w is a "set vertex".
    838834            if (w >= (n - m) && edge(v, w, mMultiplexSetGraph).second) {
Note: See TracChangeset for help on using the changeset viewer.