Ignore:
Timestamp:
Nov 5, 2015, 4:41:37 PM (4 years ago)
Author:
nmedfort
Message:

Back up check in. Memory leaks should be fixed.

File:
1 edited

Legend:

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

    r4822 r4860  
    1616#include <queue>
    1717#include <unordered_set>
    18 #include <pablo/optimizers/pablo_simplifier.hpp>
    1918#include <pablo/optimizers/booleanreassociationpass.h>
    2019#include <pablo/analysis/pabloverifier.hpp>
     
    165164        #endif
    166165
    167         Simplifier::optimize(function);
     166        BooleanReassociationPass::optimize(function);
    168167    }
    169168
     
    994993 * @brief multiplexSelectedIndependentSets
    995994 ** ------------------------------------------------------------------------------------------------------------- */
    996 void AutoMultiplexing::multiplexSelectedIndependentSets(PabloFunction & function) {
     995void AutoMultiplexing::multiplexSelectedIndependentSets(PabloFunction &) {
    997996
    998997    const unsigned first_set = num_vertices(mConstraintGraph);
     
    11001099        }
    11011100    }
    1102 
    1103     for (PabloBlock * block : modified) {
    1104         topologicalSort(function, *block);
    1105     }
    1106 }
    1107 
    1108 ///** ------------------------------------------------------------------------------------------------------------- *
    1109 // * @brief printGraph
    1110 // ** ------------------------------------------------------------------------------------------------------------- */
    1111 //template <class Graph>
    1112 //static void printGraph(const PabloBlock & block, const Graph & G, const std::string name) {
    1113 //    raw_os_ostream out(std::cerr);
    1114 
    1115 //    out << "digraph " << name << " {\n";
    1116 //    for (auto u : make_iterator_range(vertices(G))) {
    1117 //        if (in_degree(u, G) == 0 && out_degree(u, G) == 0) {
    1118 //            continue;
    1119 //        }
    1120 //        out << "v" << u << " [label=\"" << u << ": ";
    1121 //        PabloAST * const expr = G[u];
    1122 //        if (isa<Statement>(expr)) {
    1123 //            if (LLVM_UNLIKELY(isa<If>(expr))) {
    1124 //                out << "If ";
    1125 //                PabloPrinter::print(cast<If>(expr)->getOperand(0), out);
    1126 //                out << ":";
    1127 //            } else if (LLVM_UNLIKELY(isa<While>(expr))) {
    1128 //                out << "While ";
    1129 //                PabloPrinter::print(cast<While>(expr)->getOperand(0), out);
    1130 //                out << ":";
    1131 //            } else {
    1132 //                PabloPrinter::print(cast<Statement>(expr), "", out);
    1133 //            }
    1134 //        } else {
    1135 //            PabloPrinter::print(expr, out);
    1136 //        }
    1137 //        out << "\"";
    1138 //        if (!isa<Statement>(expr) || cast<Statement>(expr)->getParent() != &block) {
    1139 //            out << " style=dashed";
    1140 //        }
    1141 //        out << "];\n";
    1142 //    }
    1143 //    for (auto e : make_iterator_range(edges(G))) {
    1144 //        const auto s = source(e, G);
    1145 //        const auto t = target(e, G);
    1146 //        out << "v" << s << " -> v" << t << ";\n";
    1147 //    }
    1148 
    1149 //    if (num_vertices(G) > 0) {
    1150 
    1151 //        out << "{ rank=same;";
    1152 //        for (auto u : make_iterator_range(vertices(G))) {
    1153 //            if (in_degree(u, G) == 0 && out_degree(u, G) != 0) {
    1154 //                out << " v" << u;
    1155 //            }
    1156 //        }
    1157 //        out << "}\n";
    1158 
    1159 //        out << "{ rank=same;";
    1160 //        for (auto u : make_iterator_range(vertices(G))) {
    1161 //            if (out_degree(u, G) == 0 && in_degree(u, G) != 0) {
    1162 //                out << " v" << u;
    1163 //            }
    1164 //        }
    1165 //        out << "}\n";
    1166 
    1167 //    }
    1168 
    1169 //    out << "}\n\n";
    1170 //    out.flush();
    1171 //}
    1172 
    1173 /** ------------------------------------------------------------------------------------------------------------- *
    1174  * @brief topologicalSort
    1175  ** ------------------------------------------------------------------------------------------------------------- */
    1176 void AutoMultiplexing::topologicalSort(PabloFunction &, PabloBlock & block) const {
    1177 
    1178     TopologicalGraph G;
    1179     TopologicalMap M;
    1180     // Compute the base def-use graph ...
    1181     for (Statement * stmt : block) {       
    1182         const TopologicalVertex u = getVertex(stmt, G, M);
    1183         if (isa<If>(stmt)) {
    1184             for (Assign * def : cast<const If>(stmt)->getDefined()) {
    1185                 resolveUsages(u, def, block, G, M, stmt);
    1186             }
    1187         } else if (isa<While>(stmt)) {
    1188             for (Next * var : cast<const While>(stmt)->getVariants()) {
    1189                 resolveUsages(u, var, block, G, M, stmt);
    1190             }
    1191         } else {
    1192             resolveUsages(u, stmt, block, G, M, nullptr);
    1193         }
    1194     }
    1195 
    1196     circular_buffer<TopologicalVertex> Q(num_vertices(G));
    1197     topological_sort(G, std::back_inserter(Q));
    1198 
    1199     block.setInsertPoint(nullptr);
    1200     while (!Q.empty()) {
    1201         Statement * stmt = G[Q.back()];
    1202         Q.pop_back();
    1203         if (stmt->getParent() == &block) {
    1204             block.insert(stmt);
    1205         }
    1206     }
    1207 
    1208 }
    1209 
    1210 /** ------------------------------------------------------------------------------------------------------------- *
    1211  * @brief resolveUsages
    1212  ** ------------------------------------------------------------------------------------------------------------- */
    1213 void AutoMultiplexing::resolveUsages(const TopologicalVertex u, Statement * expr, PabloBlock & block, TopologicalGraph & G, TopologicalMap & M, Statement * ignoreIfThis) const {
    1214     for (PabloAST * user : expr->users()) {
    1215         if (LLVM_LIKELY(user != ignoreIfThis && isa<Statement>(user))) {
    1216             PabloBlock * parent = cast<Statement>(user)->getParent();
    1217             assert (parent);
    1218             if (LLVM_LIKELY(parent == &block)) {
    1219                 add_edge(u, getVertex(cast<Statement>(user), G, M), G);
    1220             } else {
    1221                 for (;;) {
    1222                     if (LLVM_UNLIKELY(parent == nullptr)) {
    1223                         assert (isa<Assign>(expr) || isa<Next>(expr));
    1224                         break;
    1225                     } else if (parent->getParent() == &block) {
    1226                         const auto f = mResolvedScopes.find(parent);
    1227                         if (LLVM_UNLIKELY(f == mResolvedScopes.end())) {
    1228                             throw std::runtime_error("Failed to resolve scope block!");
    1229                         }
    1230                         Statement * const branch = f->second;
    1231                         if (LLVM_UNLIKELY(branch != ignoreIfThis)) {
    1232                             add_edge(u, getVertex(branch, G, M), G);
    1233                         }
    1234                         break;
    1235                     }
    1236                     parent = parent->getParent();
    1237                 }
    1238             }
    1239         }
    1240     }
    1241 }
    1242 
    1243 /** ------------------------------------------------------------------------------------------------------------- *
    1244  * @brief getVertex
    1245  ** ------------------------------------------------------------------------------------------------------------- */
    1246 AutoMultiplexing::TopologicalVertex AutoMultiplexing::getVertex(Statement * expr, TopologicalGraph & G, TopologicalMap & M) {
    1247     const auto f = M.find(expr);
    1248     if (f != M.end()) {
    1249         return f->second;
    1250     }
    1251     const auto u = add_vertex(expr, G);
    1252     M.emplace(expr, u);
    1253     return u;
    12541101}
    12551102
Note: See TracChangeset for help on using the changeset viewer.