riscv
/
yosys
mirror of https://github.com/YosysHQ/yosys.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Implemented off-chain support for extract_reduce

This commit is contained in:
Andrew Zonenberg 2017-09-15 13:56:00 -07:00
parent 3404934c9c
commit 7b3966714c
1 changed files with 165 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
passes/techmap/extract_reduce.cc
View File

@ -55,6 +55,13 @@ struct ExtractReducePass : public Pass
log("\n");
}
inline bool IsRightType(Cell* cell, GateType gt)
{
return (cell->type == "$_AND_" && gt == GateType::And) ||
(cell->type == "$_OR_" && gt == GateType::Or) ||
(cell->type == "$_XOR_" && gt == GateType::Xor);
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
log_header(design, "Executing EXTRACT_REDUCE pass.\n");
@ -69,7 +76,6 @@ struct ExtractReducePass : public Pass
allow_off_chain = true;
continue;
}
break;
}
extra_args(args, argidx, design);
@ -109,7 +115,6 @@ struct ExtractReducePass : public Pass
// Actual logic starts here
pool<Cell*> consumed_cells;
pool<Cell*> head_cells;
for (auto cell : module->selected_cells())
{
if (consumed_cells.count(cell))
@ -128,14 +133,15 @@ struct ExtractReducePass : public Pass
log("Working on cell %s...\n", cell->name.c_str());
// Go all the way to the sink
// If looking for a single chain, follow linearly to the sink
pool<Cell*> sinks;
if(!allow_off_chain)
{
Cell* head_cell = cell;
Cell* x = cell;
while (true)
{
if (!((x->type == "$_AND_" && gt == GateType::And) ||
(x->type == "$_OR_" && gt == GateType::Or) ||
(x->type == "$_XOR_" && gt == GateType::Xor)))
if(!IsRightType(x, gt))
break;
head_cell = x;
@ -150,8 +156,72 @@ struct ExtractReducePass : public Pass
x = *sig_to_sink[y[0]].begin();
}
sinks.insert(head_cell);
}
//If off-chain loads are allowed, we have to do a wider traversal to see what the longest chain is
else
{
//BFS, following all chains until they hit a cell of a different type
//Pick the longest one
auto y = sigmap(cell->getPort("\\Y"));
pool<Cell*> current_loads = sig_to_sink[y];
pool<Cell*> next_loads;
while(!current_loads.empty())
{
//Find each sink and see what they are
for(auto x : current_loads)
{
//Not one of our gates? Don't follow any further
//(but add the originating cell to the list of sinks)
if(!IsRightType(x, gt))
{
sinks.insert(cell);
continue;
}
//If this signal drives a port, add it to the sinks
//(even though it may not be the end of a chain)
if(port_sigs.count(x) && !consumed_cells.count(x))
sinks.insert(x);
//It's a match, search everything out from it
auto& next = sig_to_sink[x];
for(auto z : next)
next_loads.insert(z);
}
//If we couldn't find any downstream loads, stop.
//Create a reduction for each of the max-length chains we found
if(next_loads.empty())
{
for(auto s : current_loads)
{
//Not one of our gates? Don't follow any further
if(!IsRightType(s, gt))
continue;
sinks.insert(s);
}
break;
}
//Otherwise, continue down the chain
current_loads = next_loads;
next_loads.clear();
}
}
//We have our list, go act on it
for(auto head_cell : sinks)
{
log(" Head cell is %s\n", head_cell->name.c_str());
//Avoid duplication if we already were covered
if(consumed_cells.count(head_cell))
continue;
pool<Cell*> cur_supercell;
std::deque<Cell*> bfs_queue = {head_cell};
while (bfs_queue.size())
@ -163,16 +233,15 @@ struct ExtractReducePass : public Pass
auto a = sigmap(x->getPort("\\A"));
log_assert(a.size() == 1);
// Must have only one sink
// Must have only one sink unless we're going off chain
// XXX: Check that it is indeed this node?
if (sig_to_sink[a[0]].size() + port_sigs.count(a[0]) == 1)
if( allow_off_chain || (sig_to_sink[a[0]].size() + port_sigs.count(a[0]) == 1) )
{
Cell* cell_a = sig_to_driver[a[0]];
if (cell_a && ((cell_a->type == "$_AND_" && gt == GateType::And) ||
(cell_a->type == "$_OR_" && gt == GateType::Or) ||
(cell_a->type == "$_XOR_" && gt == GateType::Xor)))
if(cell_a && IsRightType(cell_a, gt))
{
// The cell here is the correct type, and it's definitely driving only
// The cell here is the correct type, and it's definitely driving
// this current cell.
bfs_queue.push_back(cell_a);
}
@ -180,14 +249,13 @@ struct ExtractReducePass : public Pass
auto b = sigmap(x->getPort("\\B"));
log_assert(b.size() == 1);
// Must have only one sink
// XXX: Check that it is indeed this node?
if (sig_to_sink[b[0]].size() + port_sigs.count(b[0]) == 1)
if( allow_off_chain || (sig_to_sink[b[0]].size() + port_sigs.count(b[0]) == 1) )
{
Cell* cell_b = sig_to_driver[b[0]];
if (cell_b && ((cell_b->type == "$_AND_" && gt == GateType::And) ||
(cell_b->type == "$_OR_" && gt == GateType::Or) ||
(cell_b->type == "$_XOR_" && gt == GateType::Xor)))
if(cell_b && IsRightType(cell_b, gt))
{
// The cell here is the correct type, and it's definitely driving only
// this current cell.
@ -230,15 +298,20 @@ struct ExtractReducePass : public Pass
new_reduce_cell->setPort("\\A", input);
new_reduce_cell->setPort("\\Y", output);
if(allow_off_chain)
consumed_cells.insert(head_cell);
else
{
for (auto x : cur_supercell)
consumed_cells.insert(x);
head_cells.insert(head_cell);
}
}
}
}
// Remove all of the head cells, since we supplant them.
// Do not remove the upstream cells since some might still be in use ("clean" will get rid of unused ones)
for (auto cell : head_cells)
for (auto cell : consumed_cells)
module->remove(cell);
}