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

Temporary check in.

File:
1 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                }
Note: See TracChangeset for help on using the changeset viewer.