riscv
/
OpenFPGA
mirror of https://github.com/lnis-uofu/OpenFPGA.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1280 from lnis-uofu/xt_vtr_upgrade 

Upgrade VTR to the latest
This commit is contained in:
tangxifan 2023-08-09 10:18:55 -07:00 committed by GitHub
parent 7c836dea47 788e3c17a9
commit 9ed537c9ae
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 442 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -109,9 +109,9 @@ endif()
include(CheckCXXCompilerFlag) include(CheckCXXCompilerFlag)
# #
# We require c++14 support # We require c++17 support
# #
set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) #No compiler specific extensions set(CMAKE_CXX_EXTENSIONS OFF) #No compiler specific extensions

46
openfpga/src/annotation/annotate_rr_graph.cpp
View File

@ -21,7 +21,7 @@ namespace openfpga {
/* Build a RRChan Object with the given channel type and coorindators */ /* Build a RRChan Object with the given channel type and coorindators */
static RRChan build_one_rr_chan(const DeviceContext& vpr_device_ctx, static RRChan build_one_rr_chan(const DeviceContext& vpr_device_ctx,
const t_rr_type& chan_type, const t_rr_type& chan_type, const size_t& layer,
vtr::Point<size_t>& chan_coord) { vtr::Point<size_t>& chan_coord) {
std::vector<RRNodeId> chan_rr_nodes; std::vector<RRNodeId> chan_rr_nodes;
@ -32,7 +32,7 @@ static RRChan build_one_rr_chan(const DeviceContext& vpr_device_ctx,
/* Collect rr_nodes for this channel */ /* Collect rr_nodes for this channel */
chan_rr_nodes = find_rr_graph_chan_nodes( chan_rr_nodes = find_rr_graph_chan_nodes(
vpr_device_ctx.rr_graph, chan_coord.x(), chan_coord.y(), chan_type); vpr_device_ctx.rr_graph, layer, chan_coord.x(), chan_coord.y(), chan_type);
/* Fill the rr_chan */ /* Fill the rr_chan */
for (const RRNodeId& chan_rr_node : chan_rr_nodes) { for (const RRNodeId& chan_rr_node : chan_rr_nodes) {
rr_chan.add_node(vpr_device_ctx.rr_graph, chan_rr_node, rr_chan.add_node(vpr_device_ctx.rr_graph, chan_rr_node,
@ -96,6 +96,7 @@ static RRChan build_one_rr_chan(const DeviceContext& vpr_device_ctx,
*/ */
static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx, static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
const vtr::Point<size_t>& gsb_range, const vtr::Point<size_t>& gsb_range,
const size_t& layer,
const vtr::Point<size_t>& gsb_coord, const vtr::Point<size_t>& gsb_coord,
const bool& include_clock) { const bool& include_clock) {
/* Create an object to return */ /* Create an object to return */
@ -133,7 +134,7 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
/* Routing channels*/ /* Routing channels*/
/* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */ /* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */
/* Create a rr_chan object and check if it is unique in the graph */ /* Create a rr_chan object and check if it is unique in the graph */
rr_chan = build_one_rr_chan(vpr_device_ctx, CHANY, coordinate); rr_chan = build_one_rr_chan(vpr_device_ctx, CHANY, layer, coordinate);
chan_dir_to_port_dir_mapping[0] = chan_dir_to_port_dir_mapping[0] =
OUT_PORT; /* INC_DIRECTION => OUT_PORT */ OUT_PORT; /* INC_DIRECTION => OUT_PORT */
chan_dir_to_port_dir_mapping[1] = chan_dir_to_port_dir_mapping[1] =
@ -147,12 +148,12 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
opin_grid_side[1] = LEFT; opin_grid_side[1] = LEFT;
/* Include Grid[x][y+1] RIGHT side outputs pins */ /* Include Grid[x][y+1] RIGHT side outputs pins */
temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x(), vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer, gsb_coord.x(),
gsb_coord.y() + 1, OPIN, opin_grid_side[0]); gsb_coord.y() + 1, OPIN, opin_grid_side[0]);
/* Include Grid[x+1][y+1] Left side output pins */ /* Include Grid[x+1][y+1] Left side output pins */
temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x() + 1, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer,
gsb_coord.y() + 1, OPIN, opin_grid_side[1]); gsb_coord.x() + 1, gsb_coord.y() + 1, OPIN, opin_grid_side[1]);
break; break;
case RIGHT: /* RIGHT = 1 */ case RIGHT: /* RIGHT = 1 */
@ -165,7 +166,7 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
/* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */ /* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */
/* Collect rr_nodes for Tracks for top: chany[x][y+1] */ /* Collect rr_nodes for Tracks for top: chany[x][y+1] */
/* Create a rr_chan object and check if it is unique in the graph */ /* Create a rr_chan object and check if it is unique in the graph */
rr_chan = build_one_rr_chan(vpr_device_ctx, CHANX, coordinate); rr_chan = build_one_rr_chan(vpr_device_ctx, CHANX, layer, coordinate);
chan_dir_to_port_dir_mapping[0] = chan_dir_to_port_dir_mapping[0] =
OUT_PORT; /* INC_DIRECTION => OUT_PORT */ OUT_PORT; /* INC_DIRECTION => OUT_PORT */
chan_dir_to_port_dir_mapping[1] = chan_dir_to_port_dir_mapping[1] =
@ -180,12 +181,12 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
/* include Grid[x+1][y+1] Bottom side output pins */ /* include Grid[x+1][y+1] Bottom side output pins */
temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x() + 1, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer,
gsb_coord.y() + 1, OPIN, opin_grid_side[0]); gsb_coord.x() + 1, gsb_coord.y() + 1, OPIN, opin_grid_side[0]);
/* include Grid[x+1][y] Top side output pins */ /* include Grid[x+1][y] Top side output pins */
temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x() + 1, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer,
gsb_coord.y(), OPIN, opin_grid_side[1]); gsb_coord.x() + 1, gsb_coord.y(), OPIN, opin_grid_side[1]);
break; break;
case BOTTOM: /* BOTTOM = 2*/ case BOTTOM: /* BOTTOM = 2*/
/* For the border, we should take special care */ /* For the border, we should take special care */
@ -197,7 +198,7 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
/* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */ /* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */
/* Collect rr_nodes for Tracks for bottom: chany[x][y] */ /* Collect rr_nodes for Tracks for bottom: chany[x][y] */
/* Create a rr_chan object and check if it is unique in the graph */ /* Create a rr_chan object and check if it is unique in the graph */
rr_chan = build_one_rr_chan(vpr_device_ctx, CHANY, coordinate); rr_chan = build_one_rr_chan(vpr_device_ctx, CHANY, layer, coordinate);
chan_dir_to_port_dir_mapping[0] = chan_dir_to_port_dir_mapping[0] =
IN_PORT; /* INC_DIRECTION => IN_PORT */ IN_PORT; /* INC_DIRECTION => IN_PORT */
chan_dir_to_port_dir_mapping[1] = chan_dir_to_port_dir_mapping[1] =
@ -211,11 +212,11 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
opin_grid_side[1] = RIGHT; opin_grid_side[1] = RIGHT;
/* include Grid[x+1][y] Left side output pins */ /* include Grid[x+1][y] Left side output pins */
temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x() + 1, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer,
gsb_coord.y(), OPIN, opin_grid_side[0]); gsb_coord.x() + 1, gsb_coord.y(), OPIN, opin_grid_side[0]);
/* include Grid[x][y] Right side output pins */ /* include Grid[x][y] Right side output pins */
temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x(), vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer, gsb_coord.x(),
gsb_coord.y(), OPIN, opin_grid_side[1]); gsb_coord.y(), OPIN, opin_grid_side[1]);
break; break;
case LEFT: /* LEFT = 3 */ case LEFT: /* LEFT = 3 */
@ -228,7 +229,7 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
/* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */ /* Side: TOP => 0, RIGHT => 1, BOTTOM => 2, LEFT => 3 */
/* Collect rr_nodes for Tracks for left: chanx[x][y] */ /* Collect rr_nodes for Tracks for left: chanx[x][y] */
/* Create a rr_chan object and check if it is unique in the graph */ /* Create a rr_chan object and check if it is unique in the graph */
rr_chan = build_one_rr_chan(vpr_device_ctx, CHANX, coordinate); rr_chan = build_one_rr_chan(vpr_device_ctx, CHANX, layer, coordinate);
chan_dir_to_port_dir_mapping[0] = chan_dir_to_port_dir_mapping[0] =
IN_PORT; /* INC_DIRECTION => IN_PORT */ IN_PORT; /* INC_DIRECTION => IN_PORT */
chan_dir_to_port_dir_mapping[1] = chan_dir_to_port_dir_mapping[1] =
@ -241,11 +242,11 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
opin_grid_side[1] = TOP; opin_grid_side[1] = TOP;
/* include Grid[x][y+1] Bottom side outputs pins */ /* include Grid[x][y+1] Bottom side outputs pins */
temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[0] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x(), vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer, gsb_coord.x(),
gsb_coord.y() + 1, OPIN, opin_grid_side[0]); gsb_coord.y() + 1, OPIN, opin_grid_side[0]);
/* include Grid[x][y] Top side output pins */ /* include Grid[x][y] Top side output pins */
temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes( temp_opin_rr_nodes[1] = find_rr_graph_grid_nodes(
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, gsb_coord.x(), vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer, gsb_coord.x(),
gsb_coord.y(), OPIN, opin_grid_side[1]); gsb_coord.y(), OPIN, opin_grid_side[1]);
break; break;
default: default:
@ -369,9 +370,9 @@ static RRGSB build_rr_gsb(const DeviceContext& vpr_device_ctx,
continue; continue;
} }
/* Collect IPIN rr_nodes*/ /* Collect IPIN rr_nodes*/
temp_ipin_rr_nodes = temp_ipin_rr_nodes = find_rr_graph_grid_nodes(
find_rr_graph_grid_nodes(vpr_device_ctx.rr_graph, vpr_device_ctx.grid, ix, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, layer, ix, iy, IPIN,
iy, IPIN, ipin_rr_node_grid_side, include_clock); ipin_rr_node_grid_side, include_clock);
/* Fill the ipin nodes of RRGSB */ /* Fill the ipin nodes of RRGSB */
for (const RRNodeId& inode : temp_ipin_rr_nodes) { for (const RRNodeId& inode : temp_ipin_rr_nodes) {
/* Skip those has no configurable outgoing, they should NOT appear in the /* Skip those has no configurable outgoing, they should NOT appear in the
@ -422,6 +423,7 @@ void annotate_device_rr_gsb(const DeviceContext& vpr_device_ctx,
gsb_range.x(), gsb_range.y()); gsb_range.x(), gsb_range.y());
size_t gsb_cnt = 0; size_t gsb_cnt = 0;
size_t layer = 0;
/* For each switch block, determine the size of array */ /* For each switch block, determine the size of array */
for (size_t ix = 0; ix < gsb_range.x(); ++ix) { for (size_t ix = 0; ix < gsb_range.x(); ++ix) {
for (size_t iy = 0; iy < gsb_range.y(); ++iy) { for (size_t iy = 0; iy < gsb_range.y(); ++iy) {
@ -433,7 +435,7 @@ void annotate_device_rr_gsb(const DeviceContext& vpr_device_ctx,
build_rr_gsb(vpr_device_ctx, build_rr_gsb(vpr_device_ctx,
vtr::Point<size_t>(vpr_device_ctx.grid.width() - 2, vtr::Point<size_t>(vpr_device_ctx.grid.width() - 2,
vpr_device_ctx.grid.height() - 2), vpr_device_ctx.grid.height() - 2),
vtr::Point<size_t>(ix, iy), include_clock); layer, vtr::Point<size_t>(ix, iy), include_clock);
/* Add to device_rr_gsb */ /* Add to device_rr_gsb */
vtr::Point<size_t> gsb_coordinate = rr_gsb.get_sb_coordinate(); vtr::Point<size_t> gsb_coordinate = rr_gsb.get_sb_coordinate();

4
openfpga/src/annotation/annotate_simulation_setting.cpp
View File

@ -15,8 +15,8 @@
/* Headers from vpr library */ /* Headers from vpr library */
#include "AnalysisDelayCalculator.h" #include "AnalysisDelayCalculator.h"
#include "annotate_simulation_setting.h" #include "annotate_simulation_setting.h"
#include "concrete_timing_info.h"
#include "net_delay.h" #include "net_delay.h"
#include "timing_info.h"
/* begin namespace openfpga */ /* begin namespace openfpga */
namespace openfpga { namespace openfpga {
@ -212,7 +212,7 @@ int annotate_simulation_setting(
make_net_pins_matrix<float>((const Netlist<>&)cluster_ctx.clb_nlist); make_net_pins_matrix<float>((const Netlist<>&)cluster_ctx.clb_nlist);
/* Load the net delays */ /* Load the net delays */
load_net_delay_from_routing((const Netlist<>&)cluster_ctx.clb_nlist, load_net_delay_from_routing((const Netlist<>&)cluster_ctx.clb_nlist,
net_delay, false); net_delay);
/* Do final timing analysis */ /* Do final timing analysis */
auto analysis_delay_calc = std::make_shared<AnalysisDelayCalculator>( auto analysis_delay_calc = std::make_shared<AnalysisDelayCalculator>(

102
openfpga/src/annotation/append_clock_rr_graph.cpp
View File

@ -44,6 +44,7 @@ static size_t estimate_clock_rr_graph_num_chan_nodes(
* Note that switch blocks do not require any new nodes but new edges * Note that switch blocks do not require any new nodes but new edges
*******************************************************************/ *******************************************************************/
static size_t estimate_clock_rr_graph_num_nodes(const DeviceGrid& grids, static size_t estimate_clock_rr_graph_num_nodes(const DeviceGrid& grids,
const size_t& layer,
const bool& through_channel, const bool& through_channel,
const ClockNetwork& clk_ntwk) { const ClockNetwork& clk_ntwk) {
size_t num_nodes = 0; size_t num_nodes = 0;
@ -54,7 +55,7 @@ static size_t estimate_clock_rr_graph_num_nodes(const DeviceGrid& grids,
/* Bypass if the routing channel does not exist when through channels are /* Bypass if the routing channel does not exist when through channels are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chanx_exist(grids, chanx_coord))) { (false == is_chanx_exist(grids, layer, chanx_coord))) {
continue; continue;
} }
/* Estimate the routing tracks required by clock routing only */ /* Estimate the routing tracks required by clock routing only */
@ -68,7 +69,7 @@ static size_t estimate_clock_rr_graph_num_nodes(const DeviceGrid& grids,
/* Bypass if the routing channel does not exist when through channel are /* Bypass if the routing channel does not exist when through channel are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chany_exist(grids, chany_coord))) { (false == is_chany_exist(grids, layer, chany_coord))) {
continue; continue;
} }
/* Estimate the routing tracks required by clock routing only */ /* Estimate the routing tracks required by clock routing only */
@ -87,11 +88,12 @@ static size_t estimate_clock_rr_graph_num_nodes(const DeviceGrid& grids,
static void add_rr_graph_block_clock_nodes( static void add_rr_graph_block_clock_nodes(
RRGraphBuilder& rr_graph_builder, RRClockSpatialLookup& clk_rr_lookup, RRGraphBuilder& rr_graph_builder, RRClockSpatialLookup& clk_rr_lookup,
const RRGraphView& rr_graph_view, const ClockNetwork& clk_ntwk, const RRGraphView& rr_graph_view, const ClockNetwork& clk_ntwk,
const vtr::Point<size_t> chan_coord, const t_rr_type& chan_type, const size_t& layer, const vtr::Point<size_t> chan_coord,
const int& cost_index_offset, const bool& verbose) { const t_rr_type& chan_type, const int& cost_index_offset,
const bool& verbose) {
size_t orig_chan_width = size_t orig_chan_width =
rr_graph_view.node_lookup() rr_graph_view.node_lookup()
.find_channel_nodes(chan_coord.x(), chan_coord.y(), chan_type) .find_channel_nodes(layer, chan_coord.x(), chan_coord.y(), chan_type)
.size(); .size();
size_t curr_node_ptc = orig_chan_width; size_t curr_node_ptc = orig_chan_width;
@ -115,9 +117,10 @@ static void add_rr_graph_block_clock_nodes(
for (size_t ipin = 0; ipin < num_pins / 2; ++ipin) { for (size_t ipin = 0; ipin < num_pins / 2; ++ipin) {
for (auto node_dir : {Direction::INC, Direction::DEC}) { for (auto node_dir : {Direction::INC, Direction::DEC}) {
RRNodeId clk_node = rr_graph_builder.create_node( RRNodeId clk_node = rr_graph_builder.create_node(
chan_coord.x(), chan_coord.y(), chan_type, curr_node_ptc); layer, chan_coord.x(), chan_coord.y(), chan_type, curr_node_ptc);
rr_graph_builder.set_node_direction(clk_node, node_dir); rr_graph_builder.set_node_direction(clk_node, node_dir);
rr_graph_builder.set_node_capacity(clk_node, 1); rr_graph_builder.set_node_capacity(clk_node, 1);
rr_graph_builder.set_node_layer(clk_node, layer);
/* set cost_index using segment id */ /* set cost_index using segment id */
rr_graph_builder.set_node_cost_index( rr_graph_builder.set_node_cost_index(
clk_node, RRIndexedDataId(cost_index_offset + clk_node, RRIndexedDataId(cost_index_offset +
@ -145,13 +148,11 @@ static void add_rr_graph_block_clock_nodes(
* Add clock nodes one by one to the routing resource graph. * Add clock nodes one by one to the routing resource graph.
* Assign node-level attributes properly and register in dedicated lookup * Assign node-level attributes properly and register in dedicated lookup
*******************************************************************/ *******************************************************************/
static void add_rr_graph_clock_nodes(RRGraphBuilder& rr_graph_builder, static void add_rr_graph_clock_nodes(
RRClockSpatialLookup& clk_rr_lookup, RRGraphBuilder& rr_graph_builder, RRClockSpatialLookup& clk_rr_lookup,
const RRGraphView& rr_graph_view, const RRGraphView& rr_graph_view, const DeviceGrid& grids,
const DeviceGrid& grids, const size_t& layer, const bool& through_channel,
const bool& through_channel, const ClockNetwork& clk_ntwk, const bool& verbose) {
const ClockNetwork& clk_ntwk,
const bool& verbose) {
/* Pre-allocate memory: Must do otherwise data will be messed up! */ /* Pre-allocate memory: Must do otherwise data will be messed up! */
clk_rr_lookup.reserve_nodes(grids.width(), grids.height(), clk_rr_lookup.reserve_nodes(grids.width(), grids.height(),
clk_ntwk.num_trees(), clk_ntwk.max_tree_depth(), clk_ntwk.num_trees(), clk_ntwk.max_tree_depth(),
@ -164,12 +165,12 @@ static void add_rr_graph_clock_nodes(RRGraphBuilder& rr_graph_builder,
/* Bypass if the routing channel does not exist when through channels are /* Bypass if the routing channel does not exist when through channels are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chanx_exist(grids, chanx_coord))) { (false == is_chanx_exist(grids, layer, chanx_coord))) {
continue; continue;
} }
add_rr_graph_block_clock_nodes(rr_graph_builder, clk_rr_lookup, add_rr_graph_block_clock_nodes(
rr_graph_view, clk_ntwk, chanx_coord, rr_graph_builder, clk_rr_lookup, rr_graph_view, clk_ntwk, layer,
CHANX, CHANX_COST_INDEX_START, verbose); chanx_coord, CHANX, CHANX_COST_INDEX_START, verbose);
VTR_ASSERT(rr_graph_view.valid_node( VTR_ASSERT(rr_graph_view.valid_node(
clk_rr_lookup.find_node(1, 0, ClockTreeId(0), ClockLevelId(0), clk_rr_lookup.find_node(1, 0, ClockTreeId(0), ClockLevelId(0),
ClockTreePinId(0), Direction::INC))); ClockTreePinId(0), Direction::INC)));
@ -186,13 +187,13 @@ static void add_rr_graph_clock_nodes(RRGraphBuilder& rr_graph_builder,
/* Bypass if the routing channel does not exist when through channel are /* Bypass if the routing channel does not exist when through channel are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chany_exist(grids, chany_coord))) { (false == is_chany_exist(grids, layer, chany_coord))) {
continue; continue;
} }
add_rr_graph_block_clock_nodes( add_rr_graph_block_clock_nodes(
rr_graph_builder, clk_rr_lookup, rr_graph_view, clk_ntwk, chany_coord, rr_graph_builder, clk_rr_lookup, rr_graph_view, clk_ntwk, layer,
CHANY, CHANX_COST_INDEX_START + rr_graph_view.num_rr_segments(), chany_coord, CHANY,
verbose); CHANX_COST_INDEX_START + rr_graph_view.num_rr_segments(), verbose);
VTR_ASSERT(rr_graph_view.valid_node( VTR_ASSERT(rr_graph_view.valid_node(
clk_rr_lookup.find_node(1, 0, ClockTreeId(0), ClockLevelId(0), clk_rr_lookup.find_node(1, 0, ClockTreeId(0), ClockLevelId(0),
ClockTreePinId(0), Direction::INC))); ClockTreePinId(0), Direction::INC)));
@ -392,11 +393,12 @@ static std::vector<RRNodeId> find_clock_track2track_node(
*******************************************************************/ *******************************************************************/
static void try_find_and_add_clock_track2ipin_node( static void try_find_and_add_clock_track2ipin_node(
std::vector<RRNodeId>& des_nodes, const DeviceGrid& grids, std::vector<RRNodeId>& des_nodes, const DeviceGrid& grids,
const RRGraphView& rr_graph_view, const vtr::Point<size_t>& grid_coord, const RRGraphView& rr_graph_view, const size_t& layer,
const e_side& pin_side, const ClockNetwork& clk_ntwk, const vtr::Point<size_t>& grid_coord, const e_side& pin_side,
const ClockTreeId& clk_tree, const ClockTreePinId& clk_pin) { const ClockNetwork& clk_ntwk, const ClockTreeId& clk_tree,
t_physical_tile_type_ptr grid_type = const ClockTreePinId& clk_pin) {
grids.get_physical_type(grid_coord.x(), grid_coord.y()); t_physical_tile_type_ptr grid_type = grids.get_physical_type(
t_physical_tile_loc(grid_coord.x(), grid_coord.y(), layer));
for (std::string tap_pin_name : for (std::string tap_pin_name :
clk_ntwk.tree_flatten_taps(clk_tree, clk_pin)) { clk_ntwk.tree_flatten_taps(clk_tree, clk_pin)) {
/* tap pin name could be 'io[5:5].a2f[0]' */ /* tap pin name could be 'io[5:5].a2f[0]' */
@ -405,7 +407,7 @@ static void try_find_and_add_clock_track2ipin_node(
continue; continue;
} }
RRNodeId des_node = rr_graph_view.node_lookup().find_node( RRNodeId des_node = rr_graph_view.node_lookup().find_node(
grid_coord.x(), grid_coord.y(), IPIN, grid_pin_idx, pin_side); layer, grid_coord.x(), grid_coord.y(), IPIN, grid_pin_idx, pin_side);
if (rr_graph_view.valid_node(des_node)) { if (rr_graph_view.valid_node(des_node)) {
des_nodes.push_back(des_node); des_nodes.push_back(des_node);
} }
@ -440,36 +442,36 @@ static void try_find_and_add_clock_track2ipin_node(
*******************************************************************/ *******************************************************************/
static std::vector<RRNodeId> find_clock_track2ipin_node( static std::vector<RRNodeId> find_clock_track2ipin_node(
const DeviceGrid& grids, const RRGraphView& rr_graph_view, const DeviceGrid& grids, const RRGraphView& rr_graph_view,
const t_rr_type& chan_type, const vtr::Point<size_t>& chan_coord, const t_rr_type& chan_type, const size_t& layer,
const ClockNetwork& clk_ntwk, const ClockTreeId& clk_tree, const vtr::Point<size_t>& chan_coord, const ClockNetwork& clk_ntwk,
const ClockTreePinId& clk_pin) { const ClockTreeId& clk_tree, const ClockTreePinId& clk_pin) {
std::vector<RRNodeId> des_nodes; std::vector<RRNodeId> des_nodes;
if (chan_type == CHANX) { if (chan_type == CHANX) {
/* Get the clock IPINs at the BOTTOM side of adjacent grids [x][y+1] */ /* Get the clock IPINs at the BOTTOM side of adjacent grids [x][y+1] */
vtr::Point<size_t> bot_grid_coord(chan_coord.x(), chan_coord.y() + 1); vtr::Point<size_t> bot_grid_coord(chan_coord.x(), chan_coord.y() + 1);
try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view, try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view,
bot_grid_coord, BOTTOM, clk_ntwk, layer, bot_grid_coord, BOTTOM,
clk_tree, clk_pin); clk_ntwk, clk_tree, clk_pin);
/* Get the clock IPINs at the TOP side of adjacent grids [x][y] */ /* Get the clock IPINs at the TOP side of adjacent grids [x][y] */
vtr::Point<size_t> top_grid_coord(chan_coord.x(), chan_coord.y()); vtr::Point<size_t> top_grid_coord(chan_coord.x(), chan_coord.y());
try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view, try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view,
top_grid_coord, TOP, clk_ntwk, layer, top_grid_coord, TOP, clk_ntwk,
clk_tree, clk_pin); clk_tree, clk_pin);
} else { } else {
VTR_ASSERT(chan_type == CHANY); VTR_ASSERT(chan_type == CHANY);
/* Get the clock IPINs at the LEFT side of adjacent grids [x][y+1] */ /* Get the clock IPINs at the LEFT side of adjacent grids [x][y+1] */
vtr::Point<size_t> left_grid_coord(chan_coord.x() + 1, chan_coord.y()); vtr::Point<size_t> left_grid_coord(chan_coord.x() + 1, chan_coord.y());
try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view, try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view,
left_grid_coord, LEFT, clk_ntwk, layer, left_grid_coord, LEFT,
clk_tree, clk_pin); clk_ntwk, clk_tree, clk_pin);
/* Get the clock IPINs at the RIGHT side of adjacent grids [x][y] */ /* Get the clock IPINs at the RIGHT side of adjacent grids [x][y] */
vtr::Point<size_t> right_grid_coord(chan_coord.x(), chan_coord.y()); vtr::Point<size_t> right_grid_coord(chan_coord.x(), chan_coord.y());
try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view, try_find_and_add_clock_track2ipin_node(des_nodes, grids, rr_graph_view,
right_grid_coord, RIGHT, clk_ntwk, layer, right_grid_coord, RIGHT,
clk_tree, clk_pin); clk_ntwk, clk_tree, clk_pin);
} }
return des_nodes; return des_nodes;
@ -481,7 +483,7 @@ static std::vector<RRNodeId> find_clock_track2ipin_node(
static void add_rr_graph_block_clock_edges( static void add_rr_graph_block_clock_edges(
RRGraphBuilder& rr_graph_builder, size_t& num_edges_to_create, RRGraphBuilder& rr_graph_builder, size_t& num_edges_to_create,
const RRClockSpatialLookup& clk_rr_lookup, const RRGraphView& rr_graph_view, const RRClockSpatialLookup& clk_rr_lookup, const RRGraphView& rr_graph_view,
const DeviceGrid& grids, const ClockNetwork& clk_ntwk, const DeviceGrid& grids, const size_t& layer, const ClockNetwork& clk_ntwk,
const vtr::Point<size_t>& chan_coord, const t_rr_type& chan_type, const vtr::Point<size_t>& chan_coord, const t_rr_type& chan_type,
const bool& verbose) { const bool& verbose) {
size_t edge_count = 0; size_t edge_count = 0;
@ -524,7 +526,7 @@ static void add_rr_graph_block_clock_edges(
/* Create edges */ /* Create edges */
VTR_ASSERT(rr_graph_view.valid_node(des_node)); VTR_ASSERT(rr_graph_view.valid_node(des_node));
rr_graph_builder.create_edge(src_node, des_node, rr_graph_builder.create_edge(src_node, des_node,
clk_ntwk.default_switch()); clk_ntwk.default_switch(), false);
edge_count++; edge_count++;
} }
VTR_LOGV(verbose, "\tWill add %lu edges to other clock nodes\n", VTR_LOGV(verbose, "\tWill add %lu edges to other clock nodes\n",
@ -535,12 +537,12 @@ static void add_rr_graph_block_clock_edges(
if (clk_ntwk.is_last_level(itree, ilvl)) { if (clk_ntwk.is_last_level(itree, ilvl)) {
size_t curr_edge_count = edge_count; size_t curr_edge_count = edge_count;
for (RRNodeId des_node : find_clock_track2ipin_node( for (RRNodeId des_node : find_clock_track2ipin_node(
grids, rr_graph_view, chan_type, chan_coord, clk_ntwk, itree, grids, rr_graph_view, chan_type, layer, chan_coord, clk_ntwk,
ClockTreePinId(ipin))) { itree, ClockTreePinId(ipin))) {
/* Create edges */ /* Create edges */
VTR_ASSERT(rr_graph_view.valid_node(des_node)); VTR_ASSERT(rr_graph_view.valid_node(des_node));
rr_graph_builder.create_edge(src_node, des_node, rr_graph_builder.create_edge(src_node, des_node,
clk_ntwk.default_switch()); clk_ntwk.default_switch(), false);
edge_count++; edge_count++;
} }
VTR_LOGV(verbose, "\tWill add %lu edges to other IPIN\n", VTR_LOGV(verbose, "\tWill add %lu edges to other IPIN\n",
@ -579,7 +581,7 @@ static void add_rr_graph_block_clock_edges(
static void add_rr_graph_clock_edges( static void add_rr_graph_clock_edges(
RRGraphBuilder& rr_graph_builder, size_t& num_edges_to_create, RRGraphBuilder& rr_graph_builder, size_t& num_edges_to_create,
const RRClockSpatialLookup& clk_rr_lookup, const RRGraphView& rr_graph_view, const RRClockSpatialLookup& clk_rr_lookup, const RRGraphView& rr_graph_view,
const DeviceGrid& grids, const bool& through_channel, const DeviceGrid& grids, const size_t& layer, const bool& through_channel,
const ClockNetwork& clk_ntwk, const bool& verbose) { const ClockNetwork& clk_ntwk, const bool& verbose) {
/* Add edges which is driven by X-direction clock routing tracks */ /* Add edges which is driven by X-direction clock routing tracks */
for (size_t iy = 0; iy < grids.height() - 1; ++iy) { for (size_t iy = 0; iy < grids.height() - 1; ++iy) {
@ -588,11 +590,11 @@ static void add_rr_graph_clock_edges(
/* Bypass if the routing channel does not exist when through channels are /* Bypass if the routing channel does not exist when through channels are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chanx_exist(grids, chanx_coord))) { (false == is_chanx_exist(grids, layer, chanx_coord))) {
continue; continue;
} }
add_rr_graph_block_clock_edges(rr_graph_builder, num_edges_to_create, add_rr_graph_block_clock_edges(rr_graph_builder, num_edges_to_create,
clk_rr_lookup, rr_graph_view, grids, clk_rr_lookup, rr_graph_view, grids, layer,
clk_ntwk, chanx_coord, CHANX, verbose); clk_ntwk, chanx_coord, CHANX, verbose);
} }
} }
@ -604,11 +606,11 @@ static void add_rr_graph_clock_edges(
/* Bypass if the routing channel does not exist when through channel are /* Bypass if the routing channel does not exist when through channel are
* not allowed */ * not allowed */
if ((false == through_channel) && if ((false == through_channel) &&
(false == is_chany_exist(grids, chany_coord))) { (false == is_chany_exist(grids, layer, chany_coord))) {
continue; continue;
} }
add_rr_graph_block_clock_edges(rr_graph_builder, num_edges_to_create, add_rr_graph_block_clock_edges(rr_graph_builder, num_edges_to_create,
clk_rr_lookup, rr_graph_view, grids, clk_rr_lookup, rr_graph_view, grids, layer,
clk_ntwk, chany_coord, CHANY, verbose); clk_ntwk, chany_coord, CHANY, verbose);
} }
} }
@ -647,7 +649,7 @@ int append_clock_rr_graph(DeviceContext& vpr_device_ctx,
/* Estimate the number of nodes and pre-allocate */ /* Estimate the number of nodes and pre-allocate */
size_t orig_num_nodes = vpr_device_ctx.rr_graph.num_nodes(); size_t orig_num_nodes = vpr_device_ctx.rr_graph.num_nodes();
size_t num_clock_nodes = estimate_clock_rr_graph_num_nodes( size_t num_clock_nodes = estimate_clock_rr_graph_num_nodes(
vpr_device_ctx.grid, vpr_device_ctx.arch->through_channel, clk_ntwk); vpr_device_ctx.grid, 0, vpr_device_ctx.arch->through_channel, clk_ntwk);
vpr_device_ctx.rr_graph_builder.unlock_storage(); vpr_device_ctx.rr_graph_builder.unlock_storage();
vpr_device_ctx.rr_graph_builder.reserve_nodes(num_clock_nodes + vpr_device_ctx.rr_graph_builder.reserve_nodes(num_clock_nodes +
orig_num_nodes); orig_num_nodes);
@ -658,7 +660,7 @@ int append_clock_rr_graph(DeviceContext& vpr_device_ctx,
/* Add clock nodes */ /* Add clock nodes */
add_rr_graph_clock_nodes(vpr_device_ctx.rr_graph_builder, clk_rr_lookup, add_rr_graph_clock_nodes(vpr_device_ctx.rr_graph_builder, clk_rr_lookup,
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, 0,
vpr_device_ctx.arch->through_channel, clk_ntwk, vpr_device_ctx.arch->through_channel, clk_ntwk,
verbose); verbose);
VTR_LOGV(verbose, VTR_LOGV(verbose,
@ -673,7 +675,7 @@ int append_clock_rr_graph(DeviceContext& vpr_device_ctx,
add_rr_graph_clock_edges( add_rr_graph_clock_edges(
vpr_device_ctx.rr_graph_builder, num_clock_edges, vpr_device_ctx.rr_graph_builder, num_clock_edges,
static_cast<const RRClockSpatialLookup&>(clk_rr_lookup), static_cast<const RRClockSpatialLookup&>(clk_rr_lookup),
vpr_device_ctx.rr_graph, vpr_device_ctx.grid, vpr_device_ctx.rr_graph, vpr_device_ctx.grid, 0,
vpr_device_ctx.arch->through_channel, clk_ntwk, verbose); vpr_device_ctx.arch->through_channel, clk_ntwk, verbose);
VTR_LOGV(verbose, VTR_LOGV(verbose,
"Added %lu clock edges to routing " "Added %lu clock edges to routing "

10
openfpga/src/annotation/openfpga_annotate_routing.cpp
View File

@ -2,10 +2,10 @@
* This file includes functions that are used to annotate routing results * This file includes functions that are used to annotate routing results
* from VPR to OpenFPGA * from VPR to OpenFPGA
*******************************************************************/ *******************************************************************/
/* Headers from vtrutil library */
#include "openfpga_annotate_routing.h" #include "openfpga_annotate_routing.h"
#include "annotate_routing.h" #include "annotate_routing.h"
#include "old_traceback.h"
#include "vtr_assert.h" #include "vtr_assert.h"
#include "vtr_log.h" #include "vtr_log.h"
@ -134,14 +134,15 @@ void annotate_rr_node_previous_nodes(
/* Cache Previous nodes */ /* Cache Previous nodes */
RRNodeId prev_node = RRNodeId::INVALID(); RRNodeId prev_node = RRNodeId::INVALID();
t_trace* tptr = routing_ctx.trace[net_id].head; t_trace* tptr = TracebackCompat::traceback_from_route_tree(
routing_ctx.route_trees[net_id].value());
t_trace* head = tptr;
while (tptr != nullptr) { while (tptr != nullptr) {
RRNodeId rr_node = RRNodeId(tptr->index); RRNodeId rr_node = RRNodeId(tptr->index);
/* Find the right previous node */ /* Find the right previous node */
prev_node = find_previous_node_from_routing_traces( prev_node = find_previous_node_from_routing_traces(
device_ctx.rr_graph, routing_ctx.trace[net_id].head, prev_node, device_ctx.rr_graph, head, prev_node, rr_node);
rr_node);
/* Only update mapped nodes */ /* Only update mapped nodes */
if (prev_node) { if (prev_node) {
@ -156,6 +157,7 @@ void annotate_rr_node_previous_nodes(
/* Move on to the next */ /* Move on to the next */
tptr = tptr->next; tptr = tptr->next;
} }
free_traceback(head);
} }
VTR_LOG("Done with %d nodes mapping\n", counter); VTR_LOG("Done with %d nodes mapping\n", counter);

5
openfpga/src/annotation/vpr_placement_annotation.cpp
View File

@ -32,8 +32,9 @@ void VprPlacementAnnotation::init_mapped_blocks(const DeviceGrid& grids) {
for (size_t x = 0; x < grids.width(); ++x) { for (size_t x = 0; x < grids.width(); ++x) {
for (size_t y = 0; y < grids.height(); ++y) { for (size_t y = 0; y < grids.height(); ++y) {
/* Deposit invalid ids and we will fill later */ /* Deposit invalid ids and we will fill later */
blocks_[x][y].resize(grids.get_physical_type(x, y)->capacity, blocks_[x][y].resize(
ClusterBlockId::INVALID()); grids.get_physical_type(t_physical_tile_loc(x, y, 0))->capacity,
ClusterBlockId::INVALID());
} }
} }
} }

36
openfpga/src/base/openfpga_pb_pin_fixup.cpp
View File

@ -34,13 +34,13 @@ namespace openfpga {
static void update_cluster_pin_with_post_routing_results( static void update_cluster_pin_with_post_routing_results(
const DeviceContext& device_ctx, const ClusteringContext& clustering_ctx, const DeviceContext& device_ctx, const ClusteringContext& clustering_ctx,
const VprRoutingAnnotation& vpr_routing_annotation, const VprRoutingAnnotation& vpr_routing_annotation,
VprClusteringAnnotation& vpr_clustering_annotation, VprClusteringAnnotation& vpr_clustering_annotation, const size_t& layer,
const vtr::Point<size_t>& grid_coord, const ClusterBlockId& blk_id, const vtr::Point<size_t>& grid_coord, const ClusterBlockId& blk_id,
const e_side& border_side, const size_t& z, const bool& verbose) { const e_side& border_side, const size_t& z, const bool& verbose) {
/* Handle each pin */ /* Handle each pin */
auto logical_block = clustering_ctx.clb_nlist.block_type(blk_id); auto logical_block = clustering_ctx.clb_nlist.block_type(blk_id);
auto physical_tile = auto physical_tile = device_ctx.grid.get_physical_type(
device_ctx.grid.get_physical_type(grid_coord.x(), grid_coord.y()); t_physical_tile_loc(grid_coord.x(), grid_coord.y(), layer));
for (int j = 0; j < logical_block->pb_type->num_pins; j++) { for (int j = 0; j < logical_block->pb_type->num_pins; j++) {
/* Get the ptc num for the pin in rr_graph, we need t consider the z offset /* Get the ptc num for the pin in rr_graph, we need t consider the z offset
@ -86,7 +86,8 @@ static void update_cluster_pin_with_post_routing_results(
/* Find the net mapped to this pin in routing results */ /* Find the net mapped to this pin in routing results */
const RRNodeId& rr_node = device_ctx.rr_graph.node_lookup().find_node( const RRNodeId& rr_node = device_ctx.rr_graph.node_lookup().find_node(
grid_coord.x(), grid_coord.y(), rr_node_type, physical_pin, pin_side); layer, grid_coord.x(), grid_coord.y(), rr_node_type, physical_pin,
pin_side);
if (false == device_ctx.rr_graph.valid_node(rr_node)) { if (false == device_ctx.rr_graph.valid_node(rr_node)) {
continue; continue;
} }
@ -192,16 +193,21 @@ void update_pb_pin_with_post_routing_results(
* post-routing clustering result sync-up */ * post-routing clustering result sync-up */
vpr_clustering_annotation.clear_net_remapping(); vpr_clustering_annotation.clear_net_remapping();
size_t layer = 0;
/* Update the core logic (center blocks of the FPGA) */ /* Update the core logic (center blocks of the FPGA) */
for (size_t x = 1; x < device_ctx.grid.width() - 1; ++x) { for (size_t x = 1; x < device_ctx.grid.width() - 1; ++x) {
for (size_t y = 1; y < device_ctx.grid.height() - 1; ++y) { for (size_t y = 1; y < device_ctx.grid.height() - 1; ++y) {
t_physical_tile_type_ptr phy_tile =
device_ctx.grid.get_physical_type(t_physical_tile_loc(x, y, layer));
/* Bypass the EMPTY tiles */ /* Bypass the EMPTY tiles */
if (true == is_empty_type(device_ctx.grid.get_physical_type(x, y))) { if (true == is_empty_type(phy_tile)) {
continue; continue;
} }
/* Get the mapped blocks to this grid */ /* Get the mapped blocks to this grid */
for (const ClusterBlockId& cluster_blk_id : for (int isubtile = 0; isubtile < phy_tile->capacity; ++isubtile) {
placement_ctx.grid_blocks[x][y].blocks) { ClusterBlockId cluster_blk_id =
placement_ctx.grid_blocks.block_at_location(
{(int)x, (int)y, (int)isubtile, (int)layer});
/* Skip invalid ids */ /* Skip invalid ids */
if (ClusterBlockId::INVALID() == cluster_blk_id) { if (ClusterBlockId::INVALID() == cluster_blk_id) {
continue; continue;
@ -211,8 +217,9 @@ void update_pb_pin_with_post_routing_results(
vtr::Point<size_t> grid_coord(x, y); vtr::Point<size_t> grid_coord(x, y);
update_cluster_pin_with_post_routing_results( update_cluster_pin_with_post_routing_results(
device_ctx, clustering_ctx, vpr_routing_annotation, device_ctx, clustering_ctx, vpr_routing_annotation,
vpr_clustering_annotation, grid_coord, cluster_blk_id, NUM_SIDES, vpr_clustering_annotation, layer, grid_coord, cluster_blk_id,
placement_ctx.block_locs[cluster_blk_id].loc.sub_tile, verbose); NUM_SIDES, placement_ctx.block_locs[cluster_blk_id].loc.sub_tile,
verbose);
} }
} }
} }
@ -224,14 +231,17 @@ void update_pb_pin_with_post_routing_results(
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coord : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coord : io_coordinates[io_side]) {
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
device_ctx.grid.get_physical_type(io_coord.x(), io_coord.y()); device_ctx.grid.get_physical_type(
t_physical_tile_loc(io_coord.x(), io_coord.y(), layer));
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Get the mapped blocks to this grid */ /* Get the mapped blocks to this grid */
for (const ClusterBlockId& cluster_blk_id : for (int isubtile = 0; isubtile < phy_tile_type->capacity; ++isubtile) {
placement_ctx.grid_blocks[io_coord.x()][io_coord.y()].blocks) { ClusterBlockId cluster_blk_id =
placement_ctx.grid_blocks.block_at_location(
{(int)io_coord.x(), (int)io_coord.y(), (int)isubtile, (int)layer});
/* Skip invalid ids */ /* Skip invalid ids */
if (ClusterBlockId::INVALID() == cluster_blk_id) { if (ClusterBlockId::INVALID() == cluster_blk_id) {
continue; continue;
@ -239,7 +249,7 @@ void update_pb_pin_with_post_routing_results(
/* Update on I/O grid */ /* Update on I/O grid */
update_cluster_pin_with_post_routing_results( update_cluster_pin_with_post_routing_results(
device_ctx, clustering_ctx, vpr_routing_annotation, device_ctx, clustering_ctx, vpr_routing_annotation,
vpr_clustering_annotation, io_coord, cluster_blk_id, io_side, vpr_clustering_annotation, layer, io_coord, cluster_blk_id, io_side,
placement_ctx.block_locs[cluster_blk_id].loc.sub_tile, verbose); placement_ctx.block_locs[cluster_blk_id].loc.sub_tile, verbose);
} }
} }

24
openfpga/src/fabric/build_fabric_io_location_map.cpp
View File

@ -32,7 +32,8 @@ namespace openfpga {
*(x, y, z) coordinate to the actual indices *(x, y, z) coordinate to the actual indices
*******************************************************************/ *******************************************************************/
static IoLocationMap build_fabric_fine_grained_io_location_map( static IoLocationMap build_fabric_fine_grained_io_location_map(
const ModuleManager& module_manager, const DeviceGrid& grids) { const ModuleManager& module_manager, const DeviceGrid& grids,
const size_t& layer) {
vtr::ScopedStartFinishTimer timer( vtr::ScopedStartFinishTimer timer(
"Create I/O location mapping for top module"); "Create I/O location mapping for top module");
@ -50,8 +51,9 @@ static IoLocationMap build_fabric_fine_grained_io_location_map(
ModuleId child = module_manager.io_children(top_module)[ichild]; ModuleId child = module_manager.io_children(top_module)[ichild];
vtr::Point<int> coord = vtr::Point<int> coord =
module_manager.io_child_coordinates(top_module)[ichild]; module_manager.io_child_coordinates(top_module)[ichild];
t_physical_tile_loc phy_tile_loc(coord.x(), coord.y(), layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(coord.x(), coord.y()); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
@ -59,8 +61,8 @@ static IoLocationMap build_fabric_fine_grained_io_location_map(
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(coord.x(), coord.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(coord.x(), coord.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
@ -153,7 +155,8 @@ static IoLocationMap build_fabric_fine_grained_io_location_map(
*(x, y, z) coordinate to the actual indices *(x, y, z) coordinate to the actual indices
*******************************************************************/ *******************************************************************/
static IoLocationMap build_fabric_tiled_io_location_map( static IoLocationMap build_fabric_tiled_io_location_map(
const ModuleManager& module_manager, const DeviceGrid& grids) { const ModuleManager& module_manager, const DeviceGrid& grids,
const size_t& layer) {
vtr::ScopedStartFinishTimer timer( vtr::ScopedStartFinishTimer timer(
"Create I/O location mapping for top module"); "Create I/O location mapping for top module");
@ -171,8 +174,9 @@ static IoLocationMap build_fabric_tiled_io_location_map(
ModuleId child = module_manager.io_children(top_module)[ichild]; ModuleId child = module_manager.io_children(top_module)[ichild];
vtr::Point<int> coord = vtr::Point<int> coord =
module_manager.io_child_coordinates(top_module)[ichild]; module_manager.io_child_coordinates(top_module)[ichild];
t_physical_tile_loc phy_tile_loc(coord.x(), coord.y(), layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(coord.x(), coord.y()); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
@ -180,8 +184,8 @@ static IoLocationMap build_fabric_tiled_io_location_map(
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(coord.x(), coord.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(coord.x(), coord.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
@ -280,9 +284,9 @@ IoLocationMap build_fabric_io_location_map(const ModuleManager& module_manager,
const DeviceGrid& grids, const DeviceGrid& grids,
const bool& tiled_fabric) { const bool& tiled_fabric) {
if (tiled_fabric) { if (tiled_fabric) {
return build_fabric_tiled_io_location_map(module_manager, grids); return build_fabric_tiled_io_location_map(module_manager, grids, 0);
} }
return build_fabric_fine_grained_io_location_map(module_manager, grids); return build_fabric_fine_grained_io_location_map(module_manager, grids, 0);
} }
} /* end namespace openfpga */ } /* end namespace openfpga */

15
openfpga/src/fabric/build_fabric_tile.cpp
View File

@ -29,6 +29,7 @@ namespace openfpga {
*******************************************************************/ *******************************************************************/
static int build_fabric_tile_style_top_left(FabricTile& fabric_tile, static int build_fabric_tile_style_top_left(FabricTile& fabric_tile,
const DeviceGrid& grids, const DeviceGrid& grids,
const size_t& layer,
const DeviceRRGSB& device_rr_gsb, const DeviceRRGSB& device_rr_gsb,
const bool& verbose) { const bool& verbose) {
int status_code = CMD_EXEC_SUCCESS; int status_code = CMD_EXEC_SUCCESS;
@ -36,7 +37,9 @@ static int build_fabric_tile_style_top_left(FabricTile& fabric_tile,
/* Walk through all the device rr_gsb and create tile one by one */ /* Walk through all the device rr_gsb and create tile one by one */
for (size_t ix = 0; ix < grids.width(); ++ix) { for (size_t ix = 0; ix < grids.width(); ++ix) {
for (size_t iy = 0; iy < grids.height(); ++iy) { for (size_t iy = 0; iy < grids.height(); ++iy) {
t_physical_tile_type_ptr phy_tile_type = grids.get_physical_type(ix, iy); t_physical_tile_loc tile_loc(ix, iy, layer);
t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(tile_loc);
bool skip_add_pb = false; bool skip_add_pb = false;
vtr::Point<size_t> curr_tile_coord(ix, iy); vtr::Point<size_t> curr_tile_coord(ix, iy);
vtr::Point<size_t> curr_gsb_coord(ix, iy - 1); vtr::Point<size_t> curr_gsb_coord(ix, iy - 1);
@ -56,15 +59,15 @@ static int build_fabric_tile_style_top_left(FabricTile& fabric_tile,
"programmable block\n", "programmable block\n",
curr_tile_coord.x(), curr_tile_coord.y()); curr_tile_coord.x(), curr_tile_coord.y());
curr_tile_id = fabric_tile.create_tile(curr_tile_coord); curr_tile_id = fabric_tile.create_tile(curr_tile_coord);
} else if ((0 < grids.get_width_offset(ix, iy)) || } else if ((0 < grids.get_width_offset(tile_loc)) ||
(0 < grids.get_height_offset(ix, iy))) { (0 < grids.get_height_offset(tile_loc))) {
/* Skip width, height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width, height > 1 tiles (mostly heterogeneous blocks) */
/* Find the root of this grid, the instance id should be valid. /* Find the root of this grid, the instance id should be valid.
* We just copy it here * We just copy it here
*/ */
vtr::Point<size_t> root_tile_coord( vtr::Point<size_t> root_tile_coord(
ix - grids.get_width_offset(ix, iy), ix - grids.get_width_offset(tile_loc),
iy - grids.get_height_offset(ix, iy)); iy - grids.get_height_offset(tile_loc));
skip_add_pb = true; skip_add_pb = true;
VTR_LOGV(verbose, VTR_LOGV(verbose,
"Tile[%lu][%lu] contains a heterogeneous block which is " "Tile[%lu][%lu] contains a heterogeneous block which is "
@ -146,7 +149,7 @@ int build_fabric_tile(FabricTile& fabric_tile, const TileConfig& tile_config,
/* Depending on the selected style, follow different approaches */ /* Depending on the selected style, follow different approaches */
if (tile_config.style() == TileConfig::e_style::TOP_LEFT) { if (tile_config.style() == TileConfig::e_style::TOP_LEFT) {
status_code = build_fabric_tile_style_top_left(fabric_tile, grids, status_code = build_fabric_tile_style_top_left(fabric_tile, grids, 0,
device_rr_gsb, verbose); device_rr_gsb, verbose);
} else { } else {
/* Error out for styles that are not supported yet! */ /* Error out for styles that are not supported yet! */

12
openfpga/src/fabric/build_routing_module_utils.cpp
View File

@ -76,8 +76,10 @@ std::string generate_sb_module_grid_port_name(
/* Collect the attributes of the rr_node required to generate the port name */ /* Collect the attributes of the rr_node required to generate the port name */
int pin_id = rr_graph.node_pin_num(rr_node); int pin_id = rr_graph.node_pin_num(rr_node);
e_side pin_side = get_rr_graph_single_node_side(rr_graph, rr_node); e_side pin_side = get_rr_graph_single_node_side(rr_graph, rr_node);
t_physical_tile_type_ptr physical_tile = vpr_device_grid.get_physical_type( t_physical_tile_type_ptr physical_tile =
rr_graph.node_xlow(rr_node), rr_graph.node_ylow(rr_node)); vpr_device_grid.get_physical_type(t_physical_tile_loc(
rr_graph.node_xlow(rr_node), rr_graph.node_ylow(rr_node),
rr_graph.node_layer(rr_node)));
int pin_width_offset = physical_tile->pin_width_offset[pin_id]; int pin_width_offset = physical_tile->pin_width_offset[pin_id];
int pin_height_offset = physical_tile->pin_height_offset[pin_id]; int pin_height_offset = physical_tile->pin_height_offset[pin_id];
BasicPort pin_info = BasicPort pin_info =
@ -110,8 +112,10 @@ std::string generate_cb_module_grid_port_name(
/* Collect the attributes of the rr_node required to generate the port name */ /* Collect the attributes of the rr_node required to generate the port name */
int pin_id = rr_graph.node_pin_num(rr_node); int pin_id = rr_graph.node_pin_num(rr_node);
e_side pin_side = get_rr_graph_single_node_side(rr_graph, rr_node); e_side pin_side = get_rr_graph_single_node_side(rr_graph, rr_node);
t_physical_tile_type_ptr physical_tile = vpr_device_grid.get_physical_type( t_physical_tile_type_ptr physical_tile =
rr_graph.node_xlow(rr_node), rr_graph.node_ylow(rr_node)); vpr_device_grid.get_physical_type(t_physical_tile_loc(
rr_graph.node_xlow(rr_node), rr_graph.node_ylow(rr_node),
rr_graph.node_layer(rr_node)));
int pin_width_offset = physical_tile->pin_width_offset[pin_id]; int pin_width_offset = physical_tile->pin_width_offset[pin_id];
int pin_height_offset = physical_tile->pin_height_offset[pin_id]; int pin_height_offset = physical_tile->pin_height_offset[pin_id];
BasicPort pin_info = BasicPort pin_info =

66
openfpga/src/fabric/build_tile_modules.cpp
View File

@ -60,7 +60,8 @@ namespace openfpga {
*******************************************************************/ *******************************************************************/
static int build_tile_module_port_and_nets_between_sb_and_pb( static int build_tile_module_port_and_nets_between_sb_and_pb(
ModuleManager& module_manager, const ModuleId& tile_module, ModuleManager& module_manager, const ModuleId& tile_module,
const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const size_t& layer,
const VprDeviceAnnotation& vpr_device_annotation,
const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph,
const RRGSB& rr_gsb, const FabricTile& fabric_tile, const RRGSB& rr_gsb, const FabricTile& fabric_tile,
const FabricTileId& fabric_tile_id, const std::vector<size_t>& pb_instances, const FabricTileId& fabric_tile_id, const std::vector<size_t>& pb_instances,
@ -124,8 +125,8 @@ static int build_tile_module_port_and_nets_between_sb_and_pb(
size_t src_grid_pin_index = rr_graph.node_pin_num( size_t src_grid_pin_index = rr_graph.node_pin_num(
rr_gsb.get_opin_node(side_manager.get_side(), inode)); rr_gsb.get_opin_node(side_manager.get_side(), inode));
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
size_t src_grid_pin_width = size_t src_grid_pin_width =
grid_type_descriptor->pin_width_offset[src_grid_pin_index]; grid_type_descriptor->pin_width_offset[src_grid_pin_index];
size_t src_grid_pin_height = size_t src_grid_pin_height =
@ -287,7 +288,8 @@ static int build_tile_module_port_and_nets_between_sb_and_pb(
*******************************************************************/ *******************************************************************/
static int build_tile_module_port_and_nets_between_cb_and_pb( static int build_tile_module_port_and_nets_between_cb_and_pb(
ModuleManager& module_manager, const ModuleId& tile_module, ModuleManager& module_manager, const ModuleId& tile_module,
const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const size_t& layer,
const VprDeviceAnnotation& vpr_device_annotation,
const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph,
const RRGSB& rr_gsb, const FabricTile& fabric_tile, const RRGSB& rr_gsb, const FabricTile& fabric_tile,
const FabricTileId& fabric_tile_id, const t_rr_type& cb_type, const FabricTileId& fabric_tile_id, const t_rr_type& cb_type,
@ -371,8 +373,8 @@ static int build_tile_module_port_and_nets_between_cb_and_pb(
VTR_ASSERT(true == module_manager.valid_module_id(sink_grid_module)); VTR_ASSERT(true == module_manager.valid_module_id(sink_grid_module));
size_t sink_grid_pin_index = rr_graph.node_pin_num(instance_ipin_node); size_t sink_grid_pin_index = rr_graph.node_pin_num(instance_ipin_node);
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
size_t sink_grid_pin_width = size_t sink_grid_pin_width =
grid_type_descriptor->pin_width_offset[sink_grid_pin_index]; grid_type_descriptor->pin_width_offset[sink_grid_pin_index];
size_t sink_grid_pin_height = size_t sink_grid_pin_height =
@ -991,14 +993,14 @@ static int build_tile_module_ports_from_cb(
********************************************************************/ ********************************************************************/
static int build_tile_port_and_nets_from_pb( static int build_tile_port_and_nets_from_pb(
ModuleManager& module_manager, const ModuleId& tile_module, ModuleManager& module_manager, const ModuleId& tile_module,
const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const size_t& layer,
const RRGraphView& rr_graph, const vtr::Point<size_t>& pb_coord, const VprDeviceAnnotation& vpr_device_annotation, const RRGraphView& rr_graph,
const std::vector<size_t>& pb_instances, const FabricTile& fabric_tile, const vtr::Point<size_t>& pb_coord, const std::vector<size_t>& pb_instances,
const FabricTileId& curr_fabric_tile_id, const size_t& ipb, const FabricTile& fabric_tile, const FabricTileId& curr_fabric_tile_id,
const bool& frame_view, const bool& verbose) { const size_t& ipb, const bool& frame_view, const bool& verbose) {
size_t pb_instance = pb_instances[ipb]; size_t pb_instance = pb_instances[ipb];
t_physical_tile_type_ptr phy_tile = t_physical_tile_type_ptr phy_tile = grids.get_physical_type(
grids.get_physical_type(pb_coord.x(), pb_coord.y()); t_physical_tile_loc(pb_coord.x(), pb_coord.y(), layer));
/* Empty type does not require a module */ /* Empty type does not require a module */
if (is_empty_type(phy_tile)) { if (is_empty_type(phy_tile)) {
return CMD_EXEC_SUCCESS; return CMD_EXEC_SUCCESS;
@ -1120,8 +1122,8 @@ static int build_tile_port_and_nets_from_pb(
size_t num_fanout_in_tile = size_t num_fanout_in_tile =
module_manager.module_net_sinks(tile_module, curr_net).size(); module_manager.module_net_sinks(tile_module, curr_net).size();
RRNodeId rr_node = rr_graph.node_lookup().find_node( RRNodeId rr_node = rr_graph.node_lookup().find_node(
pb_coord.x() + iwidth, pb_coord.y() + iheight, OPIN, ipin, layer, pb_coord.x() + iwidth, pb_coord.y() + iheight, OPIN,
side); ipin, side);
size_t num_fanout_required = size_t num_fanout_required =
rr_graph.node_out_edges(rr_node).size(); rr_graph.node_out_edges(rr_node).size();
if (num_fanout_in_tile == num_fanout_required) { if (num_fanout_in_tile == num_fanout_required) {
@ -1179,7 +1181,8 @@ static int build_tile_port_and_nets_from_pb(
*******************************************************************/ *******************************************************************/
static int build_tile_module_ports_and_nets( static int build_tile_module_ports_and_nets(
ModuleManager& module_manager, const ModuleId& tile_module, ModuleManager& module_manager, const ModuleId& tile_module,
const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const size_t& layer,
const VprDeviceAnnotation& vpr_device_annotation,
const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph_view, const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph_view,
const FabricTile& fabric_tile, const FabricTileId& fabric_tile_id, const FabricTile& fabric_tile, const FabricTileId& fabric_tile_id,
const std::vector<size_t>& pb_instances, const std::vector<size_t>& pb_instances,
@ -1196,9 +1199,9 @@ static int build_tile_module_ports_and_nets(
fabric_tile.sb_coordinates(fabric_tile_id)[isb]; fabric_tile.sb_coordinates(fabric_tile_id)[isb];
const RRGSB& rr_gsb = device_rr_gsb.get_gsb(sb_coord); const RRGSB& rr_gsb = device_rr_gsb.get_gsb(sb_coord);
status_code = build_tile_module_port_and_nets_between_sb_and_pb( status_code = build_tile_module_port_and_nets_between_sb_and_pb(
module_manager, tile_module, grids, vpr_device_annotation, device_rr_gsb, module_manager, tile_module, grids, layer, vpr_device_annotation,
rr_graph_view, rr_gsb, fabric_tile, fabric_tile_id, pb_instances, device_rr_gsb, rr_graph_view, rr_gsb, fabric_tile, fabric_tile_id,
sb_instances, isb, true, frame_view, verbose); pb_instances, sb_instances, isb, true, frame_view, verbose);
if (status_code != CMD_EXEC_SUCCESS) { if (status_code != CMD_EXEC_SUCCESS) {
return CMD_EXEC_FATAL_ERROR; return CMD_EXEC_FATAL_ERROR;
} }
@ -1213,7 +1216,7 @@ static int build_tile_module_ports_and_nets(
fabric_tile.cb_coordinates(fabric_tile_id, cb_type)[icb]; fabric_tile.cb_coordinates(fabric_tile_id, cb_type)[icb];
const RRGSB& rr_gsb = device_rr_gsb.get_gsb(cb_coord); const RRGSB& rr_gsb = device_rr_gsb.get_gsb(cb_coord);
status_code = build_tile_module_port_and_nets_between_cb_and_pb( status_code = build_tile_module_port_and_nets_between_cb_and_pb(
module_manager, tile_module, grids, vpr_device_annotation, module_manager, tile_module, grids, layer, vpr_device_annotation,
device_rr_gsb, rr_graph_view, rr_gsb, fabric_tile, fabric_tile_id, device_rr_gsb, rr_graph_view, rr_gsb, fabric_tile, fabric_tile_id,
cb_type, pb_instances, cb_instances, icb, true, frame_view, verbose); cb_type, pb_instances, cb_instances, icb, true, frame_view, verbose);
if (status_code != CMD_EXEC_SUCCESS) { if (status_code != CMD_EXEC_SUCCESS) {
@ -1244,9 +1247,9 @@ static int build_tile_module_ports_and_nets(
vtr::Point<size_t> pb_coord = vtr::Point<size_t> pb_coord =
fabric_tile.pb_coordinates(fabric_tile_id)[ipb]; fabric_tile.pb_coordinates(fabric_tile_id)[ipb];
status_code = build_tile_port_and_nets_from_pb( status_code = build_tile_port_and_nets_from_pb(
module_manager, tile_module, grids, vpr_device_annotation, rr_graph_view, module_manager, tile_module, grids, layer, vpr_device_annotation,
pb_coord, pb_instances, fabric_tile, fabric_tile_id, ipb, frame_view, rr_graph_view, pb_coord, pb_instances, fabric_tile, fabric_tile_id, ipb,
verbose); frame_view, verbose);
if (status_code != CMD_EXEC_SUCCESS) { if (status_code != CMD_EXEC_SUCCESS) {
return CMD_EXEC_FATAL_ERROR; return CMD_EXEC_FATAL_ERROR;
} }
@ -1285,7 +1288,8 @@ static int build_tile_module_ports_and_nets(
static int build_tile_module( static int build_tile_module(
ModuleManager& module_manager, DecoderLibrary& decoder_lib, ModuleManager& module_manager, DecoderLibrary& decoder_lib,
const FabricTile& fabric_tile, const FabricTileId& fabric_tile_id, const FabricTile& fabric_tile, const FabricTileId& fabric_tile_id,
const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const size_t& layer,
const VprDeviceAnnotation& vpr_device_annotation,
const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph_view, const DeviceRRGSB& device_rr_gsb, const RRGraphView& rr_graph_view,
const CircuitLibrary& circuit_lib, const CircuitModelId& sram_model, const CircuitLibrary& circuit_lib, const CircuitModelId& sram_model,
const e_config_protocol_type& sram_orgz_type, const bool& frame_view, const e_config_protocol_type& sram_orgz_type, const bool& frame_view,
@ -1303,8 +1307,8 @@ static int build_tile_module(
pb_instances; /* Keep tracking the instance id of each pb */ pb_instances; /* Keep tracking the instance id of each pb */
for (vtr::Point<size_t> grid_coord : for (vtr::Point<size_t> grid_coord :
fabric_tile.pb_coordinates(fabric_tile_id)) { fabric_tile.pb_coordinates(fabric_tile_id)) {
t_physical_tile_type_ptr phy_tile = t_physical_tile_type_ptr phy_tile = grids.get_physical_type(
grids.get_physical_type(grid_coord.x(), grid_coord.y()); t_physical_tile_loc(grid_coord.x(), grid_coord.y(), layer));
VTR_LOGV(verbose, "Try to find pb at [%lu][%lu]\n", grid_coord.x(), VTR_LOGV(verbose, "Try to find pb at [%lu][%lu]\n", grid_coord.x(),
grid_coord.y()); grid_coord.y());
/* Empty type does not require a module */ /* Empty type does not require a module */
@ -1433,9 +1437,9 @@ static int build_tile_module(
/* Add module nets and ports */ /* Add module nets and ports */
status_code = build_tile_module_ports_and_nets( status_code = build_tile_module_ports_and_nets(
module_manager, tile_module, grids, vpr_device_annotation, device_rr_gsb, module_manager, tile_module, grids, layer, vpr_device_annotation,
rr_graph_view, fabric_tile, fabric_tile_id, pb_instances, cb_instances, device_rr_gsb, rr_graph_view, fabric_tile, fabric_tile_id, pb_instances,
sb_instances, frame_view, verbose); cb_instances, sb_instances, frame_view, verbose);
/* Add global ports to the pb_module: /* Add global ports to the pb_module:
* This is a much easier job after adding sub modules (instances), * This is a much easier job after adding sub modules (instances),
@ -1512,10 +1516,12 @@ int build_tile_modules(ModuleManager& module_manager,
int status_code = CMD_EXEC_SUCCESS; int status_code = CMD_EXEC_SUCCESS;
size_t layer = 0;
/* Build a module for each unique tile */ /* Build a module for each unique tile */
for (FabricTileId fabric_tile_id : fabric_tile.unique_tiles()) { for (FabricTileId fabric_tile_id : fabric_tile.unique_tiles()) {
status_code = build_tile_module( status_code = build_tile_module(
module_manager, decoder_lib, fabric_tile, fabric_tile_id, grids, module_manager, decoder_lib, fabric_tile, fabric_tile_id, grids, layer,
vpr_device_annotation, device_rr_gsb, rr_graph_view, circuit_lib, vpr_device_annotation, device_rr_gsb, rr_graph_view, circuit_lib,
sram_model, sram_orgz_type, frame_view, verbose); sram_model, sram_orgz_type, frame_view, verbose);
if (status_code != CMD_EXEC_SUCCESS) { if (status_code != CMD_EXEC_SUCCESS) {

17
openfpga/src/fabric/build_top_module.cpp
View File

@ -71,20 +71,23 @@ int build_top_module(
/* Label module usage */ /* Label module usage */
module_manager.set_module_usage(top_module, ModuleManager::MODULE_TOP); module_manager.set_module_usage(top_module, ModuleManager::MODULE_TOP);
size_t layer = 0;
if (fabric_tile.empty()) { if (fabric_tile.empty()) {
status = build_top_module_fine_grained_child_instances( status = build_top_module_fine_grained_child_instances(
module_manager, top_module, blwl_sr_banks, circuit_lib, clk_ntwk, module_manager, top_module, blwl_sr_banks, circuit_lib, clk_ntwk,
rr_clock_lookup, vpr_device_annotation, grids, tile_annotation, rr_graph, rr_clock_lookup, vpr_device_annotation, grids, layer, tile_annotation,
device_rr_gsb, tile_direct, arch_direct, config_protocol, sram_model, rr_graph, device_rr_gsb, tile_direct, arch_direct, config_protocol,
frame_view, compact_routing_hierarchy, duplicate_grid_pin, fabric_key, sram_model, frame_view, compact_routing_hierarchy, duplicate_grid_pin,
group_config_block); fabric_key, group_config_block);
} else { } else {
/* TODO: Build the tile instances under the top module */ /* TODO: Build the tile instances under the top module */
status = build_top_module_tile_child_instances( status = build_top_module_tile_child_instances(
module_manager, top_module, blwl_sr_banks, circuit_lib, clk_ntwk, module_manager, top_module, blwl_sr_banks, circuit_lib, clk_ntwk,
rr_clock_lookup, vpr_device_annotation, grids, tile_annotation, rr_graph, rr_clock_lookup, vpr_device_annotation, grids, layer, tile_annotation,
device_rr_gsb, tile_direct, arch_direct, fabric_tile, config_protocol, rr_graph, device_rr_gsb, tile_direct, arch_direct, fabric_tile,
sram_model, fabric_key, group_config_block, frame_view, verbose); config_protocol, sram_model, fabric_key, group_config_block, frame_view,
verbose);
} }
if (status != CMD_EXEC_SUCCESS) { if (status != CMD_EXEC_SUCCESS) {

75
openfpga/src/fabric/build_top_module_child_fine_grained_instance.cpp
View File

@ -95,7 +95,7 @@ static size_t add_top_module_grid_instance(
*******************************************************************/ *******************************************************************/
static vtr::Matrix<size_t> add_top_module_grid_instances( static vtr::Matrix<size_t> add_top_module_grid_instances(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const DeviceGrid& grids) { const DeviceGrid& grids, const size_t& layer) {
vtr::ScopedStartFinishTimer timer("Add grid instances to top module"); vtr::ScopedStartFinishTimer timer("Add grid instances to top module");
/* Reserve an array for the instance ids */ /* Reserve an array for the instance ids */
@ -109,23 +109,23 @@ static vtr::Matrix<size_t> add_top_module_grid_instances(
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) {
t_physical_tile_loc phy_tile_loc(io_coordinate.x(), io_coordinate.y(),
layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(io_coordinate.x(), io_coordinate.y()); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width, height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width, height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(io_coordinate.x(), io_coordinate.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(io_coordinate.x(), io_coordinate.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
/* Find the root of this grid, the instance id should be valid. /* Find the root of this grid, the instance id should be valid.
* We just copy it here * We just copy it here
*/ */
vtr::Point<size_t> root_grid_coord( vtr::Point<size_t> root_grid_coord(
io_coordinate.x() - io_coordinate.x() - grids.get_width_offset(phy_tile_loc),
grids.get_width_offset(io_coordinate.x(), io_coordinate.y()), io_coordinate.y() - grids.get_height_offset(phy_tile_loc));
io_coordinate.y() -
grids.get_height_offset(io_coordinate.x(), io_coordinate.y()));
VTR_ASSERT(size_t(-1) != VTR_ASSERT(size_t(-1) !=
grid_instance_ids[root_grid_coord.x()][root_grid_coord.y()]); grid_instance_ids[root_grid_coord.x()][root_grid_coord.y()]);
grid_instance_ids[io_coordinate.x()][io_coordinate.y()] = grid_instance_ids[io_coordinate.x()][io_coordinate.y()] =
@ -148,20 +148,22 @@ static vtr::Matrix<size_t> add_top_module_grid_instances(
*/ */
for (size_t ix = 1; ix < grids.width() - 1; ++ix) { for (size_t ix = 1; ix < grids.width() - 1; ++ix) {
for (size_t iy = 1; iy < grids.height() - 1; ++iy) { for (size_t iy = 1; iy < grids.height() - 1; ++iy) {
t_physical_tile_type_ptr phy_tile_type = grids.get_physical_type(ix, iy); t_physical_tile_loc phy_tile_loc(ix, iy, layer);
t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(ix, iy)) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(ix, iy))) { (0 < grids.get_height_offset(phy_tile_loc))) {
/* Find the root of this grid, the instance id should be valid. /* Find the root of this grid, the instance id should be valid.
* We just copy it here * We just copy it here
*/ */
vtr::Point<size_t> root_grid_coord( vtr::Point<size_t> root_grid_coord(
ix - grids.get_width_offset(ix, iy), ix - grids.get_width_offset(phy_tile_loc),
iy - grids.get_height_offset(ix, iy)); iy - grids.get_height_offset(phy_tile_loc));
VTR_ASSERT(size_t(-1) != VTR_ASSERT(size_t(-1) !=
grid_instance_ids[root_grid_coord.x()][root_grid_coord.y()]); grid_instance_ids[root_grid_coord.x()][root_grid_coord.y()]);
grid_instance_ids[ix][iy] = grid_instance_ids[ix][iy] =
@ -319,22 +321,24 @@ static vtr::Matrix<size_t> add_top_module_connection_block_instances(
*******************************************************************/ *******************************************************************/
static void add_top_module_io_children( static void add_top_module_io_children(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const DeviceGrid& grids, const vtr::Matrix<size_t>& grid_instance_ids) { const DeviceGrid& grids, const size_t& layer,
const vtr::Matrix<size_t>& grid_instance_ids) {
/* Create the coordinate range for the perimeter I/Os of FPGA fabric */ /* Create the coordinate range for the perimeter I/Os of FPGA fabric */
std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates = std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates =
generate_perimeter_grid_coordinates(grids); generate_perimeter_grid_coordinates(grids);
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coord : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coord : io_coordinates[io_side]) {
t_physical_tile_loc phy_tile_loc(io_coord.x(), io_coord.y(), layer);
t_physical_tile_type_ptr grid_type = t_physical_tile_type_ptr grid_type =
grids.get_physical_type(io_coord.x(), io_coord.y()); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(grid_type)) { if (true == is_empty_type(grid_type)) {
continue; continue;
} }
/* Skip width, height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width, height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(io_coord.x(), io_coord.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(io_coord.x(), io_coord.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
/* Find the module name for this type of grid */ /* Find the module name for this type of grid */
@ -395,15 +399,15 @@ static void add_top_module_io_children(
/* Now walk through the coordinates */ /* Now walk through the coordinates */
for (vtr::Point<size_t> coord : coords) { for (vtr::Point<size_t> coord : coords) {
t_physical_tile_type_ptr grid_type = t_physical_tile_loc phy_tile_loc(coord.x(), coord.y(), layer);
grids.get_physical_type(coord.x(), coord.y()); t_physical_tile_type_ptr grid_type = grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(grid_type)) { if (true == is_empty_type(grid_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(coord.x(), coord.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(coord.x(), coord.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
/* Find the module name for this type of grid */ /* Find the module name for this type of grid */
@ -431,19 +435,20 @@ int build_top_module_fine_grained_child_instances(
const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk, const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup, const RRClockSpatialLookup& rr_clock_lookup,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const TileAnnotation& tile_annotation, const RRGraphView& rr_graph, const size_t& layer, const TileAnnotation& tile_annotation,
const DeviceRRGSB& device_rr_gsb, const TileDirect& tile_direct, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const ArchDirect& arch_direct, const ConfigProtocol& config_protocol, const TileDirect& tile_direct, const ArchDirect& arch_direct,
const CircuitModelId& sram_model, const bool& frame_view, const ConfigProtocol& config_protocol, const CircuitModelId& sram_model,
const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin, const bool& frame_view, const bool& compact_routing_hierarchy,
const FabricKey& fabric_key, const bool& group_config_block) { const bool& duplicate_grid_pin, const FabricKey& fabric_key,
const bool& group_config_block) {
int status = CMD_EXEC_SUCCESS; int status = CMD_EXEC_SUCCESS;
std::map<t_rr_type, vtr::Matrix<size_t>> cb_instance_ids; std::map<t_rr_type, vtr::Matrix<size_t>> cb_instance_ids;
/* Add sub modules, which are grid, SB and CBX/CBY modules as instances */ /* Add sub modules, which are grid, SB and CBX/CBY modules as instances */
/* Add all the grids across the fabric */ /* Add all the grids across the fabric */
vtr::Matrix<size_t> grid_instance_ids = vtr::Matrix<size_t> grid_instance_ids =
add_top_module_grid_instances(module_manager, top_module, grids); add_top_module_grid_instances(module_manager, top_module, grids, layer);
/* Add all the SBs across the fabric */ /* Add all the SBs across the fabric */
vtr::Matrix<size_t> sb_instance_ids = add_top_module_switch_block_instances( vtr::Matrix<size_t> sb_instance_ids = add_top_module_switch_block_instances(
module_manager, top_module, device_rr_gsb, compact_routing_hierarchy); module_manager, top_module, device_rr_gsb, compact_routing_hierarchy);
@ -456,7 +461,7 @@ int build_top_module_fine_grained_child_instances(
compact_routing_hierarchy); compact_routing_hierarchy);
/* Update I/O children list */ /* Update I/O children list */
add_top_module_io_children(module_manager, top_module, grids, add_top_module_io_children(module_manager, top_module, grids, layer,
grid_instance_ids); grid_instance_ids);
/* Add nets when we need a complete fabric modeling, /* Add nets when we need a complete fabric modeling,
@ -468,21 +473,21 @@ int build_top_module_fine_grained_child_instances(
/* Add module nets to connect the sub modules */ /* Add module nets to connect the sub modules */
add_top_module_nets_connect_grids_and_gsbs( add_top_module_nets_connect_grids_and_gsbs(
module_manager, top_module, vpr_device_annotation, grids, module_manager, top_module, vpr_device_annotation, grids, layer,
grid_instance_ids, rr_graph, device_rr_gsb, sb_instance_ids, grid_instance_ids, rr_graph, device_rr_gsb, sb_instance_ids,
cb_instance_ids, compact_routing_hierarchy, duplicate_grid_pin); cb_instance_ids, compact_routing_hierarchy, duplicate_grid_pin);
/* Add inter-CLB direct connections */ /* Add inter-CLB direct connections */
add_top_module_nets_tile_direct_connections( add_top_module_nets_tile_direct_connections(
module_manager, top_module, circuit_lib, vpr_device_annotation, grids, module_manager, top_module, circuit_lib, vpr_device_annotation, grids,
grid_instance_ids, tile_direct, arch_direct); layer, grid_instance_ids, tile_direct, arch_direct);
} }
/* Add global ports from grid ports that are defined as global in tile /* Add global ports from grid ports that are defined as global in tile
* annotation */ * annotation */
status = add_top_module_global_ports_from_grid_modules( status = add_top_module_global_ports_from_grid_modules(
module_manager, top_module, tile_annotation, vpr_device_annotation, grids, module_manager, top_module, tile_annotation, vpr_device_annotation, grids,
rr_graph, device_rr_gsb, cb_instance_ids, grid_instance_ids, clk_ntwk, layer, rr_graph, device_rr_gsb, cb_instance_ids, grid_instance_ids,
rr_clock_lookup); clk_ntwk, rr_clock_lookup);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
return status; return status;
} }
@ -500,8 +505,8 @@ int build_top_module_fine_grained_child_instances(
if (true == fabric_key.empty()) { if (true == fabric_key.empty()) {
organize_top_module_memory_modules( organize_top_module_memory_modules(
module_manager, top_module, circuit_lib, config_protocol, sram_model, module_manager, top_module, circuit_lib, config_protocol, sram_model,
grids, grid_instance_ids, device_rr_gsb, sb_instance_ids, cb_instance_ids, grids, layer, grid_instance_ids, device_rr_gsb, sb_instance_ids,
compact_routing_hierarchy); cb_instance_ids, compact_routing_hierarchy);
} else { } else {
VTR_ASSERT_SAFE(false == fabric_key.empty()); VTR_ASSERT_SAFE(false == fabric_key.empty());
/* Throw a fatal error when the fabric key has a mismatch in region /* Throw a fatal error when the fabric key has a mismatch in region

13
openfpga/src/fabric/build_top_module_child_fine_grained_instance.h
View File

@ -38,12 +38,13 @@ int build_top_module_fine_grained_child_instances(
const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk, const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup, const RRClockSpatialLookup& rr_clock_lookup,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const TileAnnotation& tile_annotation, const RRGraphView& rr_graph, const size_t& layer, const TileAnnotation& tile_annotation,
const DeviceRRGSB& device_rr_gsb, const TileDirect& tile_direct, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const ArchDirect& arch_direct, const ConfigProtocol& config_protocol, const TileDirect& tile_direct, const ArchDirect& arch_direct,
const CircuitModelId& sram_model, const bool& frame_view, const ConfigProtocol& config_protocol, const CircuitModelId& sram_model,
const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin, const bool& frame_view, const bool& compact_routing_hierarchy,
const FabricKey& fabric_key, const bool& group_config_block); const bool& duplicate_grid_pin, const FabricKey& fabric_key,
const bool& group_config_block);
} /* end namespace openfpga */ } /* end namespace openfpga */

76
openfpga/src/fabric/build_top_module_child_tile_instance.cpp
View File

@ -1272,8 +1272,9 @@ static int build_top_module_global_net_for_given_tile_module(
const TileGlobalPortId& tile_global_port, const TileGlobalPortId& tile_global_port,
const BasicPort& tile_port_to_connect, const BasicPort& tile_port_to_connect,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Point<size_t>& grid_coordinate, const e_side& border_side, const size_t& layer, const vtr::Point<size_t>& grid_coordinate,
const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile) { const e_side& border_side, const vtr::Matrix<size_t>& tile_instance_ids,
const FabricTile& fabric_tile) {
/* Get the tile module and instance */ /* Get the tile module and instance */
FabricTileId curr_fabric_tile_id = FabricTileId curr_fabric_tile_id =
fabric_tile.find_tile_by_pb_coordinate(grid_coordinate); fabric_tile.find_tile_by_pb_coordinate(grid_coordinate);
@ -1297,8 +1298,8 @@ static int build_top_module_global_net_for_given_tile_module(
fabric_tile.pb_coordinates( fabric_tile.pb_coordinates(
unique_fabric_tile_id)[pb_idx_in_curr_fabric_tile]; unique_fabric_tile_id)[pb_idx_in_curr_fabric_tile];
t_physical_tile_type_ptr physical_tile = t_physical_tile_type_ptr physical_tile = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
/* Find the module name for this type of grid */ /* Find the module name for this type of grid */
std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX);
std::string grid_instance_name = std::string grid_instance_name =
@ -1419,7 +1420,8 @@ static int build_top_module_global_net_from_tile_modules(
const ModulePortId& top_module_port, const TileAnnotation& tile_annotation, const ModulePortId& top_module_port, const TileAnnotation& tile_annotation,
const TileGlobalPortId& tile_global_port, const TileGlobalPortId& tile_global_port,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile) { const size_t& layer, const vtr::Matrix<size_t>& tile_instance_ids,
const FabricTile& fabric_tile) {
int status = CMD_EXEC_SUCCESS; int status = CMD_EXEC_SUCCESS;
std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates = std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates =
@ -1475,15 +1477,16 @@ static int build_top_module_global_net_from_tile_modules(
/* Spot the port from child modules from core grids */ /* Spot the port from child modules from core grids */
for (size_t ix = start_coord.x(); ix < end_coord.x(); ++ix) { for (size_t ix = start_coord.x(); ix < end_coord.x(); ++ix) {
for (size_t iy = start_coord.y(); iy < end_coord.y(); ++iy) { for (size_t iy = start_coord.y(); iy < end_coord.y(); ++iy) {
t_physical_tile_loc phy_tile_loc(ix, iy, layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(ix, iy); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY tiles */ /* Bypass EMPTY tiles */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(ix, iy)) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(ix, iy))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
@ -1495,7 +1498,7 @@ static int build_top_module_global_net_from_tile_modules(
/* Create nets and finish connection build-up */ /* Create nets and finish connection build-up */
status = build_top_module_global_net_for_given_tile_module( status = build_top_module_global_net_for_given_tile_module(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, tile_port, vpr_device_annotation, grids, tile_global_port, tile_port, vpr_device_annotation, grids, layer,
vtr::Point<size_t>(ix, iy), NUM_SIDES, tile_instance_ids, vtr::Point<size_t>(ix, iy), NUM_SIDES, tile_instance_ids,
fabric_tile); fabric_tile);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
@ -1507,18 +1510,18 @@ static int build_top_module_global_net_from_tile_modules(
/* Walk through all the grids on the perimeter, which are I/O grids */ /* Walk through all the grids on the perimeter, which are I/O grids */
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) {
t_physical_tile_loc phy_tile_loc(io_coordinate.x(), io_coordinate.y(),
layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(io_coordinate.x(), io_coordinate.y()); grids.get_physical_type(phy_tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < if ((0 < grids.get_width_offset(phy_tile_loc)) ||
grids.get_width_offset(io_coordinate.x(), io_coordinate.y())) || (0 < grids.get_height_offset(phy_tile_loc))) {
(0 <
grids.get_height_offset(io_coordinate.x(), io_coordinate.y()))) {
continue; continue;
} }
@ -1543,7 +1546,7 @@ static int build_top_module_global_net_from_tile_modules(
/* Create nets and finish connection build-up */ /* Create nets and finish connection build-up */
status = build_top_module_global_net_for_given_tile_module( status = build_top_module_global_net_for_given_tile_module(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, tile_port, vpr_device_annotation, grids, tile_global_port, tile_port, vpr_device_annotation, grids, layer,
io_coordinate, io_side, tile_instance_ids, fabric_tile); io_coordinate, io_side, tile_instance_ids, fabric_tile);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
return status; return status;
@ -1563,7 +1566,8 @@ static int add_top_module_global_ports_from_tile_modules(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const TileAnnotation& tile_annotation, const TileAnnotation& tile_annotation,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb, const size_t& layer, const RRGraphView& rr_graph,
const DeviceRRGSB& device_rr_gsb,
const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile, const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile,
const ClockNetwork& clk_ntwk, const RRClockSpatialLookup& rr_clock_lookup) { const ClockNetwork& clk_ntwk, const RRClockSpatialLookup& rr_clock_lookup) {
int status = CMD_EXEC_SUCCESS; int status = CMD_EXEC_SUCCESS;
@ -1621,8 +1625,8 @@ static int add_top_module_global_ports_from_tile_modules(
} else { } else {
status = build_top_module_global_net_from_tile_modules( status = build_top_module_global_net_from_tile_modules(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, vpr_device_annotation, grids, tile_instance_ids, tile_global_port, vpr_device_annotation, grids, layer,
fabric_tile); tile_instance_ids, fabric_tile);
} }
if (status == CMD_EXEC_FATAL_ERROR) { if (status == CMD_EXEC_FATAL_ERROR) {
return status; return status;
@ -1647,9 +1651,9 @@ static void add_module_nets_connect_tile_direct_connection(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const CircuitLibrary& circuit_lib,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile, const size_t& layer, const vtr::Matrix<size_t>& tile_instance_ids,
const TileDirect& tile_direct, const TileDirectId& tile_direct_id, const FabricTile& fabric_tile, const TileDirect& tile_direct,
const ArchDirect& arch_direct) { const TileDirectId& tile_direct_id, const ArchDirect& arch_direct) {
vtr::Point<size_t> device_size(grids.width(), grids.height()); vtr::Point<size_t> device_size(grids.width(), grids.height());
std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX);
@ -1739,8 +1743,9 @@ static void add_module_nets_connect_tile_direct_connection(
e_side src_pin_grid_side = tile_direct.from_tile_side(tile_direct_id); e_side src_pin_grid_side = tile_direct.from_tile_side(tile_direct_id);
size_t src_tile_pin = tile_direct.from_tile_pin(tile_direct_id); size_t src_tile_pin = tile_direct.from_tile_pin(tile_direct_id);
t_physical_tile_loc src_tile_loc(src_clb_coord.x(), src_clb_coord.y(), layer);
t_physical_tile_type_ptr src_grid_type_descriptor = t_physical_tile_type_ptr src_grid_type_descriptor =
grids.get_physical_type(src_clb_coord.x(), src_clb_coord.y()); grids.get_physical_type(src_tile_loc);
size_t src_pin_width = size_t src_pin_width =
src_grid_type_descriptor->pin_width_offset[src_tile_pin]; src_grid_type_descriptor->pin_width_offset[src_tile_pin];
size_t src_pin_height = size_t src_pin_height =
@ -1775,8 +1780,9 @@ static void add_module_nets_connect_tile_direct_connection(
e_side sink_pin_grid_side = tile_direct.to_tile_side(tile_direct_id); e_side sink_pin_grid_side = tile_direct.to_tile_side(tile_direct_id);
size_t sink_tile_pin = tile_direct.to_tile_pin(tile_direct_id); size_t sink_tile_pin = tile_direct.to_tile_pin(tile_direct_id);
t_physical_tile_loc des_tile_loc(des_clb_coord.x(), des_clb_coord.y(), layer);
t_physical_tile_type_ptr sink_grid_type_descriptor = t_physical_tile_type_ptr sink_grid_type_descriptor =
grids.get_physical_type(des_clb_coord.x(), des_clb_coord.y()); grids.get_physical_type(des_tile_loc);
size_t sink_pin_width = size_t sink_pin_width =
sink_grid_type_descriptor->pin_width_offset[src_tile_pin]; sink_grid_type_descriptor->pin_width_offset[src_tile_pin];
size_t sink_pin_height = size_t sink_pin_height =
@ -1838,15 +1844,17 @@ static void add_top_module_nets_connect_tile_direct_connections(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const CircuitLibrary& circuit_lib,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& tile_instance_ids, const FabricTile& fabric_tile, const size_t& layer, const vtr::Matrix<size_t>& tile_instance_ids,
const TileDirect& tile_direct, const ArchDirect& arch_direct) { const FabricTile& fabric_tile, const TileDirect& tile_direct,
const ArchDirect& arch_direct) {
vtr::ScopedStartFinishTimer timer( vtr::ScopedStartFinishTimer timer(
"Add module nets for inter-tile connections"); "Add module nets for inter-tile connections");
for (const TileDirectId& tile_direct_id : tile_direct.directs()) { for (const TileDirectId& tile_direct_id : tile_direct.directs()) {
add_module_nets_connect_tile_direct_connection( add_module_nets_connect_tile_direct_connection(
module_manager, top_module, circuit_lib, vpr_device_annotation, grids, module_manager, top_module, circuit_lib, vpr_device_annotation, grids,
tile_instance_ids, fabric_tile, tile_direct, tile_direct_id, arch_direct); layer, tile_instance_ids, fabric_tile, tile_direct, tile_direct_id,
arch_direct);
} }
} }
@ -1860,12 +1868,12 @@ int build_top_module_tile_child_instances(
const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk, const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup, const RRClockSpatialLookup& rr_clock_lookup,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const TileAnnotation& tile_annotation, const RRGraphView& rr_graph, const size_t& layer, const TileAnnotation& tile_annotation,
const DeviceRRGSB& device_rr_gsb, const TileDirect& tile_direct, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const ArchDirect& arch_direct, const FabricTile& fabric_tile, const TileDirect& tile_direct, const ArchDirect& arch_direct,
const ConfigProtocol& config_protocol, const CircuitModelId& sram_model, const FabricTile& fabric_tile, const ConfigProtocol& config_protocol,
const FabricKey& fabric_key, const bool& group_config_block, const CircuitModelId& sram_model, const FabricKey& fabric_key,
const bool& frame_view, const bool& verbose) { const bool& group_config_block, const bool& frame_view, const bool& verbose) {
int status = CMD_EXEC_SUCCESS; int status = CMD_EXEC_SUCCESS;
vtr::Matrix<size_t> tile_instance_ids; vtr::Matrix<size_t> tile_instance_ids;
status = add_top_module_tile_instances(module_manager, top_module, status = add_top_module_tile_instances(module_manager, top_module,
@ -1892,7 +1900,7 @@ int build_top_module_tile_child_instances(
/* TODO: Inter-tile direct connections */ /* TODO: Inter-tile direct connections */
add_top_module_nets_connect_tile_direct_connections( add_top_module_nets_connect_tile_direct_connections(
module_manager, top_module, circuit_lib, vpr_device_annotation, grids, module_manager, top_module, circuit_lib, vpr_device_annotation, grids,
tile_instance_ids, fabric_tile, tile_direct, arch_direct); layer, tile_instance_ids, fabric_tile, tile_direct, arch_direct);
} }
/* Add global ports from tile modules: how to connect to clock architecture /* Add global ports from tile modules: how to connect to clock architecture
@ -1900,7 +1908,7 @@ int build_top_module_tile_child_instances(
*/ */
status = add_top_module_global_ports_from_tile_modules( status = add_top_module_global_ports_from_tile_modules(
module_manager, top_module, tile_annotation, vpr_device_annotation, grids, module_manager, top_module, tile_annotation, vpr_device_annotation, grids,
rr_graph, device_rr_gsb, tile_instance_ids, fabric_tile, clk_ntwk, layer, rr_graph, device_rr_gsb, tile_instance_ids, fabric_tile, clk_ntwk,
rr_clock_lookup); rr_clock_lookup);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
return status; return status;

12
openfpga/src/fabric/build_top_module_child_tile_instance.h
View File

@ -38,12 +38,12 @@ int build_top_module_tile_child_instances(
const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk, const CircuitLibrary& circuit_lib, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup, const RRClockSpatialLookup& rr_clock_lookup,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const TileAnnotation& tile_annotation, const RRGraphView& rr_graph, const size_t& layer, const TileAnnotation& tile_annotation,
const DeviceRRGSB& device_rr_gsb, const TileDirect& tile_direct, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const ArchDirect& arch_direct, const FabricTile& fabric_tile, const TileDirect& tile_direct, const ArchDirect& arch_direct,
const ConfigProtocol& config_protocol, const CircuitModelId& sram_model, const FabricTile& fabric_tile, const ConfigProtocol& config_protocol,
const FabricKey& fabric_key, const bool& group_config_block, const CircuitModelId& sram_model, const FabricKey& fabric_key,
const bool& frame_view, const bool& verbose); const bool& group_config_block, const bool& frame_view, const bool& verbose);
} /* end namespace openfpga */ } /* end namespace openfpga */

81
openfpga/src/fabric/build_top_module_connection.cpp
View File

@ -64,9 +64,9 @@ namespace openfpga {
static void add_top_module_nets_connect_grids_and_sb( static void add_top_module_nets_connect_grids_and_sb(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const RRGraphView& rr_graph, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const RRGSB& rr_gsb, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const vtr::Matrix<size_t>& sb_instance_ids, const RRGSB& rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids,
const bool& compact_routing_hierarchy) { const bool& compact_routing_hierarchy) {
/* Skip those Switch blocks that do not exist */ /* Skip those Switch blocks that do not exist */
if (false == rr_gsb.is_sb_exist()) { if (false == rr_gsb.is_sb_exist()) {
@ -126,8 +126,8 @@ static void add_top_module_nets_connect_grids_and_sb(
size_t src_grid_pin_index = rr_graph.node_pin_num( size_t src_grid_pin_index = rr_graph.node_pin_num(
rr_gsb.get_opin_node(side_manager.get_side(), inode)); rr_gsb.get_opin_node(side_manager.get_side(), inode));
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
size_t src_grid_pin_width = size_t src_grid_pin_width =
grid_type_descriptor->pin_width_offset[src_grid_pin_index]; grid_type_descriptor->pin_width_offset[src_grid_pin_index];
size_t src_grid_pin_height = size_t src_grid_pin_height =
@ -227,9 +227,9 @@ static void add_top_module_nets_connect_grids_and_sb(
static void add_top_module_nets_connect_grids_and_sb_with_duplicated_pins( static void add_top_module_nets_connect_grids_and_sb_with_duplicated_pins(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const RRGraphView& rr_graph, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const RRGSB& rr_gsb, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const vtr::Matrix<size_t>& sb_instance_ids, const RRGSB& rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids,
const bool& compact_routing_hierarchy) { const bool& compact_routing_hierarchy) {
/* Skip those Switch blocks that do not exist */ /* Skip those Switch blocks that do not exist */
if (false == rr_gsb.is_sb_exist()) { if (false == rr_gsb.is_sb_exist()) {
@ -300,8 +300,10 @@ static void add_top_module_nets_connect_grids_and_sb_with_duplicated_pins(
size_t src_grid_pin_index = rr_graph.node_pin_num( size_t src_grid_pin_index = rr_graph.node_pin_num(
rr_gsb.get_opin_node(side_manager.get_side(), inode)); rr_gsb.get_opin_node(side_manager.get_side(), inode));
t_physical_tile_loc phy_tile_loc(grid_coordinate.x(), grid_coordinate.y(),
layer);
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor =
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); grids.get_physical_type(phy_tile_loc);
size_t src_grid_pin_width = size_t src_grid_pin_width =
grid_type_descriptor->pin_width_offset[src_grid_pin_index]; grid_type_descriptor->pin_width_offset[src_grid_pin_index];
size_t src_grid_pin_height = size_t src_grid_pin_height =
@ -437,9 +439,10 @@ static void add_top_module_nets_connect_grids_and_sb_with_duplicated_pins(
static void add_top_module_nets_connect_grids_and_cb( static void add_top_module_nets_connect_grids_and_cb(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const RRGraphView& rr_graph, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const RRGSB& rr_gsb, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const t_rr_type& cb_type, const vtr::Matrix<size_t>& cb_instance_ids, const RRGSB& rr_gsb, const t_rr_type& cb_type,
const vtr::Matrix<size_t>& cb_instance_ids,
const bool& compact_routing_hierarchy) { const bool& compact_routing_hierarchy) {
/* We could have two different coordinators, one is the instance, the other is /* We could have two different coordinators, one is the instance, the other is
* the module */ * the module */
@ -519,8 +522,8 @@ static void add_top_module_nets_connect_grids_and_cb(
grid_instance_ids[grid_coordinate.x()][grid_coordinate.y()]; grid_instance_ids[grid_coordinate.x()][grid_coordinate.y()];
size_t sink_grid_pin_index = rr_graph.node_pin_num(instance_ipin_node); size_t sink_grid_pin_index = rr_graph.node_pin_num(instance_ipin_node);
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
size_t sink_grid_pin_width = size_t sink_grid_pin_width =
grid_type_descriptor->pin_width_offset[sink_grid_pin_index]; grid_type_descriptor->pin_width_offset[sink_grid_pin_index];
size_t sink_grid_pin_height = size_t sink_grid_pin_height =
@ -802,8 +805,9 @@ static void add_top_module_nets_connect_sb_and_cb(
void add_top_module_nets_connect_grids_and_gsbs( void add_top_module_nets_connect_grids_and_gsbs(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const RRGraphView& rr_graph, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const vtr::Matrix<size_t>& sb_instance_ids,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin) { const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin) {
vtr::ScopedStartFinishTimer timer("Add module nets between grids and GSBs"); vtr::ScopedStartFinishTimer timer("Add module nets between grids and GSBs");
@ -818,24 +822,24 @@ void add_top_module_nets_connect_grids_and_gsbs(
/* Connect the grid pins of the GSB to adjacent grids */ /* Connect the grid pins of the GSB to adjacent grids */
if (false == duplicate_grid_pin) { if (false == duplicate_grid_pin) {
add_top_module_nets_connect_grids_and_sb( add_top_module_nets_connect_grids_and_sb(
module_manager, top_module, vpr_device_annotation, grids, module_manager, top_module, vpr_device_annotation, grids, layer,
grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, sb_instance_ids, grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, sb_instance_ids,
compact_routing_hierarchy); compact_routing_hierarchy);
} else { } else {
VTR_ASSERT_SAFE(true == duplicate_grid_pin); VTR_ASSERT_SAFE(true == duplicate_grid_pin);
add_top_module_nets_connect_grids_and_sb_with_duplicated_pins( add_top_module_nets_connect_grids_and_sb_with_duplicated_pins(
module_manager, top_module, vpr_device_annotation, grids, module_manager, top_module, vpr_device_annotation, grids, layer,
grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, sb_instance_ids, grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, sb_instance_ids,
compact_routing_hierarchy); compact_routing_hierarchy);
} }
add_top_module_nets_connect_grids_and_cb( add_top_module_nets_connect_grids_and_cb(
module_manager, top_module, vpr_device_annotation, grids, module_manager, top_module, vpr_device_annotation, grids, layer,
grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, CHANX, grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, CHANX,
cb_instance_ids.at(CHANX), compact_routing_hierarchy); cb_instance_ids.at(CHANX), compact_routing_hierarchy);
add_top_module_nets_connect_grids_and_cb( add_top_module_nets_connect_grids_and_cb(
module_manager, top_module, vpr_device_annotation, grids, module_manager, top_module, vpr_device_annotation, grids, layer,
grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, CHANY, grid_instance_ids, rr_graph, device_rr_gsb, rr_gsb, CHANY,
cb_instance_ids.at(CHANY), compact_routing_hierarchy); cb_instance_ids.at(CHANY), compact_routing_hierarchy);
@ -856,10 +860,10 @@ static int build_top_module_global_net_for_given_grid_module(
const TileGlobalPortId& tile_global_port, const TileGlobalPortId& tile_global_port,
const BasicPort& tile_port_to_connect, const BasicPort& tile_port_to_connect,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Point<size_t>& grid_coordinate, const e_side& border_side, const size_t& layer, const vtr::Point<size_t>& grid_coordinate,
const vtr::Matrix<size_t>& grid_instance_ids) { const e_side& border_side, const vtr::Matrix<size_t>& grid_instance_ids) {
t_physical_tile_type_ptr physical_tile = t_physical_tile_type_ptr physical_tile = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), layer));
/* Find the module name for this type of grid */ /* Find the module name for this type of grid */
std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX);
std::string grid_module_name = generate_grid_block_module_name( std::string grid_module_name = generate_grid_block_module_name(
@ -982,7 +986,7 @@ static int build_top_module_global_net_from_grid_modules(
const ModulePortId& top_module_port, const TileAnnotation& tile_annotation, const ModulePortId& top_module_port, const TileAnnotation& tile_annotation,
const TileGlobalPortId& tile_global_port, const TileGlobalPortId& tile_global_port,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids) { const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids) {
int status = CMD_EXEC_SUCCESS; int status = CMD_EXEC_SUCCESS;
std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates = std::map<e_side, std::vector<vtr::Point<size_t>>> io_coordinates =
@ -1038,15 +1042,16 @@ static int build_top_module_global_net_from_grid_modules(
/* Spot the port from child modules from core grids */ /* Spot the port from child modules from core grids */
for (size_t ix = start_coord.x(); ix < end_coord.x(); ++ix) { for (size_t ix = start_coord.x(); ix < end_coord.x(); ++ix) {
for (size_t iy = start_coord.y(); iy < end_coord.y(); ++iy) { for (size_t iy = start_coord.y(); iy < end_coord.y(); ++iy) {
t_physical_tile_loc tile_loc(ix, iy, layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(ix, iy); grids.get_physical_type(tile_loc);
/* Bypass EMPTY tiles */ /* Bypass EMPTY tiles */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(ix, iy)) || if ((0 < grids.get_width_offset(tile_loc)) ||
(0 < grids.get_height_offset(ix, iy))) { (0 < grids.get_height_offset(tile_loc))) {
continue; continue;
} }
@ -1058,7 +1063,7 @@ static int build_top_module_global_net_from_grid_modules(
/* Create nets and finish connection build-up */ /* Create nets and finish connection build-up */
status = build_top_module_global_net_for_given_grid_module( status = build_top_module_global_net_for_given_grid_module(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, tile_port, vpr_device_annotation, grids, tile_global_port, tile_port, vpr_device_annotation, grids, layer,
vtr::Point<size_t>(ix, iy), NUM_SIDES, grid_instance_ids); vtr::Point<size_t>(ix, iy), NUM_SIDES, grid_instance_ids);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
return status; return status;
@ -1069,18 +1074,18 @@ static int build_top_module_global_net_from_grid_modules(
/* Walk through all the grids on the perimeter, which are I/O grids */ /* Walk through all the grids on the perimeter, which are I/O grids */
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) {
t_physical_tile_loc tile_loc(io_coordinate.x(), io_coordinate.y(),
layer);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type =
grids.get_physical_type(io_coordinate.x(), io_coordinate.y()); grids.get_physical_type(tile_loc);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(phy_tile_type)) { if (true == is_empty_type(phy_tile_type)) {
continue; continue;
} }
/* Skip width or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < if ((0 < grids.get_width_offset(tile_loc)) ||
grids.get_width_offset(io_coordinate.x(), io_coordinate.y())) || (0 < grids.get_height_offset(tile_loc))) {
(0 <
grids.get_height_offset(io_coordinate.x(), io_coordinate.y()))) {
continue; continue;
} }
@ -1105,7 +1110,7 @@ static int build_top_module_global_net_from_grid_modules(
/* Create nets and finish connection build-up */ /* Create nets and finish connection build-up */
status = build_top_module_global_net_for_given_grid_module( status = build_top_module_global_net_for_given_grid_module(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, tile_port, vpr_device_annotation, grids, tile_global_port, tile_port, vpr_device_annotation, grids, layer,
io_coordinate, io_side, grid_instance_ids); io_coordinate, io_side, grid_instance_ids);
if (CMD_EXEC_FATAL_ERROR == status) { if (CMD_EXEC_FATAL_ERROR == status) {
return status; return status;
@ -1203,7 +1208,8 @@ int add_top_module_global_ports_from_grid_modules(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const TileAnnotation& tile_annotation, const TileAnnotation& tile_annotation,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb, const size_t& layer, const RRGraphView& rr_graph,
const DeviceRRGSB& device_rr_gsb,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const vtr::Matrix<size_t>& grid_instance_ids, const ClockNetwork& clk_ntwk, const vtr::Matrix<size_t>& grid_instance_ids, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup) { const RRClockSpatialLookup& rr_clock_lookup) {
@ -1262,7 +1268,8 @@ int add_top_module_global_ports_from_grid_modules(
} else { } else {
status = build_top_module_global_net_from_grid_modules( status = build_top_module_global_net_from_grid_modules(
module_manager, top_module, top_module_port, tile_annotation, module_manager, top_module, top_module_port, tile_annotation,
tile_global_port, vpr_device_annotation, grids, grid_instance_ids); tile_global_port, vpr_device_annotation, grids, layer,
grid_instance_ids);
} }
if (status == CMD_EXEC_FATAL_ERROR) { if (status == CMD_EXEC_FATAL_ERROR) {
return status; return status;

8
openfpga/src/fabric/build_top_module_connection.h
View File

@ -28,8 +28,9 @@ namespace openfpga {
void add_top_module_nets_connect_grids_and_gsbs( void add_top_module_nets_connect_grids_and_gsbs(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const RRGraphView& rr_graph, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids, const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb,
const vtr::Matrix<size_t>& sb_instance_ids,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin); const bool& compact_routing_hierarchy, const bool& duplicate_grid_pin);
@ -37,7 +38,8 @@ int add_top_module_global_ports_from_grid_modules(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const TileAnnotation& tile_annotation, const TileAnnotation& tile_annotation,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const RRGraphView& rr_graph, const DeviceRRGSB& device_rr_gsb, const size_t& layer, const RRGraphView& rr_graph,
const DeviceRRGSB& device_rr_gsb,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const vtr::Matrix<size_t>& grid_instance_ids, const ClockNetwork& clk_ntwk, const vtr::Matrix<size_t>& grid_instance_ids, const ClockNetwork& clk_ntwk,
const RRClockSpatialLookup& rr_clock_lookup); const RRClockSpatialLookup& rr_clock_lookup);

22
openfpga/src/fabric/build_top_module_directs.cpp
View File

@ -39,15 +39,17 @@ static void add_module_nets_tile_direct_connection(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const CircuitLibrary& circuit_lib,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const TileDirect& tile_direct, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const TileDirectId& tile_direct_id, const ArchDirect& arch_direct) { const TileDirect& tile_direct, const TileDirectId& tile_direct_id,
const ArchDirect& arch_direct) {
vtr::Point<size_t> device_size(grids.width(), grids.height()); vtr::Point<size_t> device_size(grids.width(), grids.height());
/* Find the module name of source clb */ /* Find the module name of source clb */
vtr::Point<size_t> src_clb_coord = vtr::Point<size_t> src_clb_coord =
tile_direct.from_tile_coordinate(tile_direct_id); tile_direct.from_tile_coordinate(tile_direct_id);
t_physical_tile_loc src_grid_loc(src_clb_coord.x(), src_clb_coord.y(), layer);
t_physical_tile_type_ptr src_grid_type = t_physical_tile_type_ptr src_grid_type =
grids.get_physical_type(src_clb_coord.x(), src_clb_coord.y()); grids.get_physical_type(src_grid_loc);
e_side src_grid_border_side = e_side src_grid_border_side =
find_grid_border_side(device_size, src_clb_coord); find_grid_border_side(device_size, src_clb_coord);
std::string src_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string src_module_name_prefix(GRID_MODULE_NAME_PREFIX);
@ -63,8 +65,10 @@ static void add_module_nets_tile_direct_connection(
/* Find the module name of sink clb */ /* Find the module name of sink clb */
vtr::Point<size_t> des_clb_coord = vtr::Point<size_t> des_clb_coord =
tile_direct.to_tile_coordinate(tile_direct_id); tile_direct.to_tile_coordinate(tile_direct_id);
t_physical_tile_loc sink_grid_loc(des_clb_coord.x(), des_clb_coord.y(),
layer);
t_physical_tile_type_ptr sink_grid_type = t_physical_tile_type_ptr sink_grid_type =
grids.get_physical_type(des_clb_coord.x(), des_clb_coord.y()); grids.get_physical_type(sink_grid_loc);
e_side sink_grid_border_side = e_side sink_grid_border_side =
find_grid_border_side(device_size, des_clb_coord); find_grid_border_side(device_size, des_clb_coord);
std::string sink_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string sink_module_name_prefix(GRID_MODULE_NAME_PREFIX);
@ -114,7 +118,7 @@ static void add_module_nets_tile_direct_connection(
size_t src_tile_pin = tile_direct.from_tile_pin(tile_direct_id); size_t src_tile_pin = tile_direct.from_tile_pin(tile_direct_id);
t_physical_tile_type_ptr src_grid_type_descriptor = t_physical_tile_type_ptr src_grid_type_descriptor =
grids.get_physical_type(src_clb_coord.x(), src_clb_coord.y()); grids.get_physical_type(src_grid_loc);
size_t src_pin_width = size_t src_pin_width =
src_grid_type_descriptor->pin_width_offset[src_tile_pin]; src_grid_type_descriptor->pin_width_offset[src_tile_pin];
size_t src_pin_height = size_t src_pin_height =
@ -148,7 +152,7 @@ static void add_module_nets_tile_direct_connection(
size_t sink_tile_pin = tile_direct.to_tile_pin(tile_direct_id); size_t sink_tile_pin = tile_direct.to_tile_pin(tile_direct_id);
t_physical_tile_type_ptr sink_grid_type_descriptor = t_physical_tile_type_ptr sink_grid_type_descriptor =
grids.get_physical_type(des_clb_coord.x(), des_clb_coord.y()); grids.get_physical_type(sink_grid_loc);
size_t sink_pin_width = size_t sink_pin_width =
sink_grid_type_descriptor->pin_width_offset[src_tile_pin]; sink_grid_type_descriptor->pin_width_offset[src_tile_pin];
size_t sink_pin_height = size_t sink_pin_height =
@ -209,15 +213,15 @@ void add_top_module_nets_tile_direct_connections(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const CircuitLibrary& circuit_lib,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const TileDirect& tile_direct, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const ArchDirect& arch_direct) { const TileDirect& tile_direct, const ArchDirect& arch_direct) {
vtr::ScopedStartFinishTimer timer( vtr::ScopedStartFinishTimer timer(
"Add module nets for inter-tile connections"); "Add module nets for inter-tile connections");
for (const TileDirectId& tile_direct_id : tile_direct.directs()) { for (const TileDirectId& tile_direct_id : tile_direct.directs()) {
add_module_nets_tile_direct_connection( add_module_nets_tile_direct_connection(
module_manager, top_module, circuit_lib, vpr_device_annotation, grids, module_manager, top_module, circuit_lib, vpr_device_annotation, grids,
grid_instance_ids, tile_direct, tile_direct_id, arch_direct); layer, grid_instance_ids, tile_direct, tile_direct_id, arch_direct);
} }
} }

4
openfpga/src/fabric/build_top_module_directs.h
View File

@ -26,8 +26,8 @@ void add_top_module_nets_tile_direct_connections(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const CircuitLibrary& circuit_lib,
const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids, const VprDeviceAnnotation& vpr_device_annotation, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const TileDirect& tile_direct, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const ArchDirect& arch_direct); const TileDirect& tile_direct, const ArchDirect& arch_direct);
} /* end namespace openfpga */ } /* end namespace openfpga */

18
openfpga/src/fabric/build_top_module_memory.cpp
View File

@ -136,8 +136,8 @@ static void organize_top_module_tile_memory_modules(
const vtr::Matrix<size_t>& grid_instance_ids, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids, const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const bool& compact_routing_hierarchy, const vtr::Point<size_t>& tile_coord, const bool& compact_routing_hierarchy, const size_t& layer,
const e_side& tile_border_side) { const vtr::Point<size_t>& tile_coord, const e_side& tile_border_side) {
vtr::Point<size_t> gsb_coord_range = device_rr_gsb.get_gsb_range(); vtr::Point<size_t> gsb_coord_range = device_rr_gsb.get_gsb_range();
vtr::Point<size_t> gsb_coord(tile_coord.x(), tile_coord.y() - 1); vtr::Point<size_t> gsb_coord(tile_coord.x(), tile_coord.y() - 1);
@ -191,8 +191,8 @@ static void organize_top_module_tile_memory_modules(
} }
/* Find the module name for this type of grid */ /* Find the module name for this type of grid */
t_physical_tile_type_ptr grid_type = t_physical_tile_loc phy_tile_loc(tile_coord.x(), tile_coord.y(), layer);
grids.get_physical_type(tile_coord.x(), tile_coord.y()); t_physical_tile_type_ptr grid_type = grids.get_physical_type(phy_tile_loc);
/* Skip EMPTY Grid */ /* Skip EMPTY Grid */
if (true == is_empty_type(grid_type)) { if (true == is_empty_type(grid_type)) {
@ -200,8 +200,8 @@ static void organize_top_module_tile_memory_modules(
} }
/* Skip width > 1 or height > 1 Grid, which should already been processed when /* Skip width > 1 or height > 1 Grid, which should already been processed when
* offset=0 */ * offset=0 */
if ((0 < grids.get_width_offset(tile_coord.x(), tile_coord.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(tile_coord.x(), tile_coord.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
return; return;
} }
@ -437,7 +437,7 @@ void organize_top_module_memory_modules(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const ConfigProtocol& config_protocol, const CircuitLibrary& circuit_lib, const ConfigProtocol& config_protocol,
const CircuitModelId& sram_model, const DeviceGrid& grids, const CircuitModelId& sram_model, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids, const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const bool& compact_routing_hierarchy) { const bool& compact_routing_hierarchy) {
@ -497,7 +497,7 @@ void organize_top_module_memory_modules(
organize_top_module_tile_memory_modules( organize_top_module_tile_memory_modules(
module_manager, top_module, circuit_lib, config_protocol.type(), module_manager, top_module, circuit_lib, config_protocol.type(),
sram_model, grids, grid_instance_ids, device_rr_gsb, sb_instance_ids, sram_model, grids, grid_instance_ids, device_rr_gsb, sb_instance_ids,
cb_instance_ids, compact_routing_hierarchy, io_coord, io_side); cb_instance_ids, compact_routing_hierarchy, layer, io_coord, io_side);
} }
} }
@ -525,7 +525,7 @@ void organize_top_module_memory_modules(
organize_top_module_tile_memory_modules( organize_top_module_tile_memory_modules(
module_manager, top_module, circuit_lib, config_protocol.type(), module_manager, top_module, circuit_lib, config_protocol.type(),
sram_model, grids, grid_instance_ids, device_rr_gsb, sb_instance_ids, sram_model, grids, grid_instance_ids, device_rr_gsb, sb_instance_ids,
cb_instance_ids, compact_routing_hierarchy, core_coord, NUM_SIDES); cb_instance_ids, compact_routing_hierarchy, layer, core_coord, NUM_SIDES);
} }
/* Split memory modules into different regions */ /* Split memory modules into different regions */

2
openfpga/src/fabric/build_top_module_memory.h
View File

@ -32,7 +32,7 @@ void organize_top_module_memory_modules(
ModuleManager& module_manager, const ModuleId& top_module, ModuleManager& module_manager, const ModuleId& top_module,
const CircuitLibrary& circuit_lib, const ConfigProtocol& config_protocol, const CircuitLibrary& circuit_lib, const ConfigProtocol& config_protocol,
const CircuitModelId& sram_model, const DeviceGrid& grids, const CircuitModelId& sram_model, const DeviceGrid& grids,
const vtr::Matrix<size_t>& grid_instance_ids, const size_t& layer, const vtr::Matrix<size_t>& grid_instance_ids,
const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids, const DeviceRRGSB& device_rr_gsb, const vtr::Matrix<size_t>& sb_instance_ids,
const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids, const std::map<t_rr_type, vtr::Matrix<size_t>>& cb_instance_ids,
const bool& compact_routing_hierarchy); const bool& compact_routing_hierarchy);

8
openfpga/src/fabric/build_top_module_utils.cpp
View File

@ -29,8 +29,8 @@ std::string generate_grid_block_module_name_in_top_module(
/* Determine if the grid locates at the border */ /* Determine if the grid locates at the border */
vtr::Point<size_t> device_size(grids.width(), grids.height()); vtr::Point<size_t> device_size(grids.width(), grids.height());
e_side border_side = find_grid_border_side(device_size, grid_coord); e_side border_side = find_grid_border_side(device_size, grid_coord);
t_physical_tile_type_ptr phy_tile_type = t_physical_tile_type_ptr phy_tile_type = grids.get_physical_type(
grids.get_physical_type(grid_coord.x(), grid_coord.y()); t_physical_tile_loc(grid_coord.x(), grid_coord.y(), 0));
return generate_grid_block_module_name( return generate_grid_block_module_name(
prefix, std::string(phy_tile_type->name), is_io_type(phy_tile_type), prefix, std::string(phy_tile_type->name), is_io_type(phy_tile_type),
@ -51,8 +51,8 @@ std::string generate_grid_module_port_name_in_top_module(
const size_t& sink_grid_pin_index, const size_t& sink_grid_pin_index,
const VprDeviceAnnotation& vpr_device_annotation, const RRGraphView& rr_graph, const VprDeviceAnnotation& vpr_device_annotation, const RRGraphView& rr_graph,
const RRNodeId& inode) { const RRNodeId& inode) {
t_physical_tile_type_ptr grid_type_descriptor = t_physical_tile_type_ptr grid_type_descriptor = grids.get_physical_type(
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_loc(grid_coordinate.x(), grid_coordinate.y(), 0));
size_t sink_grid_pin_width = size_t sink_grid_pin_width =
grid_type_descriptor->pin_width_offset[sink_grid_pin_index]; grid_type_descriptor->pin_width_offset[sink_grid_pin_index];
size_t sink_grid_pin_height = size_t sink_grid_pin_height =

2
openfpga/src/fpga_bitstream/build_device_bitstream.cpp
View File

@ -209,7 +209,7 @@ BitstreamManager build_device_bitstream(const VprContext& vpr_ctx,
build_grid_bitstream(bitstream_manager, top_block, build_grid_bitstream(bitstream_manager, top_block,
openfpga_ctx.module_graph(), openfpga_ctx.fabric_tile(), openfpga_ctx.module_graph(), openfpga_ctx.fabric_tile(),
openfpga_ctx.arch().circuit_lib, openfpga_ctx.mux_lib(), openfpga_ctx.arch().circuit_lib, openfpga_ctx.mux_lib(),
vpr_ctx.device().grid, vpr_ctx.atom(), vpr_ctx.device().grid, 0, vpr_ctx.atom(),
openfpga_ctx.vpr_device_annotation(), openfpga_ctx.vpr_device_annotation(),
openfpga_ctx.vpr_clustering_annotation(), openfpga_ctx.vpr_clustering_annotation(),
openfpga_ctx.vpr_placement_annotation(), openfpga_ctx.vpr_placement_annotation(),

34
openfpga/src/fpga_bitstream/build_grid_bitstream.cpp
View File

@ -824,11 +824,11 @@ static void build_physical_block_bitstream(
const VprClusteringAnnotation& cluster_annotation, const VprClusteringAnnotation& cluster_annotation,
const VprPlacementAnnotation& place_annotation, const VprPlacementAnnotation& place_annotation,
const VprBitstreamAnnotation& bitstream_annotation, const DeviceGrid& grids, const VprBitstreamAnnotation& bitstream_annotation, const DeviceGrid& grids,
const vtr::Point<size_t>& grid_coord, const e_side& border_side, const size_t& layer, const vtr::Point<size_t>& grid_coord,
const bool& verbose) { const e_side& border_side, const bool& verbose) {
/* Create a block for the grid in bitstream manager */ /* Create a block for the grid in bitstream manager */
t_physical_tile_type_ptr grid_type = t_physical_tile_type_ptr grid_type = grids.get_physical_type(
grids.get_physical_type(grid_coord.x(), grid_coord.y()); t_physical_tile_loc(grid_coord.x(), grid_coord.y(), layer));
std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX); std::string grid_module_name_prefix(GRID_MODULE_NAME_PREFIX);
/* Early exit if this parent module has no configurable child modules */ /* Early exit if this parent module has no configurable child modules */
@ -950,7 +950,7 @@ void build_grid_bitstream(
BitstreamManager& bitstream_manager, const ConfigBlockId& top_block, BitstreamManager& bitstream_manager, const ConfigBlockId& top_block,
const ModuleManager& module_manager, const FabricTile& fabric_tile, const ModuleManager& module_manager, const FabricTile& fabric_tile,
const CircuitLibrary& circuit_lib, const MuxLibrary& mux_lib, const CircuitLibrary& circuit_lib, const MuxLibrary& mux_lib,
const DeviceGrid& grids, const AtomContext& atom_ctx, const DeviceGrid& grids, const size_t& layer, const AtomContext& atom_ctx,
const VprDeviceAnnotation& device_annotation, const VprDeviceAnnotation& device_annotation,
const VprClusteringAnnotation& cluster_annotation, const VprClusteringAnnotation& cluster_annotation,
const VprPlacementAnnotation& place_annotation, const VprPlacementAnnotation& place_annotation,
@ -960,13 +960,14 @@ void build_grid_bitstream(
/* Generate bitstream for the core logic block one by one */ /* Generate bitstream for the core logic block one by one */
for (size_t ix = 1; ix < grids.width() - 1; ++ix) { for (size_t ix = 1; ix < grids.width() - 1; ++ix) {
for (size_t iy = 1; iy < grids.height() - 1; ++iy) { for (size_t iy = 1; iy < grids.height() - 1; ++iy) {
t_physical_tile_loc phy_tile_loc(ix, iy, layer);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(grids.get_physical_type(ix, iy))) { if (true == is_empty_type(grids.get_physical_type(phy_tile_loc))) {
continue; continue;
} }
/* Skip width > 1 or height > 1 tiles (mostly heterogeneous blocks) */ /* Skip width > 1 or height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(ix, iy)) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(ix, iy))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
/* Add a grid module to top_module*/ /* Add a grid module to top_module*/
@ -993,8 +994,8 @@ void build_grid_bitstream(
build_physical_block_bitstream( build_physical_block_bitstream(
bitstream_manager, parent_block, module_manager, fabric_tile, curr_tile, bitstream_manager, parent_block, module_manager, fabric_tile, curr_tile,
circuit_lib, mux_lib, atom_ctx, device_annotation, cluster_annotation, circuit_lib, mux_lib, atom_ctx, device_annotation, cluster_annotation,
place_annotation, bitstream_annotation, grids, grid_coord, NUM_SIDES, place_annotation, bitstream_annotation, grids, layer, grid_coord,
verbose); NUM_SIDES, verbose);
} }
} }
VTR_LOGV(verbose, "Done\n"); VTR_LOGV(verbose, "Done\n");
@ -1008,14 +1009,15 @@ void build_grid_bitstream(
/* Add instances of I/O grids to top_module */ /* Add instances of I/O grids to top_module */
for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& io_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) { for (const vtr::Point<size_t>& io_coordinate : io_coordinates[io_side]) {
t_physical_tile_loc phy_tile_loc(io_coordinate.x(), io_coordinate.y(),
layer);
/* Bypass EMPTY grid */ /* Bypass EMPTY grid */
if (true == is_empty_type(grids.get_physical_type(io_coordinate.x(), if (true == is_empty_type(grids.get_physical_type(phy_tile_loc))) {
io_coordinate.y()))) {
continue; continue;
} }
/* Skip height > 1 tiles (mostly heterogeneous blocks) */ /* Skip height > 1 tiles (mostly heterogeneous blocks) */
if ((0 < grids.get_width_offset(io_coordinate.x(), io_coordinate.y())) || if ((0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(io_coordinate.x(), io_coordinate.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
continue; continue;
} }
/* TODO: If the fabric tile is not empty, find the tile module and create /* TODO: If the fabric tile is not empty, find the tile module and create
@ -1040,8 +1042,8 @@ void build_grid_bitstream(
build_physical_block_bitstream( build_physical_block_bitstream(
bitstream_manager, parent_block, module_manager, fabric_tile, curr_tile, bitstream_manager, parent_block, module_manager, fabric_tile, curr_tile,
circuit_lib, mux_lib, atom_ctx, device_annotation, cluster_annotation, circuit_lib, mux_lib, atom_ctx, device_annotation, cluster_annotation,
place_annotation, bitstream_annotation, grids, io_coordinate, io_side, place_annotation, bitstream_annotation, grids, layer, io_coordinate,
verbose); io_side, verbose);
} }
} }
VTR_LOGV(verbose, "Done\n"); VTR_LOGV(verbose, "Done\n");

2
openfpga/src/fpga_bitstream/build_grid_bitstream.h
View File

@ -29,7 +29,7 @@ void build_grid_bitstream(
BitstreamManager& bitstream_manager, const ConfigBlockId& top_block, BitstreamManager& bitstream_manager, const ConfigBlockId& top_block,
const ModuleManager& module_manager, const FabricTile& fabric_tile, const ModuleManager& module_manager, const FabricTile& fabric_tile,
const CircuitLibrary& circuit_lib, const MuxLibrary& mux_lib, const CircuitLibrary& circuit_lib, const MuxLibrary& mux_lib,
const DeviceGrid& grids, const AtomContext& atom_ctx, const DeviceGrid& grids, const size_t& layer, const AtomContext& atom_ctx,
const VprDeviceAnnotation& device_annotation, const VprDeviceAnnotation& device_annotation,
const VprClusteringAnnotation& cluster_annotation, const VprClusteringAnnotation& cluster_annotation,
const VprPlacementAnnotation& place_annotation, const VprPlacementAnnotation& place_annotation,

8
openfpga/src/fpga_sdc/analysis_sdc_grid_writer.cpp
View File

@ -603,15 +603,15 @@ static void print_analysis_sdc_disable_unused_grid(
/* Validate file stream */ /* Validate file stream */
valid_file_stream(fp); valid_file_stream(fp);
t_physical_tile_type_ptr grid_type = t_physical_tile_loc phy_tile_loc(grid_coordinate.x(), grid_coordinate.y(), 0);
grids.get_physical_type(grid_coordinate.x(), grid_coordinate.y()); t_physical_tile_type_ptr grid_type = grids.get_physical_type(phy_tile_loc);
/* Bypass conditions for grids : /* Bypass conditions for grids :
* 1. EMPTY type, which is by nature unused * 1. EMPTY type, which is by nature unused
* 2. Offset > 0, which has already been processed when offset = 0 * 2. Offset > 0, which has already been processed when offset = 0
*/ */
if ((true == is_empty_type(grid_type)) || if ((true == is_empty_type(grid_type)) ||
(0 < grids.get_width_offset(grid_coordinate.x(), grid_coordinate.y())) || (0 < grids.get_width_offset(phy_tile_loc)) ||
(0 < grids.get_height_offset(grid_coordinate.x(), grid_coordinate.y()))) { (0 < grids.get_height_offset(phy_tile_loc))) {
return; return;
} }

89
openfpga/src/tile_direct/build_tile_direct.cpp
View File

@ -168,7 +168,9 @@ static vtr::Point<size_t> find_grid_coordinate_given_type(
continue; continue;
} }
if (wanted_grid_type_name == if (wanted_grid_type_name ==
std::string(grids.get_physical_type(coord.x(), coord.y())->name)) { std::string(
grids.get_physical_type(t_physical_tile_loc(coord.x(), coord.y(), 0))
->name)) {
return coord; return coord;
} }
} }
@ -401,8 +403,9 @@ static void build_inner_column_row_tile_direct(
/* Walk through the device fabric and find the grid that fit the source */ /* Walk through the device fabric and find the grid that fit the source */
for (size_t x = 0; x < device_ctx.grid.width(); ++x) { for (size_t x = 0; x < device_ctx.grid.width(); ++x) {
for (size_t y = 0; y < device_ctx.grid.height(); ++y) { for (size_t y = 0; y < device_ctx.grid.height(); ++y) {
t_physical_tile_loc from_phy_tile_loc(x, y, 0);
t_physical_tile_type_ptr from_phy_tile_type = t_physical_tile_type_ptr from_phy_tile_type =
device_ctx.grid.get_physical_type(x, y); device_ctx.grid.get_physical_type(from_phy_tile_loc);
/* Bypass empty grid */ /* Bypass empty grid */
if (true == is_empty_type(from_phy_tile_type)) { if (true == is_empty_type(from_phy_tile_type)) {
continue; continue;
@ -420,8 +423,10 @@ static void build_inner_column_row_tile_direct(
for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> from_pins = find_physical_tile_pin_id( std::vector<size_t> from_pins = find_physical_tile_pin_id(
from_phy_tile_type, device_ctx.grid.get_width_offset(x, y), from_phy_tile_type,
device_ctx.grid.get_height_offset(x, y), from_tile_port, from_side); device_ctx.grid.get_width_offset(from_phy_tile_loc),
device_ctx.grid.get_height_offset(from_phy_tile_loc), from_tile_port,
from_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == from_pins.size()) { if (0 == from_pins.size()) {
continue; continue;
@ -437,9 +442,10 @@ static void build_inner_column_row_tile_direct(
continue; continue;
} }
t_physical_tile_loc to_phy_tile_loc(to_grid_coord.x(),
to_grid_coord.y(), 0);
t_physical_tile_type_ptr to_phy_tile_type = t_physical_tile_type_ptr to_phy_tile_type =
device_ctx.grid.get_physical_type(to_grid_coord.x(), device_ctx.grid.get_physical_type(to_phy_tile_loc);
to_grid_coord.y());
/* Bypass the grid that does not fit the from_tile name */ /* Bypass the grid that does not fit the from_tile name */
if (to_tile_name != std::string(to_phy_tile_type->name)) { if (to_tile_name != std::string(to_phy_tile_type->name)) {
continue; continue;
@ -451,13 +457,10 @@ static void build_inner_column_row_tile_direct(
*/ */
for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> to_pins = std::vector<size_t> to_pins = find_physical_tile_pin_id(
find_physical_tile_pin_id(to_phy_tile_type, to_phy_tile_type, device_ctx.grid.get_width_offset(to_phy_tile_loc),
device_ctx.grid.get_width_offset( device_ctx.grid.get_height_offset(to_phy_tile_loc), to_tile_port,
to_grid_coord.x(), to_grid_coord.y()), to_side);
device_ctx.grid.get_height_offset(
to_grid_coord.x(), to_grid_coord.y()),
to_tile_port, to_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == to_pins.size()) { if (0 == to_pins.size()) {
continue; continue;
@ -594,14 +597,13 @@ static void build_inter_column_row_tile_direct(
*/ */
for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> from_pins = t_physical_tile_loc from_phy_tile_loc(from_grid_coord.x(),
find_physical_tile_pin_id(device_ctx.grid.get_physical_type( from_grid_coord.y(), 0);
from_grid_coord.x(), from_grid_coord.y()), std::vector<size_t> from_pins = find_physical_tile_pin_id(
device_ctx.grid.get_width_offset( device_ctx.grid.get_physical_type(from_phy_tile_loc),
from_grid_coord.x(), from_grid_coord.y()), device_ctx.grid.get_width_offset(from_phy_tile_loc),
device_ctx.grid.get_height_offset( device_ctx.grid.get_height_offset(from_phy_tile_loc), from_tile_port,
from_grid_coord.x(), from_grid_coord.y()), from_side);
from_tile_port, from_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == from_pins.size()) { if (0 == from_pins.size()) {
continue; continue;
@ -625,14 +627,13 @@ static void build_inter_column_row_tile_direct(
*/ */
for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> to_pins = t_physical_tile_loc to_phy_tile_loc(to_grid_coord.x(),
find_physical_tile_pin_id(device_ctx.grid.get_physical_type( to_grid_coord.y(), 0);
to_grid_coord.x(), to_grid_coord.y()), std::vector<size_t> to_pins = find_physical_tile_pin_id(
device_ctx.grid.get_width_offset( device_ctx.grid.get_physical_type(to_phy_tile_loc),
to_grid_coord.x(), to_grid_coord.y()), device_ctx.grid.get_width_offset(to_phy_tile_loc),
device_ctx.grid.get_height_offset( device_ctx.grid.get_height_offset(to_phy_tile_loc), to_tile_port,
to_grid_coord.x(), to_grid_coord.y()), to_side);
to_tile_port, to_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == to_pins.size()) { if (0 == to_pins.size()) {
continue; continue;
@ -707,14 +708,13 @@ static void build_inter_column_row_tile_direct(
*/ */
for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& from_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> from_pins = t_physical_tile_loc from_phy_tile_loc(from_grid_coord.x(),
find_physical_tile_pin_id(device_ctx.grid.get_physical_type( from_grid_coord.y(), 0);
from_grid_coord.x(), from_grid_coord.y()), std::vector<size_t> from_pins = find_physical_tile_pin_id(
device_ctx.grid.get_width_offset( device_ctx.grid.get_physical_type(from_phy_tile_loc),
from_grid_coord.x(), from_grid_coord.y()), device_ctx.grid.get_width_offset(from_phy_tile_loc),
device_ctx.grid.get_height_offset( device_ctx.grid.get_height_offset(from_phy_tile_loc), from_tile_port,
from_grid_coord.x(), from_grid_coord.y()), from_side);
from_tile_port, from_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == from_pins.size()) { if (0 == from_pins.size()) {
continue; continue;
@ -738,14 +738,13 @@ static void build_inter_column_row_tile_direct(
*/ */
for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) { for (const e_side& to_side : {TOP, RIGHT, BOTTOM, LEFT}) {
/* Try to find the pin in this tile */ /* Try to find the pin in this tile */
std::vector<size_t> to_pins = t_physical_tile_loc to_phy_tile_loc(to_grid_coord.x(),
find_physical_tile_pin_id(device_ctx.grid.get_physical_type( to_grid_coord.y(), 0);
to_grid_coord.x(), to_grid_coord.y()), std::vector<size_t> to_pins = find_physical_tile_pin_id(
device_ctx.grid.get_width_offset( device_ctx.grid.get_physical_type(to_phy_tile_loc),
to_grid_coord.x(), to_grid_coord.y()), device_ctx.grid.get_width_offset(to_phy_tile_loc),
device_ctx.grid.get_height_offset( device_ctx.grid.get_height_offset(to_phy_tile_loc), to_tile_port,
to_grid_coord.x(), to_grid_coord.y()), to_side);
to_tile_port, to_side);
/* If nothing found, we can continue */ /* If nothing found, we can continue */
if (0 == to_pins.size()) { if (0 == to_pins.size()) {
continue; continue;

7
openfpga/src/utils/openfpga_physical_tile_utils.cpp
View File

@ -89,7 +89,8 @@ std::set<e_side> find_physical_io_tile_located_sides(
for (size_t ix = 1; ix < grids.width() - 1; ++ix) { for (size_t ix = 1; ix < grids.width() - 1; ++ix) {
for (size_t iy = 1; iy < grids.height() - 1; ++iy) { for (size_t iy = 1; iy < grids.height() - 1; ++iy) {
/* If located in center, we add a NUM_SIDES and finish */ /* If located in center, we add a NUM_SIDES and finish */
if (physical_tile == grids.get_physical_type(ix, iy)) { if (physical_tile ==
grids.get_physical_type(t_physical_tile_loc(ix, iy, 0))) {
io_sides.insert(NUM_SIDES); io_sides.insert(NUM_SIDES);
center_io = true; center_io = true;
break; break;
@ -108,8 +109,8 @@ std::set<e_side> find_physical_io_tile_located_sides(
for (const e_side& fpga_side : FPGA_SIDES_CLOCKWISE) { for (const e_side& fpga_side : FPGA_SIDES_CLOCKWISE) {
for (const vtr::Point<size_t>& io_coordinate : io_coordinates[fpga_side]) { for (const vtr::Point<size_t>& io_coordinate : io_coordinates[fpga_side]) {
/* If located in center, we add a NUM_SIDES and finish */ /* If located in center, we add a NUM_SIDES and finish */
if (physical_tile == if (physical_tile == grids.get_physical_type(t_physical_tile_loc(
grids.get_physical_type(io_coordinate.x(), io_coordinate.y())) { io_coordinate.x(), io_coordinate.y(), 0))) {
io_sides.insert(fpga_side); io_sides.insert(fpga_side);
break; break;
} }

32
openfpga/src/vpr_wrapper/vpr_main.cpp
View File

@ -118,20 +118,15 @@ static int vpr_standalone(int argc, char** argv) {
/* Read options, architecture, and circuit netlist */ /* Read options, architecture, and circuit netlist */
vpr_init(argc, const_cast<const char**>(argv), &Options, &vpr_setup, &Arch); vpr_init(argc, const_cast<const char**>(argv), &Options, &vpr_setup, &Arch);
const Netlist<>& net_list =
vpr_setup.RouterOpts.flat_routing
? (const Netlist<>&)g_vpr_ctx.atom().nlist
: (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
if (Options.show_version) { if (Options.show_version) {
vpr_free_all(net_list, Arch, vpr_setup); vpr_free_all(Arch, vpr_setup);
return SUCCESS_EXIT_CODE; return SUCCESS_EXIT_CODE;
} }
bool flow_succeeded = vpr_flow(vpr_setup, Arch); bool flow_succeeded = vpr_flow(vpr_setup, Arch);
if (!flow_succeeded) { if (!flow_succeeded) {
VTR_LOG("VPR failed to implement circuit\n"); VTR_LOG("VPR failed to implement circuit\n");
vpr_free_all(net_list, Arch, vpr_setup); vpr_free_all(Arch, vpr_setup);
return UNIMPLEMENTABLE_EXIT_CODE; return UNIMPLEMENTABLE_EXIT_CODE;
} }
@ -139,43 +134,30 @@ static int vpr_standalone(int argc, char** argv) {
print_timing_stats("Flow", timing_ctx.stats); print_timing_stats("Flow", timing_ctx.stats);
/* free data structures */ /* free data structures */
vpr_free_all(net_list, Arch, vpr_setup); vpr_free_all(Arch, vpr_setup);
VTR_LOG("VPR succeeded\n"); VTR_LOG("VPR succeeded\n");
} catch (const tatum::Error& tatum_error) { } catch (const tatum::Error& tatum_error) {
VTR_LOG_ERROR("%s\n", format_tatum_error(tatum_error).c_str()); VTR_LOG_ERROR("%s\n", format_tatum_error(tatum_error).c_str());
const Netlist<>& net_list = vpr_free_all(Arch, vpr_setup);
vpr_setup.RouterOpts.flat_routing
? (const Netlist<>&)g_vpr_ctx.atom().nlist
: (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
vpr_free_all(net_list, Arch, vpr_setup);
return ERROR_EXIT_CODE; return ERROR_EXIT_CODE;
} catch (const VprError& vpr_error) { } catch (const VprError& vpr_error) {
vpr_print_error(vpr_error); vpr_print_error(vpr_error);
const Netlist<>& net_list =
vpr_setup.RouterOpts.flat_routing
? (const Netlist<>&)g_vpr_ctx.atom().nlist
: (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
if (vpr_error.type() == VPR_ERROR_INTERRUPTED) { if (vpr_error.type() == VPR_ERROR_INTERRUPTED) {
vpr_free_all(net_list, Arch, vpr_setup); vpr_free_all(Arch, vpr_setup);
return INTERRUPTED_EXIT_CODE; return INTERRUPTED_EXIT_CODE;
} else { } else {
vpr_free_all(net_list, Arch, vpr_setup); vpr_free_all(Arch, vpr_setup);
return ERROR_EXIT_CODE; return ERROR_EXIT_CODE;
} }
} catch (const vtr::VtrError& vtr_error) { } catch (const vtr::VtrError& vtr_error) {
VTR_LOG_ERROR("%s:%d %s\n", vtr_error.filename_c_str(), vtr_error.line(), VTR_LOG_ERROR("%s:%d %s\n", vtr_error.filename_c_str(), vtr_error.line(),
vtr_error.what()); vtr_error.what());
const Netlist<>& net_list = vpr_free_all(Arch, vpr_setup);
vpr_setup.RouterOpts.flat_routing
? (const Netlist<>&)g_vpr_ctx.atom().nlist
: (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
vpr_free_all(net_list, Arch, vpr_setup);
return ERROR_EXIT_CODE; return ERROR_EXIT_CODE;
} }

2
vtr-verilog-to-routing

@ -1 +1 @@
Subproject commit 0963c20472e178d6562e40d90727870342035f67 Subproject commit 5bea5da827600c06990be740b580213eebae6263