From fbf8bcf38f4cc6ea11f4b6461531deb17bd9765c Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Thu, 1 Dec 2022 01:59:16 +0100 Subject: [PATCH 01/14] Add insbuf -chain mode Signed-off-by: Claire Xenia Wolf --- passes/techmap/insbuf.cc | 40 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) diff --git a/passes/techmap/insbuf.cc b/passes/techmap/insbuf.cc index 68c22c317..f288987a1 100644 --- a/passes/techmap/insbuf.cc +++ b/passes/techmap/insbuf.cc @@ -36,12 +36,16 @@ struct InsbufPass : public Pass { log(" Use the given cell type instead of $_BUF_. (Notice that the next\n"); log(" call to \"clean\" will remove all $_BUF_ in the design.)\n"); log("\n"); + log(" -chain\n"); + log(" Chain buffer cells\n"); + log("\n"); } void execute(std::vector args, RTLIL::Design *design) override { log_header(design, "Executing INSBUF pass (insert buffer cells for connected wires).\n"); IdString celltype = ID($_BUF_), in_portname = ID::A, out_portname = ID::Y; + bool chain_mode = false; size_t argidx; for (argidx = 1; argidx < args.size(); argidx++) @@ -53,6 +57,10 @@ struct InsbufPass : public Pass { out_portname = RTLIL::escape_id(args[++argidx]); continue; } + if (arg == "-chain") { + chain_mode = true; + continue; + } break; } extra_args(args, argidx, design); @@ -60,6 +68,8 @@ struct InsbufPass : public Pass { for (auto module : design->selected_modules()) { std::vector new_connections; + pool bufcells; + SigMap sigmap; for (auto &conn : module->connections()) { @@ -70,22 +80,48 @@ struct InsbufPass : public Pass { SigBit lhs = conn.first[i]; SigBit rhs = conn.second[i]; - if (lhs.wire && !design->selected(module, lhs.wire)) { + if (!lhs.wire || !design->selected(module, lhs.wire)) { new_conn.first.append(lhs); new_conn.second.append(rhs); + log("Skip %s: %s -> %s\n", log_id(module), log_signal(rhs), log_signal(lhs)); continue; } + if (chain_mode && rhs.wire) { + rhs = sigmap(rhs); + SigBit outbit = sigmap(lhs); + sigmap.add(lhs, rhs); + sigmap.add(outbit); + } + Cell *cell = module->addCell(NEW_ID, celltype); cell->setPort(in_portname, rhs); cell->setPort(out_portname, lhs); - log("Added %s.%s: %s -> %s\n", log_id(module), log_id(cell), log_signal(rhs), log_signal(lhs)); + + log("Add %s/%s: %s -> %s\n", log_id(module), log_id(cell), log_signal(rhs), log_signal(lhs)); + bufcells.insert(cell); } if (GetSize(new_conn.first)) new_connections.push_back(new_conn); } + if (chain_mode) { + for (auto &cell : module->selected_cells()) { + if (bufcells.count(cell)) + continue; + for (auto &port : cell->connections()) + if (cell->input(port.first)) { + auto s = sigmap(port.second); + if (s == port.second) + continue; + log("Rewrite %s/%s/%s: %s -> %s\n", log_id(module), log_id(cell), + log_id(port.first), log_signal(port.second), log_signal(s)); + cell->setPort(port.first, s); + } + } + } + module->new_connections(new_connections); } } From 92fc6cd4a9b5aa0085879b105b9b75fcd275f712 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Sun, 4 Dec 2022 01:33:04 +0100 Subject: [PATCH 02/14] Add splitcells pass Signed-off-by: Claire Xenia Wolf --- passes/cmds/Makefile.inc | 1 + passes/cmds/splitcells.cc | 191 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 192 insertions(+) create mode 100644 passes/cmds/splitcells.cc diff --git a/passes/cmds/Makefile.inc b/passes/cmds/Makefile.inc index 8c7a18d02..8807950dc 100644 --- a/passes/cmds/Makefile.inc +++ b/passes/cmds/Makefile.inc @@ -13,6 +13,7 @@ OBJS += passes/cmds/connect.o OBJS += passes/cmds/scatter.o OBJS += passes/cmds/setundef.o OBJS += passes/cmds/splitnets.o +OBJS += passes/cmds/splitcells.o OBJS += passes/cmds/stat.o OBJS += passes/cmds/setattr.o OBJS += passes/cmds/copy.o diff --git a/passes/cmds/splitcells.cc b/passes/cmds/splitcells.cc new file mode 100644 index 000000000..eb04380fe --- /dev/null +++ b/passes/cmds/splitcells.cc @@ -0,0 +1,191 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2012 Claire Xenia Wolf + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "kernel/yosys.h" +#include "kernel/sigtools.h" + +USING_YOSYS_NAMESPACE +PRIVATE_NAMESPACE_BEGIN + +struct SplitcellsWorker +{ + Module *module; + SigMap sigmap; + dict> bit_drivers_db; + dict>> bit_users_db; + + SplitcellsWorker(Module *module) : module(module), sigmap(module) + { + for (auto cell : module->cells()) { + for (auto conn : cell->connections()) { + if (!cell->output(conn.first)) continue; + for (int i = 0; i < GetSize(conn.second); i++) { + SigBit bit(sigmap(conn.second[i])); + bit_drivers_db[bit] = tuple(cell->name, conn.first, i); + } + } + } + + for (auto cell : module->cells()) { + for (auto conn : cell->connections()) { + if (!cell->input(conn.first)) continue; + for (int i = 0; i < GetSize(conn.second); i++) { + SigBit bit(sigmap(conn.second[i])); + if (!bit_drivers_db.count(bit)) continue; + bit_users_db[bit].insert(tuple(cell->name, + conn.first, i-std::get<2>(bit_drivers_db[bit]))); + } + } + } + + for (auto wire : module->wires()) { + if (!wire->name.isPublic()) continue; + SigSpec sig(sigmap(wire)); + for (int i = 0; i < GetSize(sig); i++) { + SigBit bit(sig[i]); + if (!bit_drivers_db.count(bit)) continue; + bit_users_db[bit].insert(tuple(wire->name, + IdString(), i-std::get<2>(bit_drivers_db[bit]))); + } + } + } + + int split(Cell *cell, const std::string &format) + { + if (!cell->type.in("$and", "$mux", "$not", "$or", "$pmux", "$xnor", "$xor")) return 0; + + SigSpec outsig = sigmap(cell->getPort(ID::Y)); + if (GetSize(outsig) <= 1) return 0; + + std::vector slices; + slices.push_back(0); + + for (int i = 1; i < GetSize(outsig); i++) { + auto &last_users = bit_users_db.at(outsig[slices.back()]); + auto &this_users = bit_users_db.at(outsig[i]); + if (last_users != this_users) slices.push_back(i); + } + if (GetSize(slices) <= 1) return 0; + slices.push_back(GetSize(outsig)); + + log("Splitting %s cell %s/%s into %d slices:\n", log_id(cell->type), log_id(module), log_id(cell), GetSize(slices)-1); + for (int i = 1; i < GetSize(slices); i++) + { + int slice_msb = slices[i]-1; + int slice_lsb = slices[i-1]; + + IdString slice_name = module->uniquify(cell->name.str() + (slice_msb == slice_lsb ? + stringf("%c%d%c", format[0], slice_lsb, format[1]) : + stringf("%c%d%c%d%c", format[0], slice_msb, format[2], slice_lsb, format[1]))); + + Cell *slice = module->addCell(slice_name, cell); + + auto slice_signal = [&](SigSpec old_sig) -> SigSpec { + SigSpec new_sig; + for (int i = 0; i < GetSize(old_sig); i += GetSize(outsig)) + new_sig.append(old_sig.extract(i+slice_lsb, slice_msb-slice_lsb+1)); + return new_sig; + }; + + slice->setPort(ID::A, slice_signal(slice->getPort(ID::A))); + if (slice->hasParam(ID::A_WIDTH)) + slice->setParam(ID::A_WIDTH, GetSize(slice->getPort(ID::A))); + + if (slice->hasPort(ID::B)) { + slice->setPort(ID::B, slice_signal(slice->getPort(ID::B))); + if (slice->hasParam(ID::B_WIDTH)) + slice->setParam(ID::B_WIDTH, GetSize(slice->getPort(ID::B))); + } + + slice->setPort(ID::Y, slice_signal(slice->getPort(ID::Y))); + if (slice->hasParam(ID::Y_WIDTH)) + slice->setParam(ID::Y_WIDTH, GetSize(slice->getPort(ID::Y))); + if (slice->hasParam(ID::WIDTH)) + slice->setParam(ID::WIDTH, GetSize(slice->getPort(ID::Y))); + + log(" slice %d: %s => %s\n", i, log_id(slice_name), log_signal(slice->getPort(ID::Y))); + } + + module->remove(cell); + return GetSize(slices)-1; + } +}; + +struct SplitcellsPass : public Pass { + SplitcellsPass() : Pass("splitcells", "split up multi-bit cells") { } + void help() override + { + // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---| + log("\n"); + log(" splitcells [options] [selection]\n"); + log("\n"); + log("This command splits multi-bit cells into smaller chunks, based on usage of the\n"); + log("cell output bits.\n"); + log("\n"); + log("This command operates only in cells such as $or, $and, and $mux, that are easily\n"); + log("cut into bit-slices.\n"); + log("\n"); + log(" -format char1[char2[char3]]\n"); + log(" the first char is inserted between the cell name and the bit index, the\n"); + log(" second char is appended to the cell name. e.g. -format () creates cell\n"); + log(" names like 'mycell(42)'. the 3rd character is the range separation\n"); + log(" character when creating multi-bit cells. the default is '[]:'.\n"); + log("\n"); + } + void execute(std::vector args, RTLIL::Design *design) override + { + std::string format; + + log_header(design, "Executing SPLITCELLS pass (splitting up multi-bit cells).\n"); + + size_t argidx; + for (argidx = 1; argidx < args.size(); argidx++) + { + if (args[argidx] == "-format" && argidx+1 < args.size()) { + format = args[++argidx]; + continue; + } + break; + } + extra_args(args, argidx, design); + + if (GetSize(format) < 1) format += "["; + if (GetSize(format) < 2) format += "]"; + if (GetSize(format) < 3) format += ":"; + + for (auto module : design->selected_modules()) + { + SplitcellsWorker worker(module); + int count_split_pre = 0; + int count_split_post = 0; + + for (auto cell : module->selected_cells()) { + int n = worker.split(cell, format); + count_split_pre += (n != 0); + count_split_post += n; + } + + if (count_split_pre) + log("Split %d cells in module %s into %d cell slices.\n", + count_split_pre, log_id(module), count_split_post); + } + } +} SplitnetsPass; + +PRIVATE_NAMESPACE_END From c9f4b06cb2256fc26b9a5c4a4070985e615388dd Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Sun, 4 Dec 2022 11:35:10 +0100 Subject: [PATCH 03/14] Add "viz" pass for visualizing big-picture data flow in larger designs Signed-off-by: Claire Xenia Wolf --- passes/cmds/Makefile.inc | 1 + passes/cmds/viz.cc | 510 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 511 insertions(+) create mode 100644 passes/cmds/viz.cc diff --git a/passes/cmds/Makefile.inc b/passes/cmds/Makefile.inc index 8807950dc..29b3a1132 100644 --- a/passes/cmds/Makefile.inc +++ b/passes/cmds/Makefile.inc @@ -7,6 +7,7 @@ OBJS += passes/cmds/delete.o OBJS += passes/cmds/design.o OBJS += passes/cmds/select.o OBJS += passes/cmds/show.o +OBJS += passes/cmds/viz.o OBJS += passes/cmds/rename.o OBJS += passes/cmds/autoname.o OBJS += passes/cmds/connect.o diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc new file mode 100644 index 000000000..83919b50a --- /dev/null +++ b/passes/cmds/viz.cc @@ -0,0 +1,510 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2012 Claire Xenia Wolf + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "kernel/yosys.h" +#include "kernel/sigtools.h" + +#ifndef _WIN32 +# include +#endif + +#ifdef __APPLE__ +# include +#endif + +#ifdef YOSYS_ENABLE_READLINE +# include +#endif + +#ifdef YOSYS_ENABLE_EDITLINE +# include +#endif + +USING_YOSYS_NAMESPACE +PRIVATE_NAMESPACE_BEGIN + +struct GraphNode { + int index = -1; + bool terminal = false; + GraphNode *replaced = nullptr; + + GraphNode *get() { + if (replaced == nullptr) + return this; + return replaced = replaced->get(); + } + + pool names_; + pool upstream_; + pool downstream_; + + pool &names() { return get()->names_; } + pool &upstream() { return get()->upstream_; } + pool &downstream() { return get()->downstream_; } + + void replace(GraphNode *g) { + if (replaced) return get()->replace(g); + + if (this == g->get()) return; + log_assert(terminal == g->terminal); + + for (auto v : g->names()) + names().insert(v); + + for (auto v : g->upstream()) { + auto n = v->get(); + if (n == this) continue; + upstream().insert(n); + } + + for (auto v : g->downstream()) { + auto n = v->get(); + if (n == this) continue; + downstream().insert(n); + } + + g->names().clear(); + g->upstream().clear(); + g->downstream().clear(); + + g->get()->replaced = this; + } + + void cleanup() { + if (replaced) return; + + pool new_upstream; + pool new_downstream; + + for (auto g : upstream_) { + auto n = g->get(); + if (n == this) continue; + new_upstream.insert(n); + } + for (auto g : downstream_) { + auto n = g->get(); + if (n == this) continue; + new_downstream.insert(n); + } + + std::swap(upstream_, new_upstream); + std::swap(downstream_, new_downstream); + } +}; + +struct Graph { + int term_nodes_cnt; + int nonterm_nodes_cnt; + + vector nodes; + vector replaced_nodes; + + ~Graph() + { + for (auto n : nodes) delete n; + for (auto n : replaced_nodes) delete n; + } + + void cleanup() + { + vector new_nodes; + + term_nodes_cnt = 0; + nonterm_nodes_cnt = 0; + + for (auto n : nodes) { + if (n->replaced) { + replaced_nodes.push_back(n); + } else { + if (n->terminal) + term_nodes_cnt++; + else + nonterm_nodes_cnt++; + n->cleanup(); + n->index = GetSize(new_nodes); + new_nodes.push_back(n); + } + } + + std::swap(nodes, new_nodes); + } + + bool merge_simple() + { + bool did_something = false; + while (true) { + vector> queued_merges; + typedef pair, pool> node_conn_t; + dict> nodes_by_conn[2]; + + for (auto g : nodes) { + if (g->replaced) continue; + + nodes_by_conn[g->terminal][node_conn_t(g->upstream(), g->downstream())].insert(g); + + if (GetSize(g->downstream()) == 1) { + auto n = (*g->downstream().begin())->get(); + if (g->terminal != n->terminal) continue; + queued_merges.push_back(pair(g, n)); + } + + if (GetSize(g->upstream()) == 1) { + auto n = (*g->upstream().begin())->get(); + if (g->terminal != n->terminal) continue; + queued_merges.push_back(pair(g, n)); + } + + for (auto n : g->downstream()) { + if (g->terminal != n->terminal) continue; + if (!n->downstream().count(g)) continue; + queued_merges.push_back(pair(g, n)); + } + } + + for (int term = 0; term < 2; term++) { + for (auto &grp : nodes_by_conn[term]) { + auto it = grp.second.begin(); + auto first = *it; + while (++it != grp.second.end()) + queued_merges.push_back(pair(first, *it)); + } + } + + int count_merges = 0; + for (auto m : queued_merges) { + auto g = m.first->get(), n = m.second->get(); + if (g == n) continue; + g->replace(n); + count_merges++; + } + if (count_merges == 0) return did_something; + + log(" Replaced %d nodes in merge_simple().\n", count_merges); + did_something = true; + cleanup(); + } + } + + Graph(Module *module) + { + SigMap sigmap(module); + dict wire_nodes; + + for (auto wire : module->selected_wires()) + { + if (!wire->name.isPublic()) continue; + auto g = new GraphNode; + g->terminal = true; + g->names().insert(wire->name); + nodes.push_back(g); + + for (auto bit : sigmap(wire)) { + if (!bit.wire) continue; + auto it = wire_nodes.find(bit); + if (it == wire_nodes.end()) + wire_nodes[bit] = g; + else + g->replace(it->second); + } + } + + dict cell_nodes; + dict> sig_users; + + for (auto cell : module->selected_cells()) { + auto g = new GraphNode; + cell_nodes[cell] = g; + g->names().insert(cell->name); + nodes.push_back(g); + + for (auto &conn : cell->connections()) { + if (cell->input(conn.first)) + for (auto bit : sigmap(conn.second)) { + if (!bit.wire) continue; + auto it = wire_nodes.find(bit); + if (it != wire_nodes.end()) { + g->upstream().insert(it->second); + it->second->downstream().insert(g); + } + sig_users[bit].insert(g); + } + if (cell->output(conn.first)) + for (auto bit : sigmap(conn.second)) { + if (!bit.wire) continue; + auto it = wire_nodes.find(bit); + if (it != wire_nodes.end()) { + g->downstream().insert(it->second); + it->second->upstream().insert(g); + } + } + } + } + + for (auto cell : module->selected_cells()) { + auto g = cell_nodes.at(cell); + + for (auto &conn : cell->connections()) { + if (!cell->output(conn.first)) continue; + for (auto bit : sigmap(conn.second)) { + if (!bit.wire) continue; + for (auto u : sig_users[bit]) { + g->downstream().insert(u); + u->upstream().insert(g); + } + } + } + } + + cleanup(); + } +}; + +struct VizWorker +{ + FILE *f; + Graph graph; + + VizWorker(FILE *f, Module *module) : graph(module) + { + log("Running Viz for module %s:\n", log_id(module)); + log(" Initial number of terminal nodes is %d.\n", graph.term_nodes_cnt); + log(" Initial number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + + graph.merge_simple(); + + log(" Final number of terminal nodes is %d.\n", graph.term_nodes_cnt); + log(" Final number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + + fprintf(f, "digraph \"%s\" {", log_id(module)); + fprintf(f, " rankdir = LR;"); + + for (int i = 0; i < GetSize(graph.nodes); i++) { + auto g = graph.nodes[i]; + if (g->terminal) { + std::string label; + for (auto n : g->names()) { + if (!label.empty()) + label += "\\n"; + label += log_id(n); + } + fprintf(f, "\tn%d [shape=octagon,label=\"%s\"];\n", g->index, label.c_str()); + } else { + fprintf(f, "\tn%d [label=\"%d cells\"];\n", g->index, GetSize(g->names())); + } + } + + for (int i = 0; i < GetSize(graph.nodes); i++) { + auto g = graph.nodes[i]; + for (auto n : g->downstream()) { + if (g->terminal && !n->terminal && n->downstream().count(g)) continue; + fprintf(f, "\tn%d -> n%d;\n", g->index, n->index); + } + } + + fprintf(f, "}"); + } +}; + +struct VizPass : public Pass { + VizPass() : Pass("viz", "visualize data flow graph") { } + void help() override + { + // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---| + log("\n"); + log(" viz [options] [selection]\n"); + log("\n"); + log("Create a graphviz DOT file for the selected part of the design, showing the\n"); + log("relationships between the selected wires, and compile it to a graphics\n"); + log("file (usually SVG or PostScript).\n"); + log("\n"); + log(" -viewer \n"); + log(" Run the specified command with the graphics file as parameter.\n"); + log(" On Windows, this pauses yosys until the viewer exits.\n"); + log("\n"); + log(" -format \n"); + log(" Generate a graphics file in the specified format. Use 'dot' to just\n"); + log(" generate a .dot file, or other strings such as 'svg' or 'ps'\n"); + log(" to generate files in other formats (this calls the 'dot' command).\n"); + log("\n"); + log(" -prefix \n"); + log(" generate .* instead of ~/.yosys_show.*\n"); + log("\n"); + log(" -pause\n"); + log(" wait for the user to press enter to before returning\n"); + log("\n"); + log(" -nobg\n"); + log(" don't run viewer in the background, IE wait for the viewer tool to\n"); + log(" exit before returning\n"); + log("\n"); + log("When no is specified, 'dot' is used. When no and is\n"); + log("specified, 'xdot' is used to display the schematic (POSIX systems only).\n"); + log("\n"); + log("The generated output files are '~/.yosys_show.dot' and '~/.yosys_show.',\n"); + log("unless another prefix is specified using -prefix .\n"); + log("\n"); + log("Yosys on Windows and YosysJS use different defaults: The output is written\n"); + log("to 'show.dot' in the current directory and new viewer is launched each time\n"); + log("the 'show' command is executed.\n"); + log("\n"); + } + void execute(std::vector args, RTLIL::Design *design) override + { + log_header(design, "Generating Graphviz representation of design.\n"); + log_push(); + +#if defined(_WIN32) || defined(YOSYS_DISABLE_SPAWN) + std::string format = "dot"; + std::string prefix = "show"; +#else + std::string format; + std::string prefix = stringf("%s/.yosys_show", getenv("HOME") ? getenv("HOME") : "."); +#endif + std::string viewer_exe; + bool flag_pause = false; + bool custom_prefix = false; + std::string background = "&"; + RTLIL::IdString colorattr; + + size_t argidx; + for (argidx = 1; argidx < args.size(); argidx++) + { + std::string arg = args[argidx]; + if (arg == "-viewer" && argidx+1 < args.size()) { + viewer_exe = args[++argidx]; + continue; + } + if (arg == "-prefix" && argidx+1 < args.size()) { + prefix = args[++argidx]; + custom_prefix = true; + continue; + } + if (arg == "-format" && argidx+1 < args.size()) { + format = args[++argidx]; + continue; + } + if (arg == "-pause") { + flag_pause= true; + continue; + } + if (arg == "-nobg") { + background= ""; + continue; + } + break; + } + extra_args(args, argidx, design); + + int modcount = 0; + for (auto module : design->selected_modules()) { + if (module->get_blackbox_attribute()) + continue; + if (module->cells().size() == 0 && module->connections().empty()) + continue; + modcount++; + } + if (format != "ps" && format != "dot" && modcount > 1) + log_cmd_error("For formats different than 'ps' or 'dot' only one module must be selected.\n"); + if (modcount == 0) + log_cmd_error("Nothing there to show.\n"); + + std::string dot_file = stringf("%s.dot", prefix.c_str()); + std::string out_file = stringf("%s.%s", prefix.c_str(), format.empty() ? "svg" : format.c_str()); + + log("Writing dot description to `%s'.\n", dot_file.c_str()); + FILE *f = fopen(dot_file.c_str(), "w"); + if (custom_prefix) + yosys_output_files.insert(dot_file); + if (f == nullptr) { + log_cmd_error("Can't open dot file `%s' for writing.\n", dot_file.c_str()); + } + for (auto module : design->selected_modules()) { + if (module->get_blackbox_attribute()) + continue; + if (module->cells().size() == 0 && module->connections().empty()) + continue; + VizWorker worker(f, module); + } + fclose(f); + + if (format != "dot" && !format.empty()) { + #ifdef _WIN32 + // system()/cmd.exe does not understand single quotes on Windows. + #define DOT_CMD "dot -T%s \"%s\" > \"%s.new\" && move \"%s.new\" \"%s\"" + #else + #define DOT_CMD "dot -T%s '%s' > '%s.new' && mv '%s.new' '%s'" + #endif + std::string cmd = stringf(DOT_CMD, format.c_str(), dot_file.c_str(), out_file.c_str(), out_file.c_str(), out_file.c_str()); + #undef DOT_CMD + log("Exec: %s\n", cmd.c_str()); + #if !defined(YOSYS_DISABLE_SPAWN) + if (run_command(cmd) != 0) + log_cmd_error("Shell command failed!\n"); + #endif + } + + #if defined(YOSYS_DISABLE_SPAWN) + log_assert(viewer_exe.empty() && !format.empty()); + #else + if (!viewer_exe.empty()) { + #ifdef _WIN32 + // system()/cmd.exe does not understand single quotes nor + // background tasks on Windows. So we have to pause yosys + // until the viewer exits. + std::string cmd = stringf("%s \"%s\"", viewer_exe.c_str(), out_file.c_str()); + #else + std::string cmd = stringf("%s '%s' %s", viewer_exe.c_str(), out_file.c_str(), background.c_str()); + #endif + log("Exec: %s\n", cmd.c_str()); + if (run_command(cmd) != 0) + log_cmd_error("Shell command failed!\n"); + } else + if (format.empty()) { + #ifdef __APPLE__ + std::string cmd = stringf("ps -fu %d | grep -q '[ ]%s' || xdot '%s' %s", getuid(), dot_file.c_str(), dot_file.c_str(), background.c_str()); + #else + std::string cmd = stringf("{ test -f '%s.pid' && fuser -s '%s.pid' 2> /dev/null; } || ( echo $$ >&3; exec xdot '%s'; ) 3> '%s.pid' %s", dot_file.c_str(), dot_file.c_str(), dot_file.c_str(), dot_file.c_str(), background.c_str()); + #endif + log("Exec: %s\n", cmd.c_str()); + if (run_command(cmd) != 0) + log_cmd_error("Shell command failed!\n"); + } + #endif + + if (flag_pause) { + #ifdef YOSYS_ENABLE_READLINE + char *input = nullptr; + while ((input = readline("Press ENTER to continue (or type 'shell' to open a shell)> ")) != nullptr) { + if (input[strspn(input, " \t\r\n")] == 0) + break; + char *p = input + strspn(input, " \t\r\n"); + if (!strcmp(p, "shell")) { + Pass::call(design, "shell"); + break; + } + } + #else + log_cmd_error("This version of yosys is built without readline support => 'show -pause' is not available.\n"); + #endif + } + + log_pop(); + } +} VizPass; + +PRIVATE_NAMESPACE_END From e151e44caa66b3d0746524b7fc4021561380c8f9 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Sun, 4 Dec 2022 19:32:31 +0100 Subject: [PATCH 04/14] Improvements in "viz" command Signed-off-by: Claire Xenia Wolf --- passes/cmds/viz.cc | 271 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 211 insertions(+), 60 deletions(-) diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc index 83919b50a..4930ff783 100644 --- a/passes/cmds/viz.cc +++ b/passes/cmds/viz.cc @@ -41,6 +41,7 @@ PRIVATE_NAMESPACE_BEGIN struct GraphNode { int index = -1; + bool nomerge = false; bool terminal = false; GraphNode *replaced = nullptr; @@ -132,57 +133,132 @@ struct Graph { if (n->replaced) { replaced_nodes.push_back(n); } else { + new_nodes.push_back(n); + n->index = GetSize(new_nodes); + n->cleanup(); + if (n->terminal) term_nodes_cnt++; else nonterm_nodes_cnt++; - n->cleanup(); - n->index = GetSize(new_nodes); - new_nodes.push_back(n); } } std::swap(nodes, new_nodes); } - bool merge_simple() + enum merge_flags_t : uint32_t { + merge_tag_any = 0x00000001, + merge_tag_buf = 0x00000002, + merge_dbl_buf = 0x00000004, + merge_bi_conn = 0x00000008, + merge_id_conn = 0x00000010, + merge_term = 0x00000020, + merge_small = 0x00000040, + + merge_stage_1 = merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term, + merge_stage_2 = merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn, + merge_stage_3 = merge_id_conn | merge_term | merge_small + }; + + + bool merge(merge_flags_t flags) { + dict, hash_ptr_ops> node_tags; + bool did_something = false; - while (true) { - vector> queued_merges; - typedef pair, pool> node_conn_t; - dict> nodes_by_conn[2]; - - for (auto g : nodes) { - if (g->replaced) continue; + while (true) + { + if (node_tags.empty() || (flags & merge_tag_buf) != 0) { + std::function downprop_tag = [&](GraphNode *g, int tag, bool last) { + auto &tags = node_tags[g]; + auto it = tags.find(tag); + if (it != tags.end()) return; + tags.insert(tag); + if (last) return; + for (auto n : g->downstream()) + downprop_tag(n->get(), tag, n->terminal); + }; - nodes_by_conn[g->terminal][node_conn_t(g->upstream(), g->downstream())].insert(g); + std::function upprop_tag = [&](GraphNode *g, int tag, bool last) { + auto &tags = node_tags[g]; + auto it = tags.find(tag); + if (it != tags.end()) return; + tags.insert(tag); + if (last) return; + for (auto n : g->upstream()) + upprop_tag(n->get(), tag, n->terminal); + }; - if (GetSize(g->downstream()) == 1) { - auto n = (*g->downstream().begin())->get(); - if (g->terminal != n->terminal) continue; - queued_merges.push_back(pair(g, n)); - } - - if (GetSize(g->upstream()) == 1) { - auto n = (*g->upstream().begin())->get(); - if (g->terminal != n->terminal) continue; - queued_merges.push_back(pair(g, n)); - } - - for (auto n : g->downstream()) { - if (g->terminal != n->terminal) continue; - if (!n->downstream().count(g)) continue; - queued_merges.push_back(pair(g, n)); + int tag = 0; + node_tags.clear(); + for (auto g : nodes) { + if (g->replaced || !g->terminal) continue; + downprop_tag(g, ++tag, false); + upprop_tag(g, ++tag, false); } } - for (int term = 0; term < 2; term++) { - for (auto &grp : nodes_by_conn[term]) { - auto it = grp.second.begin(); - auto first = *it; - while (++it != grp.second.end()) - queued_merges.push_back(pair(first, *it)); + vector> queued_merges; + typedef pair, pool> node_conn_t; + dict> nodes_by_conn[2]; + + for (auto g : nodes) { + if (g->replaced || g->nomerge) continue; + if ((flags & merge_term) == 0 && g->terminal) continue; + + if ((flags & merge_id_conn) != 0) + nodes_by_conn[g->terminal][node_conn_t(g->upstream(), g->downstream())].insert(g); + + if ((flags & merge_tag_any) != 0 || ((flags & merge_tag_buf) != 0 && GetSize(g->downstream()) == 1)) { + for (auto n : g->downstream()) { + if (g->terminal != n->terminal || n->nomerge) continue; + if (node_tags[g] != node_tags[n->get()]) continue; + queued_merges.push_back(pair(g, n->get())); + } + } + + if ((flags & merge_dbl_buf) != 0) { + if (GetSize(g->downstream()) == 1) { + auto n = (*g->downstream().begin())->get(); + if (g->terminal != n->terminal || n->nomerge) continue; + if (GetSize(n->downstream()) != 1) continue; + queued_merges.push_back(pair(g, n)); + } + } + + if ((flags & merge_bi_conn) != 0) { + for (auto n : g->downstream()) { + if (g->terminal != n->terminal || n->nomerge) continue; + if (!n->downstream().count(g)) continue; + queued_merges.push_back(pair(g, n)); + } + } + + if ((flags & merge_small) != 0 && !g->terminal && GetSize(g->names()) < 10) { + GraphNode *best = nullptr; + for (auto n : g->downstream()) { + if (n->terminal || n->nomerge || GetSize(n->names()) > 10-GetSize(g->names())) continue; + if (best && GetSize(best->names()) <= GetSize(n->names())) continue; + best = n; + } + for (auto n : g->upstream()) { + if (n->terminal || n->nomerge || GetSize(n->names()) > 10-GetSize(g->names())) continue; + if (best && GetSize(best->names()) <= GetSize(n->names())) continue; + best = n; + } + if (best) queued_merges.push_back(pair(g, best)); + } + } + + if ((flags & merge_id_conn) != 0) { + for (int term = 0; term < 2; term++) { + for (auto &grp : nodes_by_conn[term]) { + auto it = grp.second.begin(); + auto first = *it; + while (++it != grp.second.end()) + queued_merges.push_back(pair(first, *it)); + } } } @@ -195,13 +271,13 @@ struct Graph { } if (count_merges == 0) return did_something; - log(" Replaced %d nodes in merge_simple().\n", count_merges); + log(" Merged %d node pairs.\n", count_merges); did_something = true; cleanup(); } } - Graph(Module *module) + Graph(Module *module, const std::vector &groups) { SigMap sigmap(module); dict wire_nodes; @@ -224,6 +300,31 @@ struct Graph { } } + for (auto grp : groups) + { + GraphNode *g = nullptr; + + if (!grp.selected_module(module->name)) + continue; + + for (auto wire : module->wires()) { + if (!wire->name.isPublic()) continue; + if (!grp.selected_member(module->name, wire->name)) continue; + for (auto bit : sigmap(wire)) { + if (!wire_nodes.count(bit)) + continue; + auto n = wire_nodes.at(bit)->get(); + if (g) + g->replace(n); + else + g = n; + } + } + + if (g) + g->nomerge = true; + } + dict cell_nodes; dict> sig_users; @@ -280,43 +381,81 @@ struct VizWorker FILE *f; Graph graph; - VizWorker(FILE *f, Module *module) : graph(module) + VizWorker(FILE *f, Module *module, const std::vector &groups) : graph(module, groups) { log("Running Viz for module %s:\n", log_id(module)); log(" Initial number of terminal nodes is %d.\n", graph.term_nodes_cnt); log(" Initial number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); - graph.merge_simple(); + log(" Stage-1 merge loop:\n"); + graph.merge(Graph::merge_stage_1); + log(" New number of terminal nodes is %d.\n", graph.term_nodes_cnt); + log(" New number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); - log(" Final number of terminal nodes is %d.\n", graph.term_nodes_cnt); - log(" Final number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + log(" Stage-2 merge loop:\n"); + graph.merge(Graph::merge_stage_2); + log(" New number of terminal nodes is %d.\n", graph.term_nodes_cnt); + log(" New number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + + log(" Stage-3 merge loop:\n"); + graph.merge(Graph::merge_stage_3); + log(" Final number of terminal nodes is %d.\n", graph.term_nodes_cnt); + log(" Final number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); fprintf(f, "digraph \"%s\" {", log_id(module)); fprintf(f, " rankdir = LR;"); - for (int i = 0; i < GetSize(graph.nodes); i++) { - auto g = graph.nodes[i]; - if (g->terminal) { - std::string label; - for (auto n : g->names()) { - if (!label.empty()) - label += "\\n"; - label += log_id(n); - } - fprintf(f, "\tn%d [shape=octagon,label=\"%s\"];\n", g->index, label.c_str()); - } else { - fprintf(f, "\tn%d [label=\"%d cells\"];\n", g->index, GetSize(g->names())); - } + dict, hash_ptr_ops> extra_lines; + dict bypass_nodes; + + for (auto g : graph.nodes) { + if (!g->terminal) continue; + if (GetSize(g->upstream()) != 1) continue; + if (!g->downstream().empty() && g->downstream() != g->upstream()) continue; + auto n = *(g->upstream().begin()); + for (auto name : g->names()) + extra_lines[n].push_back(log_id(name)); + bypass_nodes[g] = n; } for (int i = 0; i < GetSize(graph.nodes); i++) { auto g = graph.nodes[i]; - for (auto n : g->downstream()) { - if (g->terminal && !n->terminal && n->downstream().count(g)) continue; - fprintf(f, "\tn%d -> n%d;\n", g->index, n->index); + if (g->downstream().empty() && g->upstream().empty()) + continue; + if (bypass_nodes.count(g)) + continue; + if (g->terminal) { + std::string label; // = stringf("[%d]\\n", g->index); + for (auto n : g->names()) + label = label + (label.empty() ? "" : "\\n") + log_id(n); + fprintf(f, "\tn%d [shape=rectangle,label=\"%s\"];\n", g->index, label.c_str()); + } else { + std::string label = stringf("grp%d | %d cells", g->index, GetSize(g->names())); + std::string shape = "oval"; + if (extra_lines.count(g)) { + label += label.empty() ? "" : "\\n"; + for (auto line : extra_lines.at(g)) + label = label + (label.empty() ? "" : "\\n") + line; + shape = "octagon"; + } + fprintf(f, "\tn%d [shape=%s,label=\"%s\"];\n", g->index, shape.c_str(), label.c_str()); } } + pool edges; + for (int i = 0; i < GetSize(graph.nodes); i++) { + auto g = graph.nodes[i]; + g = bypass_nodes.at(g, g); + for (auto n : g->downstream()) { + n = bypass_nodes.at(n, n); + if (g == n) continue; + if (g->terminal && !n->terminal && n->downstream().count(g)) continue; + edges.insert(stringf("n%d -> n%d", g->index, n->index)); + } + } + for (auto e : edges) + fprintf(f, "\t%s;\n", e.c_str()); + fprintf(f, "}"); } }; @@ -343,7 +482,7 @@ struct VizPass : public Pass { log(" to generate files in other formats (this calls the 'dot' command).\n"); log("\n"); log(" -prefix \n"); - log(" generate .* instead of ~/.yosys_show.*\n"); + log(" generate .* instead of ~/.yosys_viz.*\n"); log("\n"); log(" -pause\n"); log(" wait for the user to press enter to before returning\n"); @@ -352,10 +491,14 @@ struct VizPass : public Pass { log(" don't run viewer in the background, IE wait for the viewer tool to\n"); log(" exit before returning\n"); log("\n"); + log(" -g \n"); + log(" manually define a group of terminal signals. this group is not being\n"); + log(" merged with other terminal groups.\n"); + log("\n"); log("When no is specified, 'dot' is used. When no and is\n"); log("specified, 'xdot' is used to display the schematic (POSIX systems only).\n"); log("\n"); - log("The generated output files are '~/.yosys_show.dot' and '~/.yosys_show.',\n"); + log("The generated output files are '~/.yosys_viz.dot' and '~/.yosys_viz.',\n"); log("unless another prefix is specified using -prefix .\n"); log("\n"); log("Yosys on Windows and YosysJS use different defaults: The output is written\n"); @@ -373,13 +516,14 @@ struct VizPass : public Pass { std::string prefix = "show"; #else std::string format; - std::string prefix = stringf("%s/.yosys_show", getenv("HOME") ? getenv("HOME") : "."); + std::string prefix = stringf("%s/.yosys_viz", getenv("HOME") ? getenv("HOME") : "."); #endif std::string viewer_exe; bool flag_pause = false; bool custom_prefix = false; std::string background = "&"; RTLIL::IdString colorattr; + std::vector groups; size_t argidx; for (argidx = 1; argidx < args.size(); argidx++) @@ -406,6 +550,13 @@ struct VizPass : public Pass { background= ""; continue; } + if (arg == "-g" && argidx+1 < args.size()) { + handle_extra_select_args(this, args, argidx+1, argidx+2, design); + groups.push_back(design->selection_stack.back()); + design->selection_stack.pop_back(); + ++argidx; + continue; + } break; } extra_args(args, argidx, design); @@ -438,7 +589,7 @@ struct VizPass : public Pass { continue; if (module->cells().size() == 0 && module->connections().empty()) continue; - VizWorker worker(f, module); + VizWorker worker(f, module, groups); } fclose(f); From 2895a667844f91c64917ff2815e32d780f38a4f8 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Tue, 6 Dec 2022 16:00:48 +0100 Subject: [PATCH 05/14] Bugfix in splitcells pass Signed-off-by: Claire Xenia Wolf --- passes/cmds/splitcells.cc | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/passes/cmds/splitcells.cc b/passes/cmds/splitcells.cc index eb04380fe..de6df6142 100644 --- a/passes/cmds/splitcells.cc +++ b/passes/cmds/splitcells.cc @@ -76,9 +76,14 @@ struct SplitcellsWorker std::vector slices; slices.push_back(0); - for (int i = 1; i < GetSize(outsig); i++) { - auto &last_users = bit_users_db.at(outsig[slices.back()]); - auto &this_users = bit_users_db.at(outsig[i]); + int width = GetSize(outsig); + width = std::min(width, GetSize(cell->getPort(ID::A))); + if (cell->hasPort(ID::B)) + width = std::min(width, GetSize(cell->getPort(ID::B))); + + for (int i = 1; i < width; i++) { + auto &last_users = bit_users_db[outsig[slices.back()]]; + auto &this_users = bit_users_db[outsig[i]]; if (last_users != this_users) slices.push_back(i); } if (GetSize(slices) <= 1) return 0; @@ -98,8 +103,11 @@ struct SplitcellsWorker auto slice_signal = [&](SigSpec old_sig) -> SigSpec { SigSpec new_sig; - for (int i = 0; i < GetSize(old_sig); i += GetSize(outsig)) - new_sig.append(old_sig.extract(i+slice_lsb, slice_msb-slice_lsb+1)); + for (int i = 0; i < GetSize(old_sig); i += GetSize(outsig)) { + int offset = i+slice_lsb; + int length = std::min(GetSize(old_sig)-offset, slice_msb-slice_lsb+1); + new_sig.append(old_sig.extract(offset, length)); + } return new_sig; }; From c679b408cb33fd7aa2837b7f0641ca39148d7a54 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Tue, 6 Dec 2022 16:02:00 +0100 Subject: [PATCH 06/14] Various improvements in "viz" command Signed-off-by: Claire Xenia Wolf --- passes/cmds/viz.cc | 308 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 239 insertions(+), 69 deletions(-) diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc index 4930ff783..66b581feb 100644 --- a/passes/cmds/viz.cc +++ b/passes/cmds/viz.cc @@ -39,6 +39,22 @@ USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN +struct VizConfig { + enum group_type_t { + TYPE_G, + TYPE_U + }; + + int script = 9; + std::vector> groups; + + int max_size = -1; + + int max_fanout = 10; + int max_fanin = 10; + int max_conns = 15; +}; + struct GraphNode { int index = -1; bool nomerge = false; @@ -60,10 +76,14 @@ struct GraphNode { pool &downstream() { return get()->downstream_; } void replace(GraphNode *g) { - if (replaced) return get()->replace(g); + if (replaced) + return get()->replace(g); + + log_assert(!nomerge); + log_assert(!g->get()->nomerge); + log_assert(terminal == g->terminal); if (this == g->get()) return; - log_assert(terminal == g->terminal); for (auto v : g->names()) names().insert(v); @@ -110,12 +130,17 @@ struct GraphNode { }; struct Graph { - int term_nodes_cnt; - int nonterm_nodes_cnt; - vector nodes; vector replaced_nodes; + Module *module; + const VizConfig &config; + + // statistics, updated by cleanup() + int term_nodes_cnt; + int nonterm_nodes_cnt; + int max_group_sizes[5]; + ~Graph() { for (auto n : nodes) delete n; @@ -128,6 +153,8 @@ struct Graph { term_nodes_cnt = 0; nonterm_nodes_cnt = 0; + for (int i = 0; i < 5; i++) + max_group_sizes[i] = 0; for (auto n : nodes) { if (n->replaced) { @@ -137,10 +164,15 @@ struct Graph { n->index = GetSize(new_nodes); n->cleanup(); - if (n->terminal) + if (n->terminal) { term_nodes_cnt++; - else + } else { nonterm_nodes_cnt++; + int pivot = GetSize(n->names()); + for (int i = 0; i < 5; i++) + if (pivot >= max_group_sizes[i]) + std::swap(pivot, max_group_sizes[i]); + } } } @@ -155,12 +187,40 @@ struct Graph { merge_id_conn = 0x00000010, merge_term = 0x00000020, merge_small = 0x00000040, - - merge_stage_1 = merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term, - merge_stage_2 = merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn, - merge_stage_3 = merge_id_conn | merge_term | merge_small + merge_maxfan = 0x00000080, }; + static const std::vector>& scripts() + { + static std::vector> buffer; + + if (buffer.empty()) { + auto next_script = [&]() { buffer.push_back({}); }; + auto cmd = [&](uint32_t flags) { buffer.back().push_back(merge_flags_t(flags)); }; + + // viz -0 + next_script(); + cmd(merge_dbl_buf | merge_id_conn | merge_maxfan); + + // viz -1 + next_script(); + cmd(merge_dbl_buf | merge_id_conn | merge_tag_any | merge_maxfan); + + // viz -2 + next_script(); + cmd(merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term); + cmd(merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_maxfan); + cmd(merge_id_conn | merge_term | merge_small | merge_maxfan); + + // viz -3 + next_script(); + cmd(merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term); + cmd(merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn); + cmd(merge_id_conn | merge_term | merge_small | merge_maxfan); + } + + return buffer; + }; bool merge(merge_flags_t flags) { @@ -263,21 +323,75 @@ struct Graph { } int count_merges = 0; - for (auto m : queued_merges) { + int smallest_merge_idx = -1; + int smallest_merge_size = 0; + for (int merge_idx = 0; merge_idx < GetSize(queued_merges); merge_idx++) { + auto &m = queued_merges[merge_idx]; auto g = m.first->get(), n = m.second->get(); if (g == n) continue; + + if (!g->terminal) + { + int g_size = GetSize(g->names()); + int n_size = GetSize(n->names()); + int total_size = g_size + n_size; + + if (total_size > config.max_size) continue; + + if (smallest_merge_idx < 0 || total_size < smallest_merge_size) { + smallest_merge_idx = merge_idx; + smallest_merge_size = total_size; + } + + if (total_size > max_group_sizes[1] + max_group_sizes[4]) continue; + if (g_size >= max_group_sizes[0] && max_group_sizes[0] != max_group_sizes[4]) continue; + if (n_size >= max_group_sizes[0] && max_group_sizes[0] != max_group_sizes[4]) continue; + + if ((flags & merge_maxfan) != 0) { + auto &g_upstream = g->upstream(), &g_downstream = g->downstream(); + auto &n_upstream = n->upstream(), &n_downstream = n->downstream(); + + if (GetSize(g_upstream) > config.max_fanin) continue; + if (GetSize(n_upstream) > config.max_fanin) continue; + + if (GetSize(g_downstream) > config.max_fanout) continue; + if (GetSize(n_downstream) > config.max_fanout) continue; + + pool combined_upstream = g_upstream; + combined_upstream.insert(n_upstream.begin(), n_upstream.end()); + + pool combined_downstream = g_downstream; + combined_downstream.insert(n_downstream.begin(), n_downstream.end()); + + pool combined_conns = combined_upstream; + combined_conns.insert(combined_downstream.begin(), combined_downstream.end()); + + if (GetSize(combined_upstream) > config.max_fanin) continue; + if (GetSize(combined_downstream) > config.max_fanout) continue; + if (GetSize(combined_conns) > config.max_conns) continue; + } + } + g->replace(n); count_merges++; } - if (count_merges == 0) return did_something; - - log(" Merged %d node pairs.\n", count_merges); + if (count_merges == 0 && smallest_merge_idx >= 0) { + auto &m = queued_merges[smallest_merge_idx]; + auto g = m.first->get(), n = m.second->get(); + log(" Merging only the smallest node pair: %d + %d -> %d\n", + GetSize(g->names()), GetSize(n->names()), smallest_merge_size); + g->replace(n); + count_merges++; + } else { + if (count_merges == 0) return did_something; + log(" Merged %d node pairs.\n", count_merges); + } did_something = true; cleanup(); } } - Graph(Module *module, const std::vector &groups) + Graph(Module *module, const VizConfig &config) : module(module), config(config) { SigMap sigmap(module); dict wire_nodes; @@ -300,24 +414,30 @@ struct Graph { } } - for (auto grp : groups) + for (auto grp : config.groups) { GraphNode *g = nullptr; - if (!grp.selected_module(module->name)) + if (!grp.second.selected_module(module->name)) continue; for (auto wire : module->wires()) { if (!wire->name.isPublic()) continue; - if (!grp.selected_member(module->name, wire->name)) continue; + if (!grp.second.selected_member(module->name, wire->name)) continue; for (auto bit : sigmap(wire)) { - if (!wire_nodes.count(bit)) + auto it = wire_nodes.find(bit); + if (it == wire_nodes.end()) continue; - auto n = wire_nodes.at(bit)->get(); - if (g) - g->replace(n); - else - g = n; + auto n = it->second->get(); + if (grp.first == VizConfig::TYPE_G) { + if (g) { + if (!n->nomerge) + g->replace(n); + } else + g = n; + } else { // VizConfig::TYPE_U + n->nomerge = true; + } } } @@ -378,41 +498,51 @@ struct Graph { struct VizWorker { - FILE *f; + VizConfig config; + Module *module; Graph graph; - VizWorker(FILE *f, Module *module, const std::vector &groups) : graph(module, groups) + VizWorker(Module *module, const VizConfig &cfg) : config(cfg), module(module), graph(module, config) { - log("Running Viz for module %s:\n", log_id(module)); - log(" Initial number of terminal nodes is %d.\n", graph.term_nodes_cnt); - log(" Initial number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + auto &scripts = Graph::scripts(); + config.script = std::min(GetSize(scripts)-1, config.script); + auto &script = scripts.at(config.script); - log(" Stage-1 merge loop:\n"); - graph.merge(Graph::merge_stage_1); - log(" New number of terminal nodes is %d.\n", graph.term_nodes_cnt); - log(" New number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + if (config.max_size < 0) + config.max_size = graph.nonterm_nodes_cnt / 3; - log(" Stage-2 merge loop:\n"); - graph.merge(Graph::merge_stage_2); - log(" New number of terminal nodes is %d.\n", graph.term_nodes_cnt); - log(" New number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + auto log_stats = [&](const char *sp, const char *p) { + log("%s%s maximum group sizes are ", sp, p); + for (int i = 0; i < 5; i++) + log("%d%s", graph.max_group_sizes[i], i==3 ? ", and " : i == 4 ? ".\n" : ", "); + log("%s%s number of terminal nodes is %d.\n", sp, p, graph.term_nodes_cnt); + log("%s%s number of non-terminal nodes is %d.\n", sp, p, graph.nonterm_nodes_cnt); + }; - log(" Stage-3 merge loop:\n"); - graph.merge(Graph::merge_stage_3); - log(" Final number of terminal nodes is %d.\n", graph.term_nodes_cnt); - log(" Final number of non-terminal nodes is %d.\n", graph.nonterm_nodes_cnt); + log("Running 'viz -%d' for module %s:\n", config.script, log_id(module)); + log_stats(" ", "Initial"); - fprintf(f, "digraph \"%s\" {", log_id(module)); - fprintf(f, " rankdir = LR;"); + for (int i = 0; i < GetSize(script); i++) { + log(" Stage-%d merge loop:\n", i+1); + graph.merge(script[i]); + log_stats(" ", i+1 == GetSize(script) ? "Final" : "New"); + } + } + + void write_dot(FILE *f) + { + fprintf(f, "digraph \"%s\" {\n", log_id(module)); + fprintf(f, " rankdir = LR;\n"); dict, hash_ptr_ops> extra_lines; dict bypass_nodes; for (auto g : graph.nodes) { - if (!g->terminal) continue; + if (!g->terminal || g->nomerge) continue; if (GetSize(g->upstream()) != 1) continue; if (!g->downstream().empty() && g->downstream() != g->upstream()) continue; auto n = *(g->upstream().begin()); + if (n->terminal) continue; for (auto name : g->names()) extra_lines[n].push_back(log_id(name)); bypass_nodes[g] = n; @@ -430,7 +560,7 @@ struct VizWorker label = label + (label.empty() ? "" : "\\n") + log_id(n); fprintf(f, "\tn%d [shape=rectangle,label=\"%s\"];\n", g->index, label.c_str()); } else { - std::string label = stringf("grp%d | %d cells", g->index, GetSize(g->names())); + std::string label = stringf("grp=%d | %d cells", g->index, GetSize(g->names())); std::string shape = "oval"; if (extra_lines.count(g)) { label += label.empty() ? "" : "\\n"; @@ -449,14 +579,13 @@ struct VizWorker for (auto n : g->downstream()) { n = bypass_nodes.at(n, n); if (g == n) continue; - if (g->terminal && !n->terminal && n->downstream().count(g)) continue; edges.insert(stringf("n%d -> n%d", g->index, n->index)); } } for (auto e : edges) fprintf(f, "\t%s;\n", e.c_str()); - fprintf(f, "}"); + fprintf(f, "}\n"); } }; @@ -495,6 +624,19 @@ struct VizPass : public Pass { log(" manually define a group of terminal signals. this group is not being\n"); log(" merged with other terminal groups.\n"); log("\n"); + log(" -u \n"); + log(" manually define a unique group for each wire in the selection.\n"); + log("\n"); + log(" -G .\n"); + log(" -U .\n"); + log(" like -u and -g, but parse all arguments up to a terminating . argument\n"); + log(" as a single select expression. (see 'help select' for details)\n"); + log("\n"); + log(" -0, -1, -2, -3, -4, -5, -6, -7, -8, -9\n"); + log(" select effort level. each level corresponds to an incresingly more\n"); + log(" aggressive sequence of strategies for merging nodes of the data flow\n"); + log(" graph. (default: %d)\n", VizConfig().script); + log("\n"); log("When no is specified, 'dot' is used. When no and is\n"); log("specified, 'xdot' is used to display the schematic (POSIX systems only).\n"); log("\n"); @@ -522,8 +664,8 @@ struct VizPass : public Pass { bool flag_pause = false; bool custom_prefix = false; std::string background = "&"; - RTLIL::IdString colorattr; - std::vector groups; + + VizConfig config; size_t argidx; for (argidx = 1; argidx < args.size(); argidx++) @@ -550,47 +692,75 @@ struct VizPass : public Pass { background= ""; continue; } - if (arg == "-g" && argidx+1 < args.size()) { - handle_extra_select_args(this, args, argidx+1, argidx+2, design); - groups.push_back(design->selection_stack.back()); + if ((arg == "-g" || arg == "-u" || arg == "-G" || arg == "-U") && argidx+1 < args.size()) { + int numargs = 1; + int first_arg = ++argidx; + if (arg == "-G" || arg == "-U") { + while (argidx+1 < args.size()) { + if (args[++argidx] == ".") break; + numargs++; + } + } + handle_extra_select_args(this, args, first_arg, first_arg+numargs, design); + auto type = arg == "-g" || arg == "-G" ? VizConfig::TYPE_G : VizConfig::TYPE_U; + config.groups.push_back({type, design->selection_stack.back()}); design->selection_stack.pop_back(); - ++argidx; + continue; + } + if (arg == "-0" || arg == "-1" || arg == "-2" || arg == "-3" || arg == "-4" || + arg == "-5" || arg == "-6" || arg == "-7" || arg == "-8" || arg == "-9") { + config.script = arg[1] - '0'; continue; } break; } extra_args(args, argidx, design); - int modcount = 0; + std::vector modlist; for (auto module : design->selected_modules()) { if (module->get_blackbox_attribute()) continue; if (module->cells().size() == 0 && module->connections().empty()) continue; - modcount++; + modlist.push_back(module); } - if (format != "ps" && format != "dot" && modcount > 1) + if (format != "ps" && format != "dot" && GetSize(modlist) > 1) log_cmd_error("For formats different than 'ps' or 'dot' only one module must be selected.\n"); - if (modcount == 0) + if (modlist.empty()) log_cmd_error("Nothing there to show.\n"); std::string dot_file = stringf("%s.dot", prefix.c_str()); std::string out_file = stringf("%s.%s", prefix.c_str(), format.empty() ? "svg" : format.c_str()); - log("Writing dot description to `%s'.\n", dot_file.c_str()); - FILE *f = fopen(dot_file.c_str(), "w"); if (custom_prefix) yosys_output_files.insert(dot_file); - if (f == nullptr) { - log_cmd_error("Can't open dot file `%s' for writing.\n", dot_file.c_str()); - } - for (auto module : design->selected_modules()) { - if (module->get_blackbox_attribute()) - continue; - if (module->cells().size() == 0 && module->connections().empty()) - continue; - VizWorker worker(f, module, groups); + + log("Writing dot description to `%s'.\n", dot_file.c_str()); + FILE *f = nullptr; + auto open_dot_file = [&]() { + if (f != nullptr) return; + f = fopen(dot_file.c_str(), "w"); + if (f == nullptr) + log_cmd_error("Can't open dot file `%s' for writing.\n", dot_file.c_str()); + }; + for (auto module : modlist) { + VizWorker worker(module, config); + + if (format != "dot" && worker.graph.term_nodes_cnt + worker.graph.nonterm_nodes_cnt > 150) { + if (format.empty()) { + log_warning("Suppressing module in output as graph size exceeds 150 nodes.\n"); + continue; + } else { + log_warning("Changing format to 'dot' as graph size exceeds 150 nodes.\n"); + format = "dot"; + } + } + + // delay opening of output file until we have something to write, to avoid race with xdot + open_dot_file(); + worker.write_dot(f); } + open_dot_file(); fclose(f); if (format != "dot" && !format.empty()) { From aeba966475c1430ff9e0296d47e755a5f6a38a8f Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Wed, 7 Dec 2022 12:46:49 +0100 Subject: [PATCH 07/14] Improvements in "viz" pass Signed-off-by: Claire Xenia Wolf --- passes/cmds/viz.cc | 788 ++++++++++++++++++++++++++------------------- 1 file changed, 464 insertions(+), 324 deletions(-) diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc index 66b581feb..2754eafd6 100644 --- a/passes/cmds/viz.cc +++ b/passes/cmds/viz.cc @@ -42,17 +42,15 @@ PRIVATE_NAMESPACE_BEGIN struct VizConfig { enum group_type_t { TYPE_G, - TYPE_U + TYPE_U, + TYPE_X }; - int script = 9; + int effort = 9; + int similar_thresh = 30; + int small_group_thresh = 10; + int large_group_count = 10; std::vector> groups; - - int max_size = -1; - - int max_fanout = 10; - int max_fanin = 10; - int max_conns = 15; }; struct GraphNode { @@ -68,78 +66,45 @@ struct GraphNode { } pool names_; + dict tags_; pool upstream_; pool downstream_; pool &names() { return get()->names_; } + dict &tags() { return get()->tags_; } pool &upstream() { return get()->upstream_; } pool &downstream() { return get()->downstream_; } - void replace(GraphNode *g) { - if (replaced) - return get()->replace(g); - - log_assert(!nomerge); - log_assert(!g->get()->nomerge); - log_assert(terminal == g->terminal); - - if (this == g->get()) return; - - for (auto v : g->names()) - names().insert(v); - - for (auto v : g->upstream()) { - auto n = v->get(); - if (n == this) continue; - upstream().insert(n); - } - - for (auto v : g->downstream()) { - auto n = v->get(); - if (n == this) continue; - downstream().insert(n); - } - - g->names().clear(); - g->upstream().clear(); - g->downstream().clear(); - - g->get()->replaced = this; + uint8_t tag(int index) { + return tags().at(index, 0); } - void cleanup() { - if (replaced) return; - - pool new_upstream; - pool new_downstream; - - for (auto g : upstream_) { - auto n = g->get(); - if (n == this) continue; - new_upstream.insert(n); - } - for (auto g : downstream_) { - auto n = g->get(); - if (n == this) continue; - new_downstream.insert(n); - } - - std::swap(upstream_, new_upstream); - std::swap(downstream_, new_downstream); + bool tag(int index, uint8_t mask) { + if (!mask) return false; + uint8_t &v = tags()[index]; + if (v == (v|mask)) return false; + v |= mask; + return true; } }; struct Graph { + bool dirty = true; + int phase_counter = 0; + vector nodes; + vector term_nodes; + vector nonterm_nodes; vector replaced_nodes; Module *module; const VizConfig &config; - // statistics, updated by cleanup() - int term_nodes_cnt; - int nonterm_nodes_cnt; - int max_group_sizes[5]; + // statistics and indices, updated by update() + std::vector max_group_sizes; + double mean_group_size; + double rms_group_size; + int edge_count, tag_count; ~Graph() { @@ -147,252 +112,172 @@ struct Graph { for (auto n : replaced_nodes) delete n; } - void cleanup() + GraphNode *node(int index) { - vector new_nodes; - - term_nodes_cnt = 0; - nonterm_nodes_cnt = 0; - for (int i = 0; i < 5; i++) - max_group_sizes[i] = 0; - - for (auto n : nodes) { - if (n->replaced) { - replaced_nodes.push_back(n); - } else { - new_nodes.push_back(n); - n->index = GetSize(new_nodes); - n->cleanup(); - - if (n->terminal) { - term_nodes_cnt++; - } else { - nonterm_nodes_cnt++; - int pivot = GetSize(n->names()); - for (int i = 0; i < 5; i++) - if (pivot >= max_group_sizes[i]) - std::swap(pivot, max_group_sizes[i]); - } - } - } - - std::swap(nodes, new_nodes); + if (index) + return nodes[index-1]->get(); + return nullptr; } - enum merge_flags_t : uint32_t { - merge_tag_any = 0x00000001, - merge_tag_buf = 0x00000002, - merge_dbl_buf = 0x00000004, - merge_bi_conn = 0x00000008, - merge_id_conn = 0x00000010, - merge_term = 0x00000020, - merge_small = 0x00000040, - merge_maxfan = 0x00000080, - }; - - static const std::vector>& scripts() + void update_nodes() { - static std::vector> buffer; + // Filter-out replaced nodes - if (buffer.empty()) { - auto next_script = [&]() { buffer.push_back({}); }; - auto cmd = [&](uint32_t flags) { buffer.back().push_back(merge_flags_t(flags)); }; + term_nodes.clear(); + nonterm_nodes.clear(); - // viz -0 - next_script(); - cmd(merge_dbl_buf | merge_id_conn | merge_maxfan); - - // viz -1 - next_script(); - cmd(merge_dbl_buf | merge_id_conn | merge_tag_any | merge_maxfan); - - // viz -2 - next_script(); - cmd(merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term); - cmd(merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_maxfan); - cmd(merge_id_conn | merge_term | merge_small | merge_maxfan); - - // viz -3 - next_script(); - cmd(merge_tag_buf | merge_dbl_buf | merge_bi_conn | merge_id_conn | merge_term); - cmd(merge_tag_any | merge_dbl_buf | merge_bi_conn | merge_id_conn); - cmd(merge_id_conn | merge_term | merge_small | merge_maxfan); + for (auto n : nodes) { + if (n->replaced) + replaced_nodes.push_back(n); + else if (n->terminal) + term_nodes.push_back(n); + else + nonterm_nodes.push_back(n); } - return buffer; - }; + // Re-index the remaining nodes - bool merge(merge_flags_t flags) - { - dict, hash_ptr_ops> node_tags; + nodes.clear(); - bool did_something = false; - while (true) + max_group_sizes.clear(); + max_group_sizes.resize(config.large_group_count); + + mean_group_size = 0; + rms_group_size = 0; + edge_count = 0; + + auto update_node = [&](GraphNode *n) { - if (node_tags.empty() || (flags & merge_tag_buf) != 0) { - std::function downprop_tag = [&](GraphNode *g, int tag, bool last) { - auto &tags = node_tags[g]; - auto it = tags.find(tag); - if (it != tags.end()) return; - tags.insert(tag); - if (last) return; - for (auto n : g->downstream()) - downprop_tag(n->get(), tag, n->terminal); - }; + nodes.push_back(n); + n->index = GetSize(nodes); - std::function upprop_tag = [&](GraphNode *g, int tag, bool last) { - auto &tags = node_tags[g]; - auto it = tags.find(tag); - if (it != tags.end()) return; - tags.insert(tag); - if (last) return; - for (auto n : g->upstream()) - upprop_tag(n->get(), tag, n->terminal); - }; + pool new_upstream; + pool new_downstream; - int tag = 0; - node_tags.clear(); - for (auto g : nodes) { - if (g->replaced || !g->terminal) continue; - downprop_tag(g, ++tag, false); - upprop_tag(g, ++tag, false); - } + for (auto g : n->upstream()) { + if (n != (g = g->get())) + new_upstream.insert(g); + } + for (auto g : n->downstream()) { + if (n != (g = g->get())) + new_downstream.insert(g), edge_count++; } - vector> queued_merges; - typedef pair, pool> node_conn_t; - dict> nodes_by_conn[2]; + new_upstream.sort(); + new_downstream.sort(); - for (auto g : nodes) { - if (g->replaced || g->nomerge) continue; - if ((flags & merge_term) == 0 && g->terminal) continue; + std::swap(n->upstream(), new_upstream); + std::swap(n->downstream(), new_downstream); - if ((flags & merge_id_conn) != 0) - nodes_by_conn[g->terminal][node_conn_t(g->upstream(), g->downstream())].insert(g); + if (!n->terminal) { + int t = GetSize(n->names()); + mean_group_size += t; + rms_group_size += t*t; + for (int i = 0; i < config.large_group_count; i++) + if (t >= max_group_sizes[i]) + std::swap(t, max_group_sizes[i]); + } + }; - if ((flags & merge_tag_any) != 0 || ((flags & merge_tag_buf) != 0 && GetSize(g->downstream()) == 1)) { - for (auto n : g->downstream()) { - if (g->terminal != n->terminal || n->nomerge) continue; - if (node_tags[g] != node_tags[n->get()]) continue; - queued_merges.push_back(pair(g, n->get())); - } - } + for (auto n : term_nodes) + update_node(n); - if ((flags & merge_dbl_buf) != 0) { - if (GetSize(g->downstream()) == 1) { - auto n = (*g->downstream().begin())->get(); - if (g->terminal != n->terminal || n->nomerge) continue; - if (GetSize(n->downstream()) != 1) continue; - queued_merges.push_back(pair(g, n)); - } - } + for (auto n : nonterm_nodes) + update_node(n); - if ((flags & merge_bi_conn) != 0) { - for (auto n : g->downstream()) { - if (g->terminal != n->terminal || n->nomerge) continue; - if (!n->downstream().count(g)) continue; - queued_merges.push_back(pair(g, n)); - } - } + mean_group_size /= GetSize(nonterm_nodes); + rms_group_size = sqrt(rms_group_size / GetSize(nonterm_nodes)); + } - if ((flags & merge_small) != 0 && !g->terminal && GetSize(g->names()) < 10) { - GraphNode *best = nullptr; - for (auto n : g->downstream()) { - if (n->terminal || n->nomerge || GetSize(n->names()) > 10-GetSize(g->names())) continue; - if (best && GetSize(best->names()) <= GetSize(n->names())) continue; - best = n; - } - for (auto n : g->upstream()) { - if (n->terminal || n->nomerge || GetSize(n->names()) > 10-GetSize(g->names())) continue; - if (best && GetSize(best->names()) <= GetSize(n->names())) continue; - best = n; - } - if (best) queued_merges.push_back(pair(g, best)); + void update_tags() + { + std::function up_down_prop_tag = + [&](GraphNode *g, int index, bool down) + { + for (auto n : (down ? g->downstream_ : g->upstream_)) { + if (n->tag(index, down ? 2 : 1)) { + if (!n->terminal) + up_down_prop_tag(n, index, down); + tag_count++; } } + }; - if ((flags & merge_id_conn) != 0) { - for (int term = 0; term < 2; term++) { - for (auto &grp : nodes_by_conn[term]) { - auto it = grp.second.begin(); - auto first = *it; - while (++it != grp.second.end()) - queued_merges.push_back(pair(first, *it)); - } - } - } + tag_count = 0; + for (auto g : nodes) + g->tags().clear(); - int count_merges = 0; - int smallest_merge_idx = -1; - int smallest_merge_size = 0; - for (int merge_idx = 0; merge_idx < GetSize(queued_merges); merge_idx++) { - auto &m = queued_merges[merge_idx]; - auto g = m.first->get(), n = m.second->get(); - if (g == n) continue; - - if (!g->terminal) - { - int g_size = GetSize(g->names()); - int n_size = GetSize(n->names()); - int total_size = g_size + n_size; - - if (total_size > config.max_size) continue; - - if (smallest_merge_idx < 0 || total_size < smallest_merge_size) { - smallest_merge_idx = merge_idx; - smallest_merge_size = total_size; - } - - if (total_size > max_group_sizes[1] + max_group_sizes[4]) continue; - if (g_size >= max_group_sizes[0] && max_group_sizes[0] != max_group_sizes[4]) continue; - if (n_size >= max_group_sizes[0] && max_group_sizes[0] != max_group_sizes[4]) continue; - - if ((flags & merge_maxfan) != 0) { - auto &g_upstream = g->upstream(), &g_downstream = g->downstream(); - auto &n_upstream = n->upstream(), &n_downstream = n->downstream(); - - if (GetSize(g_upstream) > config.max_fanin) continue; - if (GetSize(n_upstream) > config.max_fanin) continue; - - if (GetSize(g_downstream) > config.max_fanout) continue; - if (GetSize(n_downstream) > config.max_fanout) continue; - - pool combined_upstream = g_upstream; - combined_upstream.insert(n_upstream.begin(), n_upstream.end()); - - pool combined_downstream = g_downstream; - combined_downstream.insert(n_downstream.begin(), n_downstream.end()); - - pool combined_conns = combined_upstream; - combined_conns.insert(combined_downstream.begin(), combined_downstream.end()); - - if (GetSize(combined_upstream) > config.max_fanin) continue; - if (GetSize(combined_downstream) > config.max_fanout) continue; - if (GetSize(combined_conns) > config.max_conns) continue; - } - } - - g->replace(n); - count_merges++; - } - if (count_merges == 0 && smallest_merge_idx >= 0) { - auto &m = queued_merges[smallest_merge_idx]; - auto g = m.first->get(), n = m.second->get(); - log(" Merging only the smallest node pair: %d + %d -> %d\n", - GetSize(g->names()), GetSize(n->names()), smallest_merge_size); - g->replace(n); - count_merges++; - } else { - if (count_merges == 0) return did_something; - log(" Merged %d node pairs.\n", count_merges); - } - did_something = true; - cleanup(); + for (auto g : term_nodes) { + up_down_prop_tag(g, g->index, false); + up_down_prop_tag(g, g->index, true); } + + for (auto g : nodes) + g->tags().sort(); + } + + bool update() + { + if (!dirty) { + log(" Largest non-term group sizes: "); + for (int i = 0; i < config.large_group_count; i++) + log("%d%s", max_group_sizes[i], i+1 == config.large_group_count ? ".\n" : " "); + + // log(" Mean and Root-Mean-Square group sizes: %.1f and %.1f\n", mean_group_size, rms_group_size); + + return false; + } + + dirty = false; + update_nodes(); + update_tags(); + + log(" Status: %d nodes (%d term and %d non-term), %d edges, and %d tags\n", + GetSize(nodes), GetSize(term_nodes), GetSize(nonterm_nodes), edge_count, tag_count); + return true; + } + + void merge(GraphNode *g, GraphNode *n) + { + g = g->get(); + n = n->get(); + + log_assert(!g->nomerge); + log_assert(!n->nomerge); + log_assert(g->terminal == n->terminal); + + if (g == n) return; + + for (auto v : n->names_) + g->names_.insert(v); + + for (auto v : n->tags_) + g->tags_[v.first] |= v.second; + + for (auto v : n->upstream_) { + if (g != (v = v->get())) + g->upstream_.insert(v); + } + + for (auto v : n->downstream_) { + if (g != (v = v->get())) + g->downstream_.insert(v); + } + + n->names_.clear(); + n->tags_.clear(); + n->upstream_.clear(); + n->downstream_.clear(); + + dirty = true; + n->replaced = g; } Graph(Module *module, const VizConfig &config) : module(module), config(config) { + log("Running 'viz -%d' for module %s:\n", config.effort, log_id(module)); + log(" Phase %d: Construct initial graph\n", phase_counter++); + SigMap sigmap(module); dict wire_nodes; @@ -410,10 +295,12 @@ struct Graph { if (it == wire_nodes.end()) wire_nodes[bit] = g; else - g->replace(it->second); + merge(g, it->second); } } + pool excluded; + for (auto grp : config.groups) { GraphNode *g = nullptr; @@ -432,12 +319,16 @@ struct Graph { if (grp.first == VizConfig::TYPE_G) { if (g) { if (!n->nomerge) - g->replace(n); + merge(g, n); } else g = n; - } else { // VizConfig::TYPE_U + } else if (grp.first == VizConfig::TYPE_U) { n->nomerge = true; - } + } else if (grp.first == VizConfig::TYPE_X) { + n->nomerge = true; + excluded.insert(n); + } else + log_abort(); } } @@ -460,18 +351,23 @@ struct Graph { if (!bit.wire) continue; auto it = wire_nodes.find(bit); if (it != wire_nodes.end()) { - g->upstream().insert(it->second); - it->second->downstream().insert(g); + if (!excluded.count(it->second)) { + g->upstream().insert(it->second); + it->second->downstream().insert(g); + } + } else { + sig_users[bit].insert(g); } - sig_users[bit].insert(g); } if (cell->output(conn.first)) for (auto bit : sigmap(conn.second)) { if (!bit.wire) continue; auto it = wire_nodes.find(bit); if (it != wire_nodes.end()) { - g->downstream().insert(it->second); - it->second->upstream().insert(g); + if (!excluded.count(it->second)) { + g->downstream().insert(it->second); + it->second->upstream().insert(g); + } } } } @@ -492,7 +388,258 @@ struct Graph { } } - cleanup(); + update(); + } + + int compare_tags(GraphNode *g, GraphNode *n, bool strict_mode) + { + if (GetSize(g->tags()) > GetSize(n->tags())) + return compare_tags(n, g, strict_mode); + + if (g->tags().empty()) + return 100; + + int matched_tags = 0; + for (auto it : g->tags()) { + auto g_tag = it.second; + auto n_tag = n->tag(it.first); + if (!g_tag || !n_tag) continue; + if (g_tag == n_tag) + matched_tags += 2; + else if (!strict_mode && ((g_tag == 1 && n_tag == 3) || + (g_tag == 3 && n_tag == 1))) + matched_tags += 1; + else + return 0; + } + + return (100*matched_tags) / GetSize(g->tags()); + } + + int phase(bool term, int effort) + { + log(" Phase %d: Merge %sterminal nodes with effort level %d\n", phase_counter++, term ? "" : "non-", effort); + int start_replaced_nodes = GetSize(replaced_nodes); + + do { + dict>> candidates; + auto queue = [&](GraphNode *g, GraphNode *n) -> bool { + if (g->terminal != n->terminal) + return false; + if (g->nomerge || n->nomerge) + return false; + int sz = GetSize(g->names()) + GetSize(n->names()); + if (g->index < n->index) + candidates[sz].insert(pair(g->index, n->index)); + else if (g->index != n->index) + candidates[sz].insert(pair(n->index, g->index)); + return true; + }; + + int last_candidates_size = 0; + const char *last_section_header = nullptr; + auto header = [&](const char *p = nullptr) { + if (GetSize(candidates) != last_candidates_size && last_section_header) + log(" Found %d cadidates of type '%s'.\n", + GetSize(candidates) - last_candidates_size, last_section_header); + last_candidates_size = GetSize(candidates); + last_section_header = p; + }; + + { + header("Any nodes with identical connections"); + typedef pair, pool> node_conn_t; + dict> nodes_by_conn; + for (auto g : term ? term_nodes : nonterm_nodes) { + auto &entry = nodes_by_conn[node_conn_t(g->upstream(), g->downstream())]; + for (auto n : entry) + queue(g, n); + entry.insert(g); + } + } + + if (!candidates.empty() || effort < 1) goto execute; + + if (!term) { + header("Source-Sink with identical tags"); + for (auto g : nonterm_nodes) { + for (auto n : g->downstream()) { + if (n->terminal) continue; + if (g->tags() == n->tags()) queue(g, n); + } + } + + header("Sibblings with identical tags"); + for (auto g : nonterm_nodes) { + auto process_conns = [&](const pool &stream) { + dict, pool> nodes_by_tags; + for (auto n : stream) { + if (n->terminal) continue; + std::vector key; + for (auto kv : n->tags()) + key.push_back(kv.first), key.push_back(kv.second); + auto &entry = nodes_by_tags[key]; + for (auto m : entry) queue(n, m); + entry.insert(n); + } + }; + process_conns(g->upstream()); + process_conns(g->downstream()); + } + } + + if (!candidates.empty() || effort < 2) goto execute; + + if (!term) { + header("Nodes with single fan-out and compatible tags"); + for (auto g : nonterm_nodes) { + if (GetSize(g->downstream()) != 1) continue; + auto n = *g->downstream().begin(); + if (!n->terminal && compare_tags(g, n, true)) queue(g, n); + } + + header("Nodes with single fan-in and compatible tags"); + for (auto g : nonterm_nodes) { + if (GetSize(g->upstream()) != 1) continue; + auto n = *g->upstream().begin(); + if (!n->terminal && compare_tags(g, n, true)) queue(g, n); + } + } + + if (!candidates.empty() || effort < 3) goto execute; + + if (!term) { + header("Connected nodes with similar tags (strict)"); + for (auto g : nonterm_nodes) { + for (auto n : g->downstream()) + if (!n->terminal && compare_tags(g, n, true) > config.similar_thresh) queue(g, n); + } + } + + if (!candidates.empty() || effort < 4) goto execute; + + if (!term) { + header("Sibblings with similar tags (strict)"); + for (auto g : nonterm_nodes) { + auto process_conns = [&](const pool &stream) { + std::vector nodes; + for (auto n : stream) + if (!n->terminal) nodes.push_back(n); + for (int i = 0; i < GetSize(nodes); i++) + for (int j = 0; j < i; j++) + if (compare_tags(nodes[i], nodes[j], true) > config.similar_thresh) + queue(nodes[i], nodes[j]); + }; + process_conns(g->upstream()); + process_conns(g->downstream()); + } + } + + if (!candidates.empty() || effort < 5) goto execute; + + if (!term) { + header("Connected nodes with similar tags (non-strict)"); + for (auto g : nonterm_nodes) { + for (auto n : g->downstream()) + if (!n->terminal && compare_tags(g, n, false) > config.similar_thresh) queue(g, n); + } + } + + if (!candidates.empty() || effort < 6) goto execute; + + if (!term) { + header("Sibblings with similar tags (non-strict)"); + for (auto g : nonterm_nodes) { + auto process_conns = [&](const pool &stream) { + std::vector nodes; + for (auto n : stream) + if (!n->terminal) nodes.push_back(n); + for (int i = 0; i < GetSize(nodes); i++) + for (int j = 0; j < i; j++) + if (compare_tags(nodes[i], nodes[j], false) > config.similar_thresh) + queue(nodes[i], nodes[j]); + }; + process_conns(g->upstream()); + process_conns(g->downstream()); + } + } + + if (!candidates.empty() || effort < 7) goto execute; + + { + header("Any nodes with identical fan-in or fan-out"); + dict, pool> nodes_by_conn[2]; + for (auto g : term ? term_nodes : nonterm_nodes) { + auto &up_entry = nodes_by_conn[0][g->upstream()]; + auto &down_entry = nodes_by_conn[1][g->downstream()]; + for (auto n : up_entry) queue(g, n); + for (auto n : down_entry) queue(g, n); + up_entry.insert(g); + down_entry.insert(g); + } + } + + if (!candidates.empty() || effort < 8) goto execute; + + if (!term) { + header("Connected nodes with similar tags (lax)"); + for (auto g : nonterm_nodes) { + for (auto n : g->downstream()) + if (!n->terminal && compare_tags(g, n, false)) queue(g, n); + } + } + + if (!candidates.empty() || effort < 9) goto execute; + + if (!term) { + header("Sibblings with similar tags (lax)"); + for (auto g : nonterm_nodes) { + auto process_conns = [&](const pool &stream) { + std::vector nodes; + for (auto n : stream) + if (!n->terminal) nodes.push_back(n); + for (int i = 0; i < GetSize(nodes); i++) + for (int j = 0; j < i; j++) + if (compare_tags(nodes[i], nodes[j], false)) + queue(nodes[i], nodes[j]); + }; + process_conns(g->upstream()); + process_conns(g->downstream()); + } + } + + execute: + header(); + candidates.sort(); + bool small_mode = false; + bool medium_mode = false; + for (auto &candidate_group : candidates) { + for (auto &candidate : candidate_group.second) { + auto g = node(candidate.first); + auto n = node(candidate.second); + if (!term) { + int sz = GetSize(g->names()) + GetSize(n->names()); + if (sz <= config.small_group_thresh) + small_mode = true; + else if (small_mode && sz >= max_group_sizes.back()) + continue; + if (sz <= max_group_sizes.front()) + medium_mode = true; + else if (medium_mode && sz > max_group_sizes.front()) + continue; + } + merge(g, n); + } + } + if (small_mode) + log(" Using 'small-mode' to prevent big groups.\n"); + else if (medium_mode) + log(" Using 'medium-mode' to prevent big groups.\n"); + } while (update()); + + int merged_nodes = GetSize(replaced_nodes) - start_replaced_nodes; + log(" Merged a total of %d nodes.\n", merged_nodes); + return merged_nodes; } }; @@ -504,28 +651,17 @@ struct VizWorker VizWorker(Module *module, const VizConfig &cfg) : config(cfg), module(module), graph(module, config) { - auto &scripts = Graph::scripts(); - config.script = std::min(GetSize(scripts)-1, config.script); - auto &script = scripts.at(config.script); - - if (config.max_size < 0) - config.max_size = graph.nonterm_nodes_cnt / 3; - - auto log_stats = [&](const char *sp, const char *p) { - log("%s%s maximum group sizes are ", sp, p); - for (int i = 0; i < 5; i++) - log("%d%s", graph.max_group_sizes[i], i==3 ? ", and " : i == 4 ? ".\n" : ", "); - log("%s%s number of terminal nodes is %d.\n", sp, p, graph.term_nodes_cnt); - log("%s%s number of non-terminal nodes is %d.\n", sp, p, graph.nonterm_nodes_cnt); - }; - - log("Running 'viz -%d' for module %s:\n", config.script, log_id(module)); - log_stats(" ", "Initial"); - - for (int i = 0; i < GetSize(script); i++) { - log(" Stage-%d merge loop:\n", i+1); - graph.merge(script[i]); - log_stats(" ", i+1 == GetSize(script) ? "Final" : "New"); + for (int effort = 0; effort <= config.effort; effort++) { + bool first = true; + while (1) { + if (!graph.phase(false, effort) && !first) break; + if (!graph.phase(true, effort)) break; + first = false; + } + log(" %s: %d nodes (%d term and %d non-term), %d edges, and %d tags\n", + effort == config.effort ? "Final" : "Status", GetSize(graph.nodes), + GetSize(graph.term_nodes), GetSize(graph.nonterm_nodes), + graph.edge_count, graph.tag_count); } } @@ -537,9 +673,8 @@ struct VizWorker dict, hash_ptr_ops> extra_lines; dict bypass_nodes; - for (auto g : graph.nodes) { - if (!g->terminal || g->nomerge) continue; - if (GetSize(g->upstream()) != 1) continue; + for (auto g : graph.term_nodes) { + if (g->nomerge || GetSize(g->upstream()) != 1) continue; if (!g->downstream().empty() && g->downstream() != g->upstream()) continue; auto n = *(g->upstream().begin()); if (n->terminal) continue; @@ -560,7 +695,7 @@ struct VizWorker label = label + (label.empty() ? "" : "\\n") + log_id(n); fprintf(f, "\tn%d [shape=rectangle,label=\"%s\"];\n", g->index, label.c_str()); } else { - std::string label = stringf("grp=%d | %d cells", g->index, GetSize(g->names())); + std::string label = stringf("vg=%d | %d cells", g->index, GetSize(g->names())); std::string shape = "oval"; if (extra_lines.count(g)) { label += label.empty() ? "" : "\\n"; @@ -573,8 +708,7 @@ struct VizWorker } pool edges; - for (int i = 0; i < GetSize(graph.nodes); i++) { - auto g = graph.nodes[i]; + for (auto g : graph.nodes) { g = bypass_nodes.at(g, g); for (auto n : g->downstream()) { n = bypass_nodes.at(n, n); @@ -627,15 +761,20 @@ struct VizPass : public Pass { log(" -u \n"); log(" manually define a unique group for each wire in the selection.\n"); log("\n"); + log(" -x \n"); + log(" manually exclude wires from being considered. (usually this is\n"); + log(" used for global signals, such as reset.)\n"); + log("\n"); log(" -G .\n"); log(" -U .\n"); - log(" like -u and -g, but parse all arguments up to a terminating . argument\n"); + log(" -X .\n"); + log(" like -u, -g, and -x, but parse all arguments up to a terminating .\n"); log(" as a single select expression. (see 'help select' for details)\n"); log("\n"); log(" -0, -1, -2, -3, -4, -5, -6, -7, -8, -9\n"); log(" select effort level. each level corresponds to an incresingly more\n"); log(" aggressive sequence of strategies for merging nodes of the data flow\n"); - log(" graph. (default: %d)\n", VizConfig().script); + log(" graph. (default: %d)\n", VizConfig().effort); log("\n"); log("When no is specified, 'dot' is used. When no and is\n"); log("specified, 'xdot' is used to display the schematic (POSIX systems only).\n"); @@ -692,24 +831,25 @@ struct VizPass : public Pass { background= ""; continue; } - if ((arg == "-g" || arg == "-u" || arg == "-G" || arg == "-U") && argidx+1 < args.size()) { + if ((arg == "-g" || arg == "-u" || arg == "-x" || arg == "-G" || arg == "-U" || arg == "-X") && argidx+1 < args.size()) { int numargs = 1; int first_arg = ++argidx; - if (arg == "-G" || arg == "-U") { + if (arg == "-G" || arg == "-U" || arg == "-X") { while (argidx+1 < args.size()) { if (args[++argidx] == ".") break; numargs++; } } handle_extra_select_args(this, args, first_arg, first_arg+numargs, design); - auto type = arg == "-g" || arg == "-G" ? VizConfig::TYPE_G : VizConfig::TYPE_U; + auto type = arg == "-g" || arg == "-G" ? VizConfig::TYPE_G : + arg == "-u" || arg == "-U" ? VizConfig::TYPE_U : VizConfig::TYPE_X; config.groups.push_back({type, design->selection_stack.back()}); design->selection_stack.pop_back(); continue; } if (arg == "-0" || arg == "-1" || arg == "-2" || arg == "-3" || arg == "-4" || arg == "-5" || arg == "-6" || arg == "-7" || arg == "-8" || arg == "-9") { - config.script = arg[1] - '0'; + config.effort = arg[1] - '0'; continue; } break; @@ -746,12 +886,12 @@ struct VizPass : public Pass { for (auto module : modlist) { VizWorker worker(module, config); - if (format != "dot" && worker.graph.term_nodes_cnt + worker.graph.nonterm_nodes_cnt > 150) { + if (format != "dot" && GetSize(worker.graph.nodes) > 200) { if (format.empty()) { - log_warning("Suppressing module in output as graph size exceeds 150 nodes.\n"); + log_warning("Suppressing module in output as graph size exceeds 200 nodes.\n"); continue; } else { - log_warning("Changing format to 'dot' as graph size exceeds 150 nodes.\n"); + log_warning("Changing format to 'dot' as graph size exceeds 200 nodes.\n"); format = "dot"; } } From 068031d2aa8af0cc6828d527360934fc788f0430 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Wed, 7 Dec 2022 16:10:58 +0100 Subject: [PATCH 08/14] Improvements in "viz" command Signed-off-by: Claire Xenia Wolf --- passes/cmds/viz.cc | 68 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 51 insertions(+), 17 deletions(-) diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc index 2754eafd6..36375cafa 100644 --- a/passes/cmds/viz.cc +++ b/passes/cmds/viz.cc @@ -670,27 +670,58 @@ struct VizWorker fprintf(f, "digraph \"%s\" {\n", log_id(module)); fprintf(f, " rankdir = LR;\n"); - dict, hash_ptr_ops> extra_lines; + dict>, hash_ptr_ops> extra_lines; dict bypass_nodes; - for (auto g : graph.term_nodes) { - if (g->nomerge || GetSize(g->upstream()) != 1) continue; + auto bypass = [&](GraphNode *g, GraphNode *n) { + log_assert(g->terminal); + log_assert(!n->terminal); + bypass_nodes[g] = n; + + auto &buffer = extra_lines[n]; + buffer.emplace_back(); + + for (auto name : g->names()) + buffer.back().push_back(log_id(name)); + + std::sort(buffer.back().begin(), buffer.back().end()); + std::sort(buffer.begin(), buffer.end()); + }; + + for (auto g : graph.term_nodes) + { + if (bypass_nodes.count(g)) continue; + if (GetSize(g->upstream()) != 1) continue; if (!g->downstream().empty() && g->downstream() != g->upstream()) continue; + auto n = *(g->upstream().begin()); if (n->terminal) continue; - for (auto name : g->names()) - extra_lines[n].push_back(log_id(name)); - bypass_nodes[g] = n; + + bypass(g, n); } - for (int i = 0; i < GetSize(graph.nodes); i++) { - auto g = graph.nodes[i]; + for (auto g : graph.term_nodes) + { + if (bypass_nodes.count(g)) continue; + if (GetSize(g->upstream()) != 1) continue; + + auto n = *(g->upstream().begin()); + if (n->terminal) continue; + + if (GetSize(n->downstream()) != 1) continue; + if (extra_lines.count(n)) continue; + + bypass(g, n); + } + + for (auto g : graph.nodes) { if (g->downstream().empty() && g->upstream().empty()) continue; if (bypass_nodes.count(g)) continue; if (g->terminal) { - std::string label; // = stringf("[%d]\\n", g->index); + g->names().sort(); + std::string label; // = stringf("vg=%d\\n", g->index); for (auto n : g->names()) label = label + (label.empty() ? "" : "\\n") + log_id(n); fprintf(f, "\tn%d [shape=rectangle,label=\"%s\"];\n", g->index, label.c_str()); @@ -698,10 +729,12 @@ struct VizWorker std::string label = stringf("vg=%d | %d cells", g->index, GetSize(g->names())); std::string shape = "oval"; if (extra_lines.count(g)) { - label += label.empty() ? "" : "\\n"; - for (auto line : extra_lines.at(g)) - label = label + (label.empty() ? "" : "\\n") + line; - shape = "octagon"; + for (auto &block : extra_lines.at(g)) { + label += label.empty() ? "" : "\\n"; + for (auto &line : block) + label = label + (label.empty() ? "" : "\\n") + line; + shape = "octagon"; + } } fprintf(f, "\tn%d [shape=%s,label=\"%s\"];\n", g->index, shape.c_str(), label.c_str()); } @@ -709,13 +742,14 @@ struct VizWorker pool edges; for (auto g : graph.nodes) { - g = bypass_nodes.at(g, g); + auto p = bypass_nodes.at(g, g); for (auto n : g->downstream()) { - n = bypass_nodes.at(n, n); - if (g == n) continue; - edges.insert(stringf("n%d -> n%d", g->index, n->index)); + auto q = bypass_nodes.at(n, n); + if (p == q) continue; + edges.insert(stringf("n%d -> n%d", p->index, q->index)); } } + edges.sort(); for (auto e : edges) fprintf(f, "\t%s;\n", e.c_str()); From 172a8e79f0b818a3d7f6634f3149439b34c28b4e Mon Sep 17 00:00:00 2001 From: Jannis Harder Date: Thu, 8 Dec 2022 20:00:01 +0100 Subject: [PATCH 09/14] xprop: Add -split-public option --- passes/cmds/xprop.cc | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/passes/cmds/xprop.cc b/passes/cmds/xprop.cc index c2a1b5c44..fa1976b34 100644 --- a/passes/cmds/xprop.cc +++ b/passes/cmds/xprop.cc @@ -33,6 +33,7 @@ struct XpropOptions { bool split_inputs = false; bool split_outputs = false; + bool split_public = false; bool assume_encoding = false; bool assert_encoding = false; bool assume_def_inputs = false; @@ -1018,6 +1019,31 @@ struct XpropWorker module->fixup_ports(); } + void split_public() + { + if (!options.split_public) + return; + + for (auto wire : module->selected_wires()) { + if (wire->port_input || wire->port_output || !wire->name.isPublic()) + continue; + auto name_d = module->uniquify(stringf("%s_d", wire->name.c_str())); + auto name_x = module->uniquify(stringf("%s_x", wire->name.c_str())); + + auto wire_d = module->addWire(name_d, GetSize(wire)); + auto wire_x = module->addWire(name_x, GetSize(wire)); + + auto enc = encoded(wire); + module->connect(wire_d, enc.is_1); + module->connect(wire_x, enc.is_x); + + module->wires_.erase(wire->name); + wire->attributes.erase(ID::fsm_encoding); + wire->name = NEW_ID_SUFFIX(wire->name.c_str()); + module->wires_[wire->name] = wire; + } + } + void encode_remaining() { pool enc_undriven_wires; @@ -1083,6 +1109,13 @@ struct XpropPass : public Pass { log(" the corresponding bit in _d is ignored for inputs and\n"); log(" guaranteed to be 0 for outputs.\n"); log("\n"); + log(" -split-public\n"); + log(" Replace each public non-port wire with two new wires, one carrying the\n"); + log(" defined values (named _d) and one carrying the mask of which\n"); + log(" bits are x (named _x). When a bit in the _x is set\n"); + log(" the corresponding bit in _d is guaranteed to be 0 for\n"); + log(" outputs.\n"); + log("\n"); log(" -assume-encoding\n"); log(" Add encoding invariants as assumptions. This can speed up formal\n"); log(" verification tasks.\n"); @@ -1129,6 +1162,10 @@ struct XpropPass : public Pass { options.split_outputs = true; continue; } + if (args[argidx] == "-split-public") { + options.split_public = true; + continue; + } if (args[argidx] == "-assume-encoding") { options.assume_encoding = true; continue; @@ -1188,6 +1225,8 @@ struct XpropPass : public Pass { worker.process_cells(); log_debug("Splitting ports.\n"); worker.split_ports(); + log_debug("Splitting public signals.\n"); + worker.split_public(); log_debug("Encode remaining signals.\n"); worker.encode_remaining(); From dc14def5f3172b235e405b43af41ddd4cfab66ee Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Thu, 8 Dec 2022 22:14:16 +0100 Subject: [PATCH 10/14] Add gold-x handing to miter cross port handling Signed-off-by: Claire Xenia Wolf --- passes/sat/miter.cc | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/passes/sat/miter.cc b/passes/sat/miter.cc index 1f64c0216..8f27c4c6f 100644 --- a/passes/sat/miter.cc +++ b/passes/sat/miter.cc @@ -144,8 +144,16 @@ void create_miter_equiv(struct Pass *that, std::vector args, RTLIL: { if (gold_cross_ports.count(gold_wire)) { - RTLIL::Wire *w = miter_module->addWire("\\cross_" + RTLIL::unescape_id(gold_wire->name), gold_wire->width); + SigSpec w = miter_module->addWire("\\cross_" + RTLIL::unescape_id(gold_wire->name), gold_wire->width); gold_cell->setPort(gold_wire->name, w); + if (flag_ignore_gold_x) { + RTLIL::SigSpec w_x = miter_module->addWire(NEW_ID, GetSize(w)); + for (int i = 0; i < GetSize(w); i++) + miter_module->addEqx(NEW_ID, w[i], State::Sx, w_x[i]); + RTLIL::SigSpec w_any = miter_module->And(NEW_ID, miter_module->Anyseq(NEW_ID, GetSize(w)), w_x); + RTLIL::SigSpec w_masked = miter_module->And(NEW_ID, w, miter_module->Not(NEW_ID, w_x)); + w = miter_module->And(NEW_ID, w_any, w_masked); + } gate_cell->setPort(gold_wire->name, w); continue; } From 6a6e1d8424a0232c385676e8ee3dabfa91b5d113 Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Fri, 9 Dec 2022 18:28:17 +0100 Subject: [PATCH 11/14] Improvements in "viz" pass Signed-off-by: Claire Xenia Wolf --- passes/cmds/viz.cc | 124 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 100 insertions(+), 24 deletions(-) diff --git a/passes/cmds/viz.cc b/passes/cmds/viz.cc index 36375cafa..3655f3f49 100644 --- a/passes/cmds/viz.cc +++ b/passes/cmds/viz.cc @@ -43,7 +43,8 @@ struct VizConfig { enum group_type_t { TYPE_G, TYPE_U, - TYPE_X + TYPE_X, + TYPE_S }; int effort = 9; @@ -57,6 +58,8 @@ struct GraphNode { int index = -1; bool nomerge = false; bool terminal = false; + bool excluded = false; + bool special = false; GraphNode *replaced = nullptr; GraphNode *get() { @@ -316,7 +319,9 @@ struct Graph { if (it == wire_nodes.end()) continue; auto n = it->second->get(); - if (grp.first == VizConfig::TYPE_G) { + if (n->nomerge) + continue; + if (grp.first == VizConfig::TYPE_G || grp.first == VizConfig::TYPE_S) { if (g) { if (!n->nomerge) merge(g, n); @@ -332,10 +337,16 @@ struct Graph { } } - if (g) + if (g) { + if (grp.first == VizConfig::TYPE_S) + g->special = true; g->nomerge = true; + } } + for (auto g : excluded) + excluded.insert(g->get()); + dict cell_nodes; dict> sig_users; @@ -351,9 +362,10 @@ struct Graph { if (!bit.wire) continue; auto it = wire_nodes.find(bit); if (it != wire_nodes.end()) { - if (!excluded.count(it->second)) { - g->upstream().insert(it->second); - it->second->downstream().insert(g); + auto n = it->second->get(); + if (!excluded.count(n)) { + g->upstream().insert(n); + n->downstream().insert(g); } } else { sig_users[bit].insert(g); @@ -364,9 +376,10 @@ struct Graph { if (!bit.wire) continue; auto it = wire_nodes.find(bit); if (it != wire_nodes.end()) { - if (!excluded.count(it->second)) { - g->downstream().insert(it->second); - it->second->upstream().insert(g); + auto n = it->second->get(); + if (!excluded.count(n)) { + g->downstream().insert(n); + n->upstream().insert(g); } } } @@ -399,21 +412,43 @@ struct Graph { if (g->tags().empty()) return 100; - int matched_tags = 0; + bool gn_specials = true; + bool g_nonspecials = false; + bool n_nonspecials = false; + + int score = 0; for (auto it : g->tags()) { auto g_tag = it.second; auto n_tag = n->tag(it.first); - if (!g_tag || !n_tag) continue; + log_assert(g_tag != 0); + if (node(it.first)->special) { + gn_specials = true; + if (g_tag != n_tag) return 0; + } else + g_nonspecials = true; + if (n_tag == 0) continue; if (g_tag == n_tag) - matched_tags += 2; - else if (!strict_mode && ((g_tag == 1 && n_tag == 3) || - (g_tag == 3 && n_tag == 1))) - matched_tags += 1; + score += 2; + else if (!strict_mode && (g_tag + n_tag == 4)) + score += 1; else return 0; } + for (auto it : n->tags()) { + auto n_tag = it.second; + log_assert(n_tag != 0); + if (node(it.first)->special) { + gn_specials = true; + auto g_tag = g->tag(it.first); + if (g_tag != n_tag) return 0; + } else + n_nonspecials = true; + } - return (100*matched_tags) / GetSize(g->tags()); + if (gn_specials && (g_nonspecials != n_nonspecials)) + return 0; + + return (100*score) / GetSize(g->tags()); } int phase(bool term, int effort) @@ -665,6 +700,21 @@ struct VizWorker } } + void update_attrs() + { + IdString vg_id("\\vg"); + for (auto c : module->cells()) + c->attributes.erase(vg_id); + for (auto g : graph.nodes) { + for (auto name : g->names()) { + auto w = module->wire(name); + auto c = module->cell(name); + if (w) w->attributes[vg_id] = g->index; + if (c) c->attributes[vg_id] = g->index; + } + } + } + void write_dot(FILE *f) { fprintf(f, "digraph \"%s\" {\n", log_id(module)); @@ -672,6 +722,7 @@ struct VizWorker dict>, hash_ptr_ops> extra_lines; dict bypass_nodes; + pool bypass_candidates; auto bypass = [&](GraphNode *g, GraphNode *n) { log_assert(g->terminal); @@ -688,25 +739,32 @@ struct VizWorker std::sort(buffer.begin(), buffer.end()); }; + for (auto g : graph.nonterm_nodes) { + for (auto n : g->downstream()) + if (!n->terminal) goto not_a_candidate; + bypass_candidates.insert(g); + not_a_candidate:; + } + for (auto g : graph.term_nodes) { - if (bypass_nodes.count(g)) continue; + if (g->special || bypass_nodes.count(g)) continue; if (GetSize(g->upstream()) != 1) continue; if (!g->downstream().empty() && g->downstream() != g->upstream()) continue; auto n = *(g->upstream().begin()); - if (n->terminal) continue; + if (n->terminal || !bypass_candidates.count(n)) continue; bypass(g, n); } for (auto g : graph.term_nodes) { - if (bypass_nodes.count(g)) continue; + if (g->special || bypass_nodes.count(g)) continue; if (GetSize(g->upstream()) != 1) continue; auto n = *(g->upstream().begin()); - if (n->terminal) continue; + if (n->terminal || !bypass_candidates.count(n)) continue; if (GetSize(n->downstream()) != 1) continue; if (extra_lines.count(n)) continue; @@ -788,6 +846,9 @@ struct VizPass : public Pass { log(" don't run viewer in the background, IE wait for the viewer tool to\n"); log(" exit before returning\n"); log("\n"); + log(" -set-vg-attr\n"); + log(" set their group index as 'vg' attribute on cells and wires\n"); + log("\n"); log(" -g \n"); log(" manually define a group of terminal signals. this group is not being\n"); log(" merged with other terminal groups.\n"); @@ -799,10 +860,15 @@ struct VizPass : public Pass { log(" manually exclude wires from being considered. (usually this is\n"); log(" used for global signals, such as reset.)\n"); log("\n"); + log(" -s \n"); + log(" like -g, but mark group as 'special', changing the algorithm to\n"); + log(" preserve as much info about this groups connectivity as possible.\n"); + log("\n"); log(" -G .\n"); log(" -U .\n"); log(" -X .\n"); - log(" like -u, -g, and -x, but parse all arguments up to a terminating .\n"); + log(" -S .\n"); + log(" like -u, -g, -x, and -s, but parse all arguments up to a terminating .\n"); log(" as a single select expression. (see 'help select' for details)\n"); log("\n"); log(" -0, -1, -2, -3, -4, -5, -6, -7, -8, -9\n"); @@ -835,6 +901,7 @@ struct VizPass : public Pass { #endif std::string viewer_exe; bool flag_pause = false; + bool flag_attr = false; bool custom_prefix = false; std::string background = "&"; @@ -861,14 +928,19 @@ struct VizPass : public Pass { flag_pause= true; continue; } + if (arg == "-set-vg-attr") { + flag_attr= true; + continue; + } if (arg == "-nobg") { background= ""; continue; } - if ((arg == "-g" || arg == "-u" || arg == "-x" || arg == "-G" || arg == "-U" || arg == "-X") && argidx+1 < args.size()) { + if ((arg == "-g" || arg == "-u" || arg == "-x" || arg == "-s" || + arg == "-G" || arg == "-U" || arg == "-X" || arg == "-S") && argidx+1 < args.size()) { int numargs = 1; int first_arg = ++argidx; - if (arg == "-G" || arg == "-U" || arg == "-X") { + if (arg == "-G" || arg == "-U" || arg == "-X" || arg == "-S") { while (argidx+1 < args.size()) { if (args[++argidx] == ".") break; numargs++; @@ -876,7 +948,8 @@ struct VizPass : public Pass { } handle_extra_select_args(this, args, first_arg, first_arg+numargs, design); auto type = arg == "-g" || arg == "-G" ? VizConfig::TYPE_G : - arg == "-u" || arg == "-U" ? VizConfig::TYPE_U : VizConfig::TYPE_X; + arg == "-u" || arg == "-U" ? VizConfig::TYPE_U : + arg == "-x" || arg == "-X" ? VizConfig::TYPE_X : VizConfig::TYPE_S; config.groups.push_back({type, design->selection_stack.back()}); design->selection_stack.pop_back(); continue; @@ -920,6 +993,9 @@ struct VizPass : public Pass { for (auto module : modlist) { VizWorker worker(module, config); + if (flag_attr) + worker.update_attrs(); + if (format != "dot" && GetSize(worker.graph.nodes) > 200) { if (format.empty()) { log_warning("Suppressing module in output as graph size exceeds 200 nodes.\n"); From 4a0ed35aab1c7ff85e20f5be6776f101d421290e Mon Sep 17 00:00:00 2001 From: Jannis Harder Date: Fri, 9 Dec 2022 15:02:58 +0100 Subject: [PATCH 12/14] xprop: Improve signal splitting code Avoid splitting output ports twice when combining -split-outputs with -split-public and clean up the corresponding code. --- passes/cmds/xprop.cc | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/passes/cmds/xprop.cc b/passes/cmds/xprop.cc index fa1976b34..5dee72e1b 100644 --- a/passes/cmds/xprop.cc +++ b/passes/cmds/xprop.cc @@ -967,7 +967,7 @@ struct XpropWorker if (!options.split_inputs && !options.split_outputs) return; - vector new_ports; + int port_id = 1; for (auto port : module->ports) { auto wire = module->wire(port); @@ -983,16 +983,21 @@ struct XpropWorker wire_d->port_input = wire->port_input; wire_d->port_output = wire->port_output; - wire_d->port_id = GetSize(new_ports) + 1; + wire_d->port_id = port_id++; wire_x->port_input = wire->port_input; wire_x->port_output = wire->port_output; - wire_x->port_id = GetSize(new_ports) + 2; + wire_x->port_id = port_id++; if (wire->port_output) { auto enc = encoded(wire); module->connect(wire_d, enc.is_1); module->connect(wire_x, enc.is_x); + + if (options.split_public) { + // Need to hide the original wire so split_public doesn't try to split it again + module->rename(wire, NEW_ID_SUFFIX(wire->name.c_str())); + } } else { auto enc = encoded(wire, true); @@ -1004,18 +1009,12 @@ struct XpropWorker wire->port_input = wire->port_output = false; wire->port_id = 0; - new_ports.push_back(port_d); - new_ports.push_back(port_x); - continue; } } - wire->port_id = GetSize(new_ports) + 1; - new_ports.push_back(port); + wire->port_id = port_id++; } - module->ports = new_ports; - module->fixup_ports(); } @@ -1037,10 +1036,7 @@ struct XpropWorker module->connect(wire_d, enc.is_1); module->connect(wire_x, enc.is_x); - module->wires_.erase(wire->name); - wire->attributes.erase(ID::fsm_encoding); - wire->name = NEW_ID_SUFFIX(wire->name.c_str()); - module->wires_[wire->name] = wire; + module->rename(wire, NEW_ID_SUFFIX(wire->name.c_str())); } } From a9072dc23c5aefa4b9f59bb486c20ea6770ed2da Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Wed, 21 Dec 2022 10:41:48 +0100 Subject: [PATCH 13/14] Small bugfix in uniquify pass Signed-off-by: Claire Xenia Wolf --- passes/hierarchy/uniquify.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/passes/hierarchy/uniquify.cc b/passes/hierarchy/uniquify.cc index e9322d359..49b59c8df 100644 --- a/passes/hierarchy/uniquify.cc +++ b/passes/hierarchy/uniquify.cc @@ -52,6 +52,7 @@ struct UniquifyPass : public Pass { // flag_check = true; // continue; // } + break; } extra_args(args, argidx, design); From 1bc832a8e1fe9230379f3a811786bc19cac1f6dc Mon Sep 17 00:00:00 2001 From: Claire Xenia Wolf Date: Wed, 21 Dec 2022 10:43:02 +0100 Subject: [PATCH 14/14] Allow non-unique modules without state in sim writeback-mode Signed-off-by: Claire Xenia Wolf --- passes/sat/sim.cc | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/passes/sat/sim.cc b/passes/sat/sim.cc index e8dda4c45..0084a1f28 100644 --- a/passes/sat/sim.cc +++ b/passes/sat/sim.cc @@ -685,10 +685,11 @@ struct SimInstance void writeback(pool &wbmods) { - if (wbmods.count(module)) - log_error("Instance %s of module %s is not unique: Writeback not possible. (Fix by running 'uniquify'.)\n", hiername().c_str(), log_id(module)); - - wbmods.insert(module); + if (!ff_database.empty() || !mem_database.empty()) { + if (wbmods.count(module)) + log_error("Instance %s of module %s is not unique: Writeback not possible. (Fix by running 'uniquify'.)\n", hiername().c_str(), log_id(module)); + wbmods.insert(module); + } for (auto wire : module->wires()) wire->attributes.erase(ID::init);