Ignore:
Timestamp:
Aug 12, 2015, 5:02:38 PM (4 years ago)
Author:
nmedfort
Message:

Temporary check in

File:
1 edited

Legend:

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

    r4722 r4724  
    170170//        RECORD_TIMESTAMP(end_topological_sort2);
    171171//        LOG("TopologicalSort (2):     " << (end_topological_sort2 - start_topological_sort2));
     172
    172173    }
    173174
     
    988989            const size_t m = log2_plus_one(n);
    989990            Advance * input[n];
    990             std::vector<PabloAST *> muxed(m);
     991            std::vector<Advance *> muxed(m);
    991992
    992993            graph_traits<MultiplexSetGraph>::out_edge_iterator ei, ei_end;
     
    10271028                // The only way this did not return an Advance statement would be if either the mux or shift amount
    10281029                // is zero. Since these cases would have been eliminated earlier, we are safe to cast here.               
    1029                 muxed[j] = builder.createAdvance(mux, adv->getOperand(1), prefix.str());
     1030                muxed[j] = cast<Advance>(builder.createAdvance(mux, adv->getOperand(1), prefix.str()));
    10301031            }
    10311032
     
    10871088    raw_os_ostream out(std::cerr);
    10881089
    1089     PabloPrinter::print(function.getEntryBlock(), "", out);
    1090     out << "\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n";
    1091     out.flush();
    1092 
    1093 
    10941090    // TODO: this should build a single graph and iterate by connected component instead.
    10951091    for (const auto & muxed : mMuxedVariables) {
     
    10981094        std::unordered_map<PabloAST *, unsigned> M;
    10991095        std::queue<Statement *> Q;
     1096
     1097        out << "-----------------------------------------------------------------------------------\n";
     1098        PabloPrinter::print(function.getEntryBlock().statements(), out);
     1099        out << "-----------------------------------------------------------------------------------\n"; out.flush();
     1100
    11001101
    11011102        for (unsigned i = 0; i != muxed.size(); ++i) {
     
    11261127        while (!Q.empty()) {
    11271128            Statement * const var = Q.front(); Q.pop();
     1129
     1130
    11281131            const Vertex u = M[var];
    11291132            for (unsigned i = 0; i != var->getNumOperands(); ++i) {
     
    11611164        }
    11621165
     1166        for (auto u : make_iterator_range(vertices(G))) {
     1167            PabloAST * expr = G[u];
     1168            switch (expr->getClassTypeId()) {
     1169                case PabloAST::ClassTypeId::And:
     1170                case PabloAST::ClassTypeId::Or:
     1171                case PabloAST::ClassTypeId::Not:
     1172                case PabloAST::ClassTypeId::Sel:
     1173                    break;
     1174                default: // this vertex corresponds to a non-Boolean function. It needs to be split.
     1175                    if (in_degree(u, G) > 0 && out_degree(u, G) > 0) {
     1176                        Vertex v = add_vertex(expr, G);
     1177                        for (auto e : make_iterator_range(out_edges(u, G))) {
     1178                            add_edge(v, target(e, G), G);
     1179                        }
     1180                        clear_out_edges(u, G);
     1181                    }
     1182            }
     1183        }
     1184
     1185        out << "\ndigraph x {\n";
     1186        for (auto u : make_iterator_range(vertices(G))) {
     1187            std::string tmp;
     1188            raw_string_ostream name(tmp);
     1189            PabloPrinter::print(G[u], name);
     1190            out << "v" << u << " [label=\"" << name.str() << "\"];\n";
     1191        }
     1192        for (auto e : make_iterator_range(edges(G))) {
     1193            out << "v" << source(e, G) << " -> v" << target(e, G) << '\n';
     1194        }
     1195
     1196        out << " { rank=same;";
     1197        for (auto u : make_iterator_range(vertices(G))) {
     1198            if (in_degree(u, G) == 0) {
     1199                out << " v" << u;
     1200            }
     1201        }
     1202        out << "}\n";
     1203
     1204        out << " { rank=same;";
     1205        for (auto u : make_iterator_range(vertices(G))) {
     1206            if (out_degree(u, G) == 0) {
     1207                out << " v" << u;
     1208            }
     1209        }
     1210        out << "}\n";
     1211
     1212        out << "}\n\n";
     1213        out.flush();
     1214
    11631215        // count the number of sources (sinks) so we know how many variables (terminals) will exist in the BDD
    11641216        std::vector<Vertex> inputs;
    11651217        flat_set<Vertex> terminals;
     1218
    11661219        for (auto u : make_iterator_range(vertices(G))) {
    11671220            if (in_degree(u, G) == 0) {
     
    11751228            }
    11761229        }
     1230
     1231
     1232
    11771233
    11781234        const auto n = inputs.size();
     
    12071263                input[i] = characterization[source(e, G)];
    12081264                if (input[i] == nullptr) {
    1209                     throw std::runtime_error("Uncharacterized input!");
     1265                    std::string tmp;
     1266                    raw_string_ostream out(tmp);
     1267                    out << "Uncharacterized input! ";
     1268                    PabloPrinter::print(G[source(e, G)], out);
     1269                    throw std::runtime_error(out.str());
    12101270                }
    12111271                ++i;
     
    12361296        }
    12371297
    1238         Cudd_AutodynDisable(mManager);
    12391298        assert (Cudd_DebugCheck(mManager) == 0);
    12401299        Cudd_ReduceHeap(mManager, CUDD_REORDER_SIFT, 0);
    1241 
    1242         mSimplifyDepth = 0;
    12431300
    12441301        assert (mManager->size == nodes.size());
     
    12921349        DdNode * h = Cudd_Cofactor(mManager, f, g);
    12931350        Cudd_Ref(h);
    1294         Cudd_RecursiveDeref(mManager, g);
    12951351        PabloAST * c1 = simplifyAST(h, variables, builder);
    1296         Cudd_RecursiveDeref(mManager, h);
    12971352        if (LLVM_UNLIKELY(c1 == nullptr)) {
     1353            Cudd_RecursiveDeref(mManager, g);
     1354            Cudd_RecursiveDeref(mManager, h);
    12981355            cast<Statement>(c0)->eraseFromParent(true);
    12991356            return nullptr;
    13001357        }
    1301         return builder.createAnd(c0, c1);
     1358        assert (And(g, h) == f);
     1359        Cudd_RecursiveDeref(mManager, g);
     1360        Cudd_RecursiveDeref(mManager, h);
     1361        return builder.createAnd(c0, c1, "escf");
    13021362    }
    13031363
     
    13161376    }
    13171377
    1318     DdNode ** decomp = nullptr;
     1378    DdNode * decomp[] = { nullptr, nullptr };
    13191379    if (disjuncts == 2) {
    1320         FREE(conjunct); conjunct = nullptr; decomp = disjunct;
     1380        memcpy(decomp, disjunct, sizeof(DdNode *) * 2);
    13211381    } else if (conjuncts == 2) {
    1322         FREE(disjunct); disjunct = nullptr; decomp = conjunct;
    1323     }
    1324 
    1325     if (decomp && (decomp[0] != decomp[1]) && (decomp[0] != f) && (decomp[1] != f)) {
     1382        memcpy(decomp, conjunct, sizeof(DdNode *) * 2);
     1383    }
     1384
     1385    FREE(disjunct);
     1386    FREE(conjunct);
     1387
     1388    if ((decomp[0] != decomp[1]) && (decomp[0] != f) && (decomp[1] != f)) {
    13261389        Cudd_Ref(decomp[0]);
    13271390        Cudd_Ref(decomp[1]);
     
    13351398        PabloAST * d1 = simplifyAST(decomp[1], variables, builder);
    13361399        Cudd_RecursiveDeref(mManager, decomp[1]);
    1337         FREE(decomp);
    13381400        if (LLVM_UNLIKELY(d1 == nullptr)) {
    13391401            cast<Statement>(d0)->eraseFromParent(true);
     
    13411403        }
    13421404
    1343         std::cerr << "d0: " << (ptruint)(d0) << "  d1: " << (ptruint)(d1) << " disjunct: " << (disjunct != 0) << " conjunct: " << (conjunct != 0) << std::endl;
    1344 
    1345         if (disjunct) {
    1346             return builder.createOr(d0, d1);
     1405        if (disjuncts == 2) {
     1406            return builder.createOr(d0, d1, "disj");
    13471407        } else {
    1348             return builder.createAnd(d0, d1);
     1408            return builder.createAnd(d0, d1, "conj");
    13491409        }
    13501410    }
     
    14071467
    14081468        for (auto i = 0; i != n; ++i) {
     1469            assert (cube[i] >= 0 && cube[i] <= 2);
    14091470            if (cube[i] == 0) {
    14101471                assert (!DQ.full());
     
    14171478
    14181479        if (LLVM_UNLIKELY(DQ.empty() && CQ.empty())) {
    1419             continue;
     1480            throw std::runtime_error("Error! statement contains no elements!");
    14201481        }
    14211482
     
    14401501    Cudd_RecursiveDeref(mManager, g);
    14411502    if (LLVM_UNLIKELY(SQ.empty())) {
    1442         return nullptr;
     1503        throw std::runtime_error("Error! statement queue empty!");
    14431504    }
    14441505    while (SQ.size() > 1) {
Note: See TracChangeset for help on using the changeset viewer.