mirror of https://github.com/YosysHQ/yosys.git
744 lines
20 KiB
C++
744 lines
20 KiB
C++
/*
|
|
* yosys -- Yosys Open SYnthesis Suite
|
|
*
|
|
* Copyright (C) 2012 Claire Xenia Wolf <claire@yosyshq.com>
|
|
*
|
|
* 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
|
|
|
|
#define COST_DMUX 90
|
|
#define COST_MUX2 100
|
|
#define COST_MUX4 220
|
|
#define COST_MUX8 460
|
|
#define COST_MUX16 940
|
|
|
|
struct MuxcoverWorker
|
|
{
|
|
Module *module;
|
|
SigMap sigmap;
|
|
|
|
struct newmux_t
|
|
{
|
|
int cost;
|
|
vector<SigBit> inputs, selects;
|
|
newmux_t() : cost(0) {}
|
|
};
|
|
|
|
struct tree_t
|
|
{
|
|
SigBit root;
|
|
dict<SigBit, Cell*> muxes;
|
|
dict<SigBit, newmux_t> newmuxes;
|
|
};
|
|
|
|
vector<tree_t> tree_list;
|
|
|
|
dict<tuple<SigBit, SigBit, SigBit>, tuple<SigBit, pool<SigBit>, bool>> decode_mux_cache;
|
|
dict<SigBit, tuple<SigBit, SigBit, SigBit>> decode_mux_reverse_cache;
|
|
int decode_mux_counter;
|
|
|
|
bool use_mux4;
|
|
bool use_mux8;
|
|
bool use_mux16;
|
|
bool nodecode;
|
|
bool nopartial;
|
|
|
|
int cost_dmux;
|
|
int cost_mux2;
|
|
int cost_mux4;
|
|
int cost_mux8;
|
|
int cost_mux16;
|
|
|
|
MuxcoverWorker(Module *module) : module(module), sigmap(module)
|
|
{
|
|
use_mux4 = false;
|
|
use_mux8 = false;
|
|
use_mux16 = false;
|
|
nodecode = false;
|
|
nopartial = false;
|
|
cost_dmux = COST_DMUX;
|
|
cost_mux2 = COST_MUX2;
|
|
cost_mux4 = COST_MUX4;
|
|
cost_mux8 = COST_MUX8;
|
|
cost_mux16 = COST_MUX16;
|
|
decode_mux_counter = 0;
|
|
}
|
|
|
|
bool xcmp(std::initializer_list<SigBit> list)
|
|
{
|
|
auto cursor = list.begin(), end = list.end();
|
|
log_assert(cursor != end);
|
|
SigBit tmp = *(cursor++);
|
|
while (cursor != end) {
|
|
SigBit bit = *(cursor++);
|
|
if (bit == State::Sx)
|
|
continue;
|
|
if (tmp == State::Sx)
|
|
tmp = bit;
|
|
if (bit != tmp)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void treeify()
|
|
{
|
|
pool<SigBit> roots;
|
|
pool<SigBit> used_once;
|
|
dict<SigBit, Cell*> sig_to_mux;
|
|
|
|
for (auto wire : module->wires()) {
|
|
if (!wire->port_output)
|
|
continue;
|
|
for (auto bit : sigmap(wire))
|
|
roots.insert(bit);
|
|
}
|
|
|
|
for (auto cell : module->cells()) {
|
|
for (auto conn : cell->connections()) {
|
|
if (!cell->input(conn.first))
|
|
continue;
|
|
for (auto bit : sigmap(conn.second)) {
|
|
if (used_once.count(bit) || cell->type != ID($_MUX_) || conn.first == ID::S)
|
|
roots.insert(bit);
|
|
used_once.insert(bit);
|
|
}
|
|
}
|
|
if (cell->type == ID($_MUX_))
|
|
sig_to_mux[sigmap(cell->getPort(ID::Y))] = cell;
|
|
}
|
|
|
|
log(" Treeifying %d MUXes:\n", GetSize(sig_to_mux));
|
|
|
|
roots.sort();
|
|
for (auto rootsig : roots)
|
|
{
|
|
tree_t tree;
|
|
tree.root = rootsig;
|
|
|
|
pool<SigBit> wavefront;
|
|
wavefront.insert(rootsig);
|
|
|
|
while (!wavefront.empty()) {
|
|
SigBit bit = wavefront.pop();
|
|
if (sig_to_mux.count(bit) && (bit == rootsig || !roots.count(bit))) {
|
|
Cell *c = sig_to_mux.at(bit);
|
|
tree.muxes[bit] = c;
|
|
wavefront.insert(sigmap(c->getPort(ID::A)));
|
|
wavefront.insert(sigmap(c->getPort(ID::B)));
|
|
}
|
|
}
|
|
|
|
if (!tree.muxes.empty()) {
|
|
log(" Found tree with %d MUXes at root %s.\n", GetSize(tree.muxes), log_signal(tree.root));
|
|
tree_list.push_back(tree);
|
|
}
|
|
}
|
|
|
|
log(" Finished treeification: Found %d trees.\n", GetSize(tree_list));
|
|
}
|
|
|
|
bool follow_muxtree(SigBit &ret_bit, tree_t &tree, SigBit bit, const char *path, bool first_layer = true)
|
|
{
|
|
if (*path) {
|
|
if (tree.muxes.count(bit) == 0) {
|
|
if (first_layer || nopartial)
|
|
return false;
|
|
while (path[0] && path[1])
|
|
path++;
|
|
if (path[0] == 'S')
|
|
ret_bit = State::Sx;
|
|
else
|
|
ret_bit = bit;
|
|
return true;
|
|
}
|
|
char port_name[3] = {'\\', *path, 0};
|
|
return follow_muxtree(ret_bit, tree, sigmap(tree.muxes.at(bit)->getPort(port_name)), path+1, false);
|
|
} else {
|
|
ret_bit = bit;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
int prepare_decode_mux(SigBit &A, SigBit B, SigBit sel, SigBit bit)
|
|
{
|
|
if (A == B || A == State::Sx || B == State::Sx || sel == State::Sx)
|
|
return 0;
|
|
|
|
tuple<SigBit, SigBit, SigBit> key(A, B, sel);
|
|
if (decode_mux_cache.count(key) == 0) {
|
|
auto &entry = decode_mux_cache[key];
|
|
std::get<0>(entry) = module->addWire(NEW_ID);
|
|
std::get<2>(entry) = false;
|
|
decode_mux_reverse_cache[std::get<0>(entry)] = key;
|
|
}
|
|
|
|
auto &entry = decode_mux_cache[key];
|
|
A = std::get<0>(entry);
|
|
std::get<1>(entry).insert(bit);
|
|
|
|
if (std::get<2>(entry))
|
|
return 0;
|
|
|
|
return cost_dmux / GetSize(std::get<1>(entry));
|
|
}
|
|
|
|
void implement_decode_mux(SigBit ctrl_bit)
|
|
{
|
|
if (decode_mux_reverse_cache.count(ctrl_bit) == 0)
|
|
return;
|
|
|
|
auto &key = decode_mux_reverse_cache.at(ctrl_bit);
|
|
auto &entry = decode_mux_cache[key];
|
|
|
|
if (std::get<2>(entry))
|
|
return;
|
|
|
|
implement_decode_mux(std::get<0>(key));
|
|
implement_decode_mux(std::get<1>(key));
|
|
|
|
if (std::get<0>(key) == State::Sx) {
|
|
module->addBufGate(NEW_ID, std::get<1>(key), ctrl_bit);
|
|
} else if (std::get<1>(key) == State::Sx) {
|
|
module->addBufGate(NEW_ID, std::get<0>(key), ctrl_bit);
|
|
} else {
|
|
module->addMuxGate(NEW_ID, std::get<0>(key), std::get<1>(key), std::get<2>(key), ctrl_bit);
|
|
decode_mux_counter++;
|
|
}
|
|
std::get<2>(entry) = true;
|
|
}
|
|
|
|
void find_best_covers(tree_t &tree, const vector<SigBit> &bits)
|
|
{
|
|
for (auto bit : bits)
|
|
find_best_cover(tree, bit);
|
|
}
|
|
|
|
int sum_best_covers(tree_t &tree, const vector<SigBit> &bits)
|
|
{
|
|
int sum = 0;
|
|
for (auto bit : pool<SigBit>(bits.begin(), bits.end())) {
|
|
int cost = tree.newmuxes.at(bit).cost;
|
|
log_debug(" Best cost for %s: %d\n", log_signal(bit), cost);
|
|
sum += cost;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
int find_best_cover(tree_t &tree, SigBit bit)
|
|
{
|
|
if (tree.newmuxes.count(bit)) {
|
|
return tree.newmuxes.at(bit).cost;
|
|
}
|
|
|
|
SigBit A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P;
|
|
SigBit S1, S2, S3, S4, S5, S6, S7, S8;
|
|
SigBit T1, T2, T3, T4;
|
|
SigBit U1, U2;
|
|
SigBit V1;
|
|
|
|
newmux_t best_mux;
|
|
bool ok = true;
|
|
|
|
// 2-Input MUX
|
|
|
|
ok = ok && follow_muxtree(A, tree, bit, "A");
|
|
ok = ok && follow_muxtree(B, tree, bit, "B");
|
|
|
|
ok = ok && follow_muxtree(S1, tree, bit, "S");
|
|
|
|
if (ok)
|
|
{
|
|
newmux_t mux;
|
|
|
|
mux.inputs.push_back(A);
|
|
mux.inputs.push_back(B);
|
|
mux.selects.push_back(S1);
|
|
|
|
find_best_covers(tree, mux.inputs);
|
|
log_debug(" Decode cost for mux2 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
mux.cost += cost_mux2;
|
|
mux.cost += sum_best_covers(tree, mux.inputs);
|
|
|
|
log_debug(" Cost of mux2 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
best_mux = mux;
|
|
}
|
|
|
|
// 4-Input MUX
|
|
|
|
if (use_mux4)
|
|
{
|
|
ok = ok && follow_muxtree(A, tree, bit, "AA");
|
|
ok = ok && follow_muxtree(B, tree, bit, "AB");
|
|
ok = ok && follow_muxtree(C, tree, bit, "BA");
|
|
ok = ok && follow_muxtree(D, tree, bit, "BB");
|
|
|
|
ok = ok && follow_muxtree(S1, tree, bit, "AS");
|
|
ok = ok && follow_muxtree(S2, tree, bit, "BS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({S1, S2});
|
|
|
|
ok = ok && follow_muxtree(T1, tree, bit, "S");
|
|
|
|
if (ok)
|
|
{
|
|
newmux_t mux;
|
|
|
|
mux.inputs.push_back(A);
|
|
mux.inputs.push_back(B);
|
|
mux.inputs.push_back(C);
|
|
mux.inputs.push_back(D);
|
|
|
|
mux.cost += prepare_decode_mux(S1, S2, T1, bit);
|
|
|
|
mux.selects.push_back(S1);
|
|
mux.selects.push_back(T1);
|
|
|
|
find_best_covers(tree, mux.inputs);
|
|
log_debug(" Decode cost for mux4 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
mux.cost += cost_mux4;
|
|
mux.cost += sum_best_covers(tree, mux.inputs);
|
|
|
|
log_debug(" Cost of mux4 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
if (best_mux.cost >= mux.cost)
|
|
best_mux = mux;
|
|
}
|
|
}
|
|
|
|
// 8-Input MUX
|
|
|
|
if (use_mux8)
|
|
{
|
|
ok = ok && follow_muxtree(A, tree, bit, "AAA");
|
|
ok = ok && follow_muxtree(B, tree, bit, "AAB");
|
|
ok = ok && follow_muxtree(C, tree, bit, "ABA");
|
|
ok = ok && follow_muxtree(D, tree, bit, "ABB");
|
|
ok = ok && follow_muxtree(E, tree, bit, "BAA");
|
|
ok = ok && follow_muxtree(F, tree, bit, "BAB");
|
|
ok = ok && follow_muxtree(G, tree, bit, "BBA");
|
|
ok = ok && follow_muxtree(H, tree, bit, "BBB");
|
|
|
|
ok = ok && follow_muxtree(S1, tree, bit, "AAS");
|
|
ok = ok && follow_muxtree(S2, tree, bit, "ABS");
|
|
ok = ok && follow_muxtree(S3, tree, bit, "BAS");
|
|
ok = ok && follow_muxtree(S4, tree, bit, "BBS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({S1, S2, S3, S4});
|
|
|
|
ok = ok && follow_muxtree(T1, tree, bit, "AS");
|
|
ok = ok && follow_muxtree(T2, tree, bit, "BS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({T1, T2});
|
|
|
|
ok = ok && follow_muxtree(U1, tree, bit, "S");
|
|
|
|
if (ok)
|
|
{
|
|
newmux_t mux;
|
|
|
|
mux.inputs.push_back(A);
|
|
mux.inputs.push_back(B);
|
|
mux.inputs.push_back(C);
|
|
mux.inputs.push_back(D);
|
|
mux.inputs.push_back(E);
|
|
mux.inputs.push_back(F);
|
|
mux.inputs.push_back(G);
|
|
mux.inputs.push_back(H);
|
|
|
|
mux.cost += prepare_decode_mux(S1, S2, T1, bit);
|
|
mux.cost += prepare_decode_mux(S3, S4, T2, bit);
|
|
mux.cost += prepare_decode_mux(S1, S3, U1, bit);
|
|
|
|
mux.cost += prepare_decode_mux(T1, T2, U1, bit);
|
|
|
|
mux.selects.push_back(S1);
|
|
mux.selects.push_back(T1);
|
|
mux.selects.push_back(U1);
|
|
|
|
find_best_covers(tree, mux.inputs);
|
|
log_debug(" Decode cost for mux8 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
mux.cost += cost_mux8;
|
|
mux.cost += sum_best_covers(tree, mux.inputs);
|
|
|
|
log_debug(" Cost of mux8 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
if (best_mux.cost >= mux.cost)
|
|
best_mux = mux;
|
|
}
|
|
}
|
|
|
|
// 16-Input MUX
|
|
|
|
if (use_mux16)
|
|
{
|
|
ok = ok && follow_muxtree(A, tree, bit, "AAAA");
|
|
ok = ok && follow_muxtree(B, tree, bit, "AAAB");
|
|
ok = ok && follow_muxtree(C, tree, bit, "AABA");
|
|
ok = ok && follow_muxtree(D, tree, bit, "AABB");
|
|
ok = ok && follow_muxtree(E, tree, bit, "ABAA");
|
|
ok = ok && follow_muxtree(F, tree, bit, "ABAB");
|
|
ok = ok && follow_muxtree(G, tree, bit, "ABBA");
|
|
ok = ok && follow_muxtree(H, tree, bit, "ABBB");
|
|
ok = ok && follow_muxtree(I, tree, bit, "BAAA");
|
|
ok = ok && follow_muxtree(J, tree, bit, "BAAB");
|
|
ok = ok && follow_muxtree(K, tree, bit, "BABA");
|
|
ok = ok && follow_muxtree(L, tree, bit, "BABB");
|
|
ok = ok && follow_muxtree(M, tree, bit, "BBAA");
|
|
ok = ok && follow_muxtree(N, tree, bit, "BBAB");
|
|
ok = ok && follow_muxtree(O, tree, bit, "BBBA");
|
|
ok = ok && follow_muxtree(P, tree, bit, "BBBB");
|
|
|
|
ok = ok && follow_muxtree(S1, tree, bit, "AAAS");
|
|
ok = ok && follow_muxtree(S2, tree, bit, "AABS");
|
|
ok = ok && follow_muxtree(S3, tree, bit, "ABAS");
|
|
ok = ok && follow_muxtree(S4, tree, bit, "ABBS");
|
|
ok = ok && follow_muxtree(S5, tree, bit, "BAAS");
|
|
ok = ok && follow_muxtree(S6, tree, bit, "BABS");
|
|
ok = ok && follow_muxtree(S7, tree, bit, "BBAS");
|
|
ok = ok && follow_muxtree(S8, tree, bit, "BBBS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({S1, S2, S3, S4, S5, S6, S7, S8});
|
|
|
|
ok = ok && follow_muxtree(T1, tree, bit, "AAS");
|
|
ok = ok && follow_muxtree(T2, tree, bit, "ABS");
|
|
ok = ok && follow_muxtree(T3, tree, bit, "BAS");
|
|
ok = ok && follow_muxtree(T4, tree, bit, "BBS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({T1, T2, T3, T4});
|
|
|
|
ok = ok && follow_muxtree(U1, tree, bit, "AS");
|
|
ok = ok && follow_muxtree(U2, tree, bit, "BS");
|
|
|
|
if (nodecode)
|
|
ok = ok && xcmp({U1, U2});
|
|
|
|
ok = ok && follow_muxtree(V1, tree, bit, "S");
|
|
|
|
if (ok)
|
|
{
|
|
newmux_t mux;
|
|
|
|
mux.inputs.push_back(A);
|
|
mux.inputs.push_back(B);
|
|
mux.inputs.push_back(C);
|
|
mux.inputs.push_back(D);
|
|
mux.inputs.push_back(E);
|
|
mux.inputs.push_back(F);
|
|
mux.inputs.push_back(G);
|
|
mux.inputs.push_back(H);
|
|
mux.inputs.push_back(I);
|
|
mux.inputs.push_back(J);
|
|
mux.inputs.push_back(K);
|
|
mux.inputs.push_back(L);
|
|
mux.inputs.push_back(M);
|
|
mux.inputs.push_back(N);
|
|
mux.inputs.push_back(O);
|
|
mux.inputs.push_back(P);
|
|
|
|
mux.cost += prepare_decode_mux(S1, S2, T1, bit);
|
|
mux.cost += prepare_decode_mux(S3, S4, T2, bit);
|
|
mux.cost += prepare_decode_mux(S5, S6, T3, bit);
|
|
mux.cost += prepare_decode_mux(S7, S8, T4, bit);
|
|
mux.cost += prepare_decode_mux(S1, S3, U1, bit);
|
|
mux.cost += prepare_decode_mux(S5, S7, U2, bit);
|
|
mux.cost += prepare_decode_mux(S1, S5, V1, bit);
|
|
|
|
mux.cost += prepare_decode_mux(T1, T2, U1, bit);
|
|
mux.cost += prepare_decode_mux(T3, T4, U2, bit);
|
|
mux.cost += prepare_decode_mux(T1, T3, V1, bit);
|
|
|
|
mux.cost += prepare_decode_mux(U1, U2, V1, bit);
|
|
|
|
mux.selects.push_back(S1);
|
|
mux.selects.push_back(T1);
|
|
mux.selects.push_back(U1);
|
|
mux.selects.push_back(V1);
|
|
|
|
find_best_covers(tree, mux.inputs);
|
|
log_debug(" Decode cost for mux16 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
mux.cost += cost_mux16;
|
|
mux.cost += sum_best_covers(tree, mux.inputs);
|
|
|
|
log_debug(" Cost of mux16 at %s: %d\n", log_signal(bit), mux.cost);
|
|
|
|
if (best_mux.cost >= mux.cost)
|
|
best_mux = mux;
|
|
}
|
|
}
|
|
|
|
tree.newmuxes[bit] = best_mux;
|
|
return best_mux.cost;
|
|
}
|
|
|
|
void implement_best_cover(tree_t &tree, SigBit bit, int count_muxes_by_type[4])
|
|
{
|
|
newmux_t mux = tree.newmuxes.at(bit);
|
|
|
|
for (auto inbit : mux.inputs)
|
|
implement_best_cover(tree, inbit, count_muxes_by_type);
|
|
|
|
for (auto selbit : mux.selects)
|
|
implement_decode_mux(selbit);
|
|
|
|
if (GetSize(mux.inputs) == 0)
|
|
return;
|
|
|
|
if (GetSize(mux.inputs) == 2) {
|
|
count_muxes_by_type[0]++;
|
|
Cell *cell = module->addCell(NEW_ID, ID($_MUX_));
|
|
cell->setPort(ID::A, mux.inputs[0]);
|
|
cell->setPort(ID::B, mux.inputs[1]);
|
|
cell->setPort(ID::S, mux.selects[0]);
|
|
cell->setPort(ID::Y, bit);
|
|
return;
|
|
}
|
|
|
|
if (GetSize(mux.inputs) == 4) {
|
|
count_muxes_by_type[1]++;
|
|
Cell *cell = module->addCell(NEW_ID, ID($_MUX4_));
|
|
cell->setPort(ID::A, mux.inputs[0]);
|
|
cell->setPort(ID::B, mux.inputs[1]);
|
|
cell->setPort(ID::C, mux.inputs[2]);
|
|
cell->setPort(ID::D, mux.inputs[3]);
|
|
cell->setPort(ID::S, mux.selects[0]);
|
|
cell->setPort(ID::T, mux.selects[1]);
|
|
cell->setPort(ID::Y, bit);
|
|
return;
|
|
}
|
|
|
|
if (GetSize(mux.inputs) == 8) {
|
|
count_muxes_by_type[2]++;
|
|
Cell *cell = module->addCell(NEW_ID, ID($_MUX8_));
|
|
cell->setPort(ID::A, mux.inputs[0]);
|
|
cell->setPort(ID::B, mux.inputs[1]);
|
|
cell->setPort(ID::C, mux.inputs[2]);
|
|
cell->setPort(ID::D, mux.inputs[3]);
|
|
cell->setPort(ID::E, mux.inputs[4]);
|
|
cell->setPort(ID::F, mux.inputs[5]);
|
|
cell->setPort(ID::G, mux.inputs[6]);
|
|
cell->setPort(ID::H, mux.inputs[7]);
|
|
cell->setPort(ID::S, mux.selects[0]);
|
|
cell->setPort(ID::T, mux.selects[1]);
|
|
cell->setPort(ID::U, mux.selects[2]);
|
|
cell->setPort(ID::Y, bit);
|
|
return;
|
|
}
|
|
|
|
if (GetSize(mux.inputs) == 16) {
|
|
count_muxes_by_type[3]++;
|
|
Cell *cell = module->addCell(NEW_ID, ID($_MUX16_));
|
|
cell->setPort(ID::A, mux.inputs[0]);
|
|
cell->setPort(ID::B, mux.inputs[1]);
|
|
cell->setPort(ID::C, mux.inputs[2]);
|
|
cell->setPort(ID::D, mux.inputs[3]);
|
|
cell->setPort(ID::E, mux.inputs[4]);
|
|
cell->setPort(ID::F, mux.inputs[5]);
|
|
cell->setPort(ID::G, mux.inputs[6]);
|
|
cell->setPort(ID::H, mux.inputs[7]);
|
|
cell->setPort(ID::I, mux.inputs[8]);
|
|
cell->setPort(ID::J, mux.inputs[9]);
|
|
cell->setPort(ID::K, mux.inputs[10]);
|
|
cell->setPort(ID::L, mux.inputs[11]);
|
|
cell->setPort(ID::M, mux.inputs[12]);
|
|
cell->setPort(ID::N, mux.inputs[13]);
|
|
cell->setPort(ID::O, mux.inputs[14]);
|
|
cell->setPort(ID::P, mux.inputs[15]);
|
|
cell->setPort(ID::S, mux.selects[0]);
|
|
cell->setPort(ID::T, mux.selects[1]);
|
|
cell->setPort(ID::U, mux.selects[2]);
|
|
cell->setPort(ID::V, mux.selects[3]);
|
|
cell->setPort(ID::Y, bit);
|
|
return;
|
|
}
|
|
|
|
log_abort();
|
|
}
|
|
|
|
void treecover(tree_t &tree)
|
|
{
|
|
int count_muxes_by_type[4] = {0, 0, 0, 0};
|
|
log_debug(" Searching for best cover for tree at %s.\n", log_signal(tree.root));
|
|
find_best_cover(tree, tree.root);
|
|
implement_best_cover(tree, tree.root, count_muxes_by_type);
|
|
log(" Replaced tree at %s: %d MUX2, %d MUX4, %d MUX8, %d MUX16\n", log_signal(tree.root),
|
|
count_muxes_by_type[0], count_muxes_by_type[1], count_muxes_by_type[2], count_muxes_by_type[3]);
|
|
for (auto &it : tree.muxes)
|
|
module->remove(it.second);
|
|
}
|
|
|
|
void run()
|
|
{
|
|
log("Covering MUX trees in module %s..\n", log_id(module));
|
|
|
|
treeify();
|
|
|
|
log(" Covering trees:\n");
|
|
|
|
if (!nodecode) {
|
|
log_debug(" Populating cache of decoder muxes.\n");
|
|
for (auto &tree : tree_list) {
|
|
find_best_cover(tree, tree.root);
|
|
tree.newmuxes.clear();
|
|
}
|
|
}
|
|
|
|
for (auto &tree : tree_list)
|
|
treecover(tree);
|
|
|
|
if (!nodecode)
|
|
log(" Added a total of %d decoder MUXes.\n", decode_mux_counter);
|
|
}
|
|
};
|
|
|
|
struct MuxcoverPass : public Pass {
|
|
MuxcoverPass() : Pass("muxcover", "cover trees of MUX cells with wider MUXes") { }
|
|
void help() override
|
|
{
|
|
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
|
|
log("\n");
|
|
log(" muxcover [options] [selection]\n");
|
|
log("\n");
|
|
log("Cover trees of $_MUX_ cells with $_MUX{4,8,16}_ cells\n");
|
|
log("\n");
|
|
log(" -mux4[=cost], -mux8[=cost], -mux16[=cost]\n");
|
|
log(" Cover $_MUX_ trees using the specified types of MUXes (with optional\n");
|
|
log(" integer costs). If none of these options are given, the effect is the\n");
|
|
log(" same as if all of them are.\n");
|
|
log(" Default costs: $_MUX4_ = %d, $_MUX8_ = %d, \n", COST_MUX4, COST_MUX8);
|
|
log(" $_MUX16_ = %d\n", COST_MUX16);
|
|
log("\n");
|
|
log(" -mux2=cost\n");
|
|
log(" Use the specified cost for $_MUX_ cells when making covering decisions.\n");
|
|
log(" Default cost: $_MUX_ = %d\n", COST_MUX2);
|
|
log("\n");
|
|
log(" -dmux=cost\n");
|
|
log(" Use the specified cost for $_MUX_ cells used in decoders.\n");
|
|
log(" Default cost: %d\n", COST_DMUX);
|
|
log("\n");
|
|
log(" -nodecode\n");
|
|
log(" Do not insert decoder logic. This reduces the number of possible\n");
|
|
log(" substitutions, but guarantees that the resulting circuit is not\n");
|
|
log(" less efficient than the original circuit.\n");
|
|
log("\n");
|
|
log(" -nopartial\n");
|
|
log(" Do not consider mappings that use $_MUX<N>_ to select from less\n");
|
|
log(" than <N> different signals.\n");
|
|
log("\n");
|
|
}
|
|
void execute(std::vector<std::string> args, RTLIL::Design *design) override
|
|
{
|
|
log_header(design, "Executing MUXCOVER pass (mapping to wider MUXes).\n");
|
|
|
|
bool use_mux4 = false;
|
|
bool use_mux8 = false;
|
|
bool use_mux16 = false;
|
|
bool nodecode = false;
|
|
bool nopartial = false;
|
|
int cost_dmux = COST_DMUX;
|
|
int cost_mux2 = COST_MUX2;
|
|
int cost_mux4 = COST_MUX4;
|
|
int cost_mux8 = COST_MUX8;
|
|
int cost_mux16 = COST_MUX16;
|
|
|
|
size_t argidx;
|
|
for (argidx = 1; argidx < args.size(); argidx++)
|
|
{
|
|
const auto &arg = args[argidx];
|
|
if (arg.size() >= 6 && arg.compare(0,6,"-mux2=") == 0) {
|
|
cost_mux2 = atoi(arg.substr(6).c_str());
|
|
continue;
|
|
}
|
|
if (arg.size() >= 5 && arg.compare(0,5,"-mux4") == 0) {
|
|
use_mux4 = true;
|
|
if (arg.size() > 5) {
|
|
if (arg[5] != '=') break;
|
|
cost_mux4 = atoi(arg.substr(6).c_str());
|
|
}
|
|
continue;
|
|
}
|
|
if (arg.size() >= 5 && arg.compare(0,5,"-mux8") == 0) {
|
|
use_mux8 = true;
|
|
if (arg.size() > 5) {
|
|
if (arg[5] != '=') break;
|
|
cost_mux8 = atoi(arg.substr(6).c_str());
|
|
}
|
|
continue;
|
|
}
|
|
if (arg.size() >= 6 && arg.compare(0,6,"-mux16") == 0) {
|
|
use_mux16 = true;
|
|
if (arg.size() > 6) {
|
|
if (arg[6] != '=') break;
|
|
cost_mux16 = atoi(arg.substr(7).c_str());
|
|
}
|
|
continue;
|
|
}
|
|
if (arg.size() >= 6 && arg.compare(0,6,"-dmux=") == 0) {
|
|
cost_dmux = atoi(arg.substr(6).c_str());
|
|
continue;
|
|
}
|
|
if (arg == "-nodecode") {
|
|
nodecode = true;
|
|
continue;
|
|
}
|
|
if (arg == "-nopartial") {
|
|
nopartial = true;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
extra_args(args, argidx, design);
|
|
|
|
if (!use_mux4 && !use_mux8 && !use_mux16) {
|
|
use_mux4 = true;
|
|
use_mux8 = true;
|
|
use_mux16 = true;
|
|
}
|
|
|
|
for (auto module : design->selected_modules())
|
|
{
|
|
MuxcoverWorker worker(module);
|
|
worker.use_mux4 = use_mux4;
|
|
worker.use_mux8 = use_mux8;
|
|
worker.use_mux16 = use_mux16;
|
|
worker.cost_dmux = cost_dmux;
|
|
worker.cost_mux2 = cost_mux2;
|
|
worker.cost_mux4 = cost_mux4;
|
|
worker.cost_mux8 = cost_mux8;
|
|
worker.cost_mux16 = cost_mux16;
|
|
worker.nodecode = nodecode;
|
|
worker.nopartial = nopartial;
|
|
worker.run();
|
|
}
|
|
}
|
|
} MuxcoverPass;
|
|
|
|
PRIVATE_NAMESPACE_END
|