Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

3D FPGA block select fix, and rr-node display fix for 3D FPGAs #2380

Merged
merged 11 commits into from
Sep 11, 2023
Merged

3D FPGA block select fix, and rr-node display fix for 3D FPGAs #2380

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
dd5db23
Updated critical path to work with multi-layer transparency options a…
Meet-Patel2580 Aug 28, 2023
05432ca
Fixed bug in the highlighting of blocks upon click to work with multi…
Meet-Patel2580 Aug 29, 2023
26b7798
Formatted code
Meet-Patel2580 Aug 30, 2023
8011703
Added helper function that returns the clusterBlockId of the clb clic…
Meet-Patel2580 Sep 3, 2023
dc9bfc3
fixing merge conflicts
Meet-Patel2580 Sep 3, 2023
21e1568
Formatted code
Meet-Patel2580 Sep 3, 2023
f6b519e
updated draw_check_rr_node_hit to ensure that only nodes on currently…
Meet-Patel2580 Sep 3, 2023
0ddc032
Formatted code
Meet-Patel2580 Sep 3, 2023
720e984
Update draw_rr.cpp
Meet-Patel2580 Sep 6, 2023
11490af
Update draw.h
Meet-Patel2580 Sep 10, 2023
738f455
Merge branch 'master' into 3D-graphics
Meet-Patel2580 Sep 10, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 14 additions & 6 deletions vpr/src/draw/draw.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -985,6 +985,7 @@ static void draw_router_expansion_costs(ezgl::renderer* g) {

static void highlight_blocks(double x, double y) {
t_draw_coords* draw_coords = get_draw_coords_vars();
t_draw_state* draw_state = get_draw_state_vars();

char msg[vtr::bufsize];
ClusterBlockId clb_index = EMPTY_BLOCK_ID;
Expand All @@ -995,8 +996,11 @@ static void highlight_blocks(double x, double y) {
/// determine block ///
ezgl::rectangle clb_bbox;

//iterate over grid z (layers) first, so we draw from bottom to top die. This makes partial transparency of layers draw properly.
for (int layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
//iterate over grid z (layers) first. Start search of the block at the top layer to prioritize highlighting of blocks at higher levels during overlapping of layers.
for (int layer_num = device_ctx.grid.get_num_layers() - 1; layer_num >= 0; layer_num--) {
if (!draw_state->draw_layer_display[layer_num].visible) {
continue; /* Don't check for blocks on non-visible layers*/
}
// iterate over grid x
for (int i = 0; i < (int)device_ctx.grid.width(); ++i) {
if (draw_coords->tile_x[i] > x) {
Expand Down Expand Up @@ -1032,7 +1036,11 @@ static void highlight_blocks(double x, double y) {

if (clb_index == EMPTY_BLOCK_ID || clb_index == ClusterBlockId::INVALID()) {
//Nothing found
return;
if (layer_num == 0) {
return; /* Nothing was found on any layer*/
} else {
continue; /* Nothing found on current layer*/
}
}

VTR_ASSERT(clb_index != EMPTY_BLOCK_ID);
Expand All @@ -1059,7 +1067,6 @@ static void highlight_blocks(double x, double y) {
}

//If manual moves is activated, then user can select block from the grid.
t_draw_state* draw_state = get_draw_state_vars();
if (draw_state->manual_moves_state.manual_move_enabled) {
draw_state->manual_moves_state.user_highlighted_block = true;
if (!draw_state->manual_moves_state.manual_move_window_is_open) {
Expand All @@ -1069,6 +1076,7 @@ static void highlight_blocks(double x, double y) {

application.update_message(msg);
application.refresh_drawing();
return;
}
}

Expand Down Expand Up @@ -1450,8 +1458,8 @@ t_draw_layer_display get_element_visibility_and_transparency(int src_layer, int
element_visibility.visible = true;
bool cross_layer_enabled = draw_state->cross_layer_display.visible;

//To only show primitive nets that are connected to currently active layers on the screen
if (!draw_state->draw_layer_display[sink_layer].visible || (!cross_layer_enabled && src_layer != sink_layer)) {
//To only show elements (net flylines,noc links,etc...) that are connected to currently active layers on the screen
if (!draw_state->draw_layer_display[sink_layer].visible || !draw_state->draw_layer_display[src_layer].visible || (!cross_layer_enabled && src_layer != sink_layer)) {
element_visibility.visible = false; /* Don't Draw */
}

Expand Down
36 changes: 23 additions & 13 deletions vpr/src/draw/draw_basic.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -653,25 +653,31 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
auto rr_type = rr_graph.node_type(inode);

RRNodeId prev_node = rr_nodes_to_draw[i - 1];
RRNodeId prev_rr_node = prev_node;
auto prev_type = rr_graph.node_type(RRNodeId(prev_node));

auto iedge = find_edge(prev_node, inode);
auto switch_type = rr_graph.edge_switch(RRNodeId(prev_node), iedge);

int current_node_layer = rr_graph.node_layer(inode);
int prev_node_layer = rr_graph.node_layer(prev_node);
t_draw_layer_display edge_visibility = get_element_visibility_and_transparency(prev_node_layer, current_node_layer);

//Don't draw node if the layer of the node is not set to visible on screen
if (!draw_state->draw_layer_display[rr_graph.node_layer(inode)].visible) {
if (!draw_state->draw_layer_display[current_node_layer].visible) {
continue;
}

ezgl::color color = draw_state->draw_rr_node[inode].color;

switch (rr_type) {
case OPIN: {
draw_rr_pin(inode, draw_state->draw_rr_node[inode].color, g);
draw_rr_pin(inode, color, g);
break;
}
case IPIN: {
draw_rr_pin(inode, draw_state->draw_rr_node[inode].color, g);
if (is_edge_valid_to_draw(inode, prev_rr_node)) {
draw_rr_pin(inode, color, g);
if (edge_visibility.visible) {
g->set_color(color, edge_visibility.alpha);
if (rr_graph.node_type(prev_node) == OPIN) {
draw_pin_to_pin(prev_node, inode, g);
} else {
Expand All @@ -684,8 +690,9 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
if (draw_state->draw_route_type == GLOBAL)
chanx_track[rr_graph.node_xlow(inode)][rr_graph.node_ylow(inode)]++;

draw_rr_chan(inode, draw_state->draw_rr_node[inode].color, g);
if (is_edge_valid_to_draw(inode, prev_rr_node)) {
draw_rr_chan(inode, color, g);
if (edge_visibility.visible) {
g->set_color(color, edge_visibility.alpha);
switch (prev_type) {
case CHANX: {
draw_chanx_to_chanx_edge(prev_node, inode, switch_type, g);
Expand Down Expand Up @@ -713,9 +720,10 @@ void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::ren
if (draw_state->draw_route_type == GLOBAL)
chany_track[rr_graph.node_xlow(inode)][rr_graph.node_ylow(inode)]++;

draw_rr_chan(inode, draw_state->draw_rr_node[inode].color, g);
draw_rr_chan(inode, color, g);

if (is_edge_valid_to_draw(inode, prev_rr_node)) {
if (edge_visibility.visible) {
g->set_color(color, edge_visibility.alpha);
switch (prev_type) {
case CHANX: {
draw_chanx_to_chany_edge(prev_node, inode,
Expand Down Expand Up @@ -1049,12 +1057,14 @@ void draw_crit_path(ezgl::renderer* g) {
int src_block_layer = get_timing_path_node_layer_num(node);
int sink_block_layer = get_timing_path_node_layer_num(prev_node);

t_draw_layer_display flyline_visibility = get_element_visibility_and_transparency(src_block_layer, sink_block_layer);

if (draw_state->show_crit_path == DRAW_CRIT_PATH_FLYLINES
|| draw_state->show_crit_path
== DRAW_CRIT_PATH_FLYLINES_DELAYS) {
// FLylines for critical path are drawn based on the layer visibility of the source and sink
if (is_flyline_valid_to_draw(src_block_layer, sink_block_layer)) {
g->set_color(color);
if (flyline_visibility.visible) {
g->set_color(color, flyline_visibility.alpha);
g->set_line_dash(ezgl::line_dash::none);
g->set_line_width(4);
draw_flyline_timing_edge(tnode_draw_coord(prev_node),
Expand All @@ -1070,10 +1080,10 @@ void draw_crit_path(ezgl::renderer* g) {
draw_routed_timing_edge_connection(prev_node, node, color, g);

// FLylines for critical path are drawn based on the layer visibility of the source and sink
if (is_flyline_valid_to_draw(src_block_layer, sink_block_layer)) {
if (flyline_visibility.visible) {
g->set_line_dash(ezgl::line_dash::asymmetric_5_3);
g->set_line_width(3);
g->set_color(color);
g->set_color(color, flyline_visibility.alpha);

draw_flyline_timing_edge((ezgl::point2d)tnode_draw_coord(prev_node),
(ezgl::point2d)tnode_draw_coord(node), (float)delay,
Expand Down