vpr/src/draw/search_bar.cpp - third_party/vtr-verilog-to-routing - Git at Google

 #ifndef NO_GRAPHICS

 #    include <cstdio>
 #    include <sstream>

 #    include "vtr_assert.h"
 #    include "vtr_ndoffsetmatrix.h"
 #    include "vtr_memory.h"
 #    include "vtr_log.h"
 #    include "vtr_color_map.h"

 #    include "vpr_utils.h"
 #    include "vpr_error.h"

 #    include "globals.h"
 #    include "draw_color.h"
 #    include "draw.h"
 #    include "read_xml_arch_file.h"
 #    include "draw_global.h"
 #    include "intra_logic_block.h"
 #    include "atom_netlist.h"
 #    include "tatum/report/TimingPathCollector.hpp"
 #    include "hsl.h"
 #    include "route_export.h"
 #    include "search_bar.h"

 #    ifdef WIN32 /* For runtime tracking in WIN32. The clock() function defined in time.h will *
                   * track CPU runtime.														   */
 #        include <time.h>
 #    else /* For X11. The clock() function in time.h will not output correct time difference   *
            * for X11, because the graphics is processed by the Xserver rather than local CPU,  *
            * which means tracking CPU time will not be the same as the actual wall clock time. *
            * Thus, so use gettimeofday() in sys/time.h to track actual calendar time.          */
 #        include <sys/time.h>
 #    endif

 //To process key presses we need the X11 keysym definitions,
 //which are unavailable when building with MINGW
 #    if defined(X11) && !defined(__MINGW32__)
 #        include <X11/keysym.h>
 #    endif

 #    include "rr_graph.h"
 #    include "route_util.h"
 #    include "place_macro.h"

 extern std::string rr_highlight_message;

 void search_and_highlight(GtkWidget* /*widget*/, ezgl::application* app) {
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();

     // get ID from search bar
     GtkEntry* text_entry = (GtkEntry*)app->get_object("TextInput");
     const char* text = gtk_entry_get_text(text_entry);
     std::string user_input = text;
     std::stringstream ss(user_input);

     GObject* combo_box = (GObject*)app->get_object("SearchType");
     gchar* type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo_box));
     std::string search_type(type);

     // reset
     deselect_all();

     if (search_type == "RR Node ID") {
         int rr_node_id = -1;
         ss >> rr_node_id;

         // valid rr node id check
         if (rr_node_id < 0 || rr_node_id >= int(device_ctx.rr_nodes.size())) {
             warning_dialog_box("Invalid RR Node ID");
             app->refresh_drawing();
             return;
         }

         highlight_rr_nodes(rr_node_id);
         auto_zoom_rr_node(rr_node_id);
     }

     else if (search_type == "Block ID") {
         int block_id = -1;
         ss >> block_id;

         // valid block id check
         if (!cluster_ctx.clb_nlist.valid_block_id(ClusterBlockId(block_id))) {
             warning_dialog_box("Invalid Block ID");
             app->refresh_drawing();
             return;
         }

         highlight_blocks((ClusterBlockId)block_id);
     }

     else if (search_type == "Block Name") {
         std::string block_name = "";
         ss >> block_name;

         highlight_blocks((std::string)block_name);
     }

     else if (search_type == "Net ID") {
         int net_id = -1;
         ss >> net_id;

         // valid net id check
         if (!cluster_ctx.clb_nlist.valid_net_id(ClusterNetId(net_id))) {
             warning_dialog_box("Invalid Net ID");
             app->refresh_drawing();
             return;
         }

         highlight_nets((ClusterNetId)net_id);
     }

     else if (search_type == "Net Name") {
         std::string net_name = "";
         ss >> net_name;

         highlight_nets((std::string)net_name);
     }

     else
         return;
     app->refresh_drawing();
 }

 bool highlight_rr_nodes(int hit_node) {
     t_draw_state* draw_state = get_draw_state_vars();

     char message[250] = "";

     if (hit_node != OPEN) {
         auto nodes = draw_expand_non_configurable_rr_nodes(hit_node);
         for (auto node : nodes) {
             if (draw_state->draw_rr_node[node].color != ezgl::MAGENTA) {
                 /* If the node hasn't been clicked on before, highlight it
                  * in magenta.
                  */
                 draw_state->draw_rr_node[node].color = ezgl::MAGENTA;
                 draw_state->draw_rr_node[node].node_highlighted = true;

             } else {
                 //Using white color to represent de-highlighting (or
                 //de-selecting) of node.
                 draw_state->draw_rr_node[node].color = ezgl::WHITE;
                 draw_state->draw_rr_node[node].node_highlighted = false;
             }
             //Print info about all nodes to terminal
             VTR_LOG("%s\n", describe_rr_node(node).c_str());
         }

         //Show info about *only* hit node to graphics
         std::string info = describe_rr_node(hit_node);

         sprintf(message, "Selected %s", info.c_str());
         rr_highlight_message = message;

         if (draw_state->draw_rr_toggle != DRAW_NO_RR) {
             // If rr_graph is shown, highlight the fan-in/fan-outs for
             // this node.
             draw_highlight_fan_in_fan_out(nodes);
         }
     } else {
         application.update_message(draw_state->default_message);
         rr_highlight_message = "";
         application.refresh_drawing();
         return false; //No hit
     }

     if (draw_state->show_nets)
         highlight_nets(message, hit_node);
     else
         application.update_message(message);

     application.refresh_drawing();
     return true;
 }

 void auto_zoom_rr_node(int rr_node_id) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
     ezgl::rectangle rr_node;

     // find the location of the node
     switch (device_ctx.rr_nodes[rr_node_id].type()) {
         case IPIN:
         case OPIN: {
             int i = device_ctx.rr_nodes[rr_node_id].xlow();
             int j = device_ctx.rr_nodes[rr_node_id].ylow();
             t_physical_tile_type_ptr type = device_ctx.grid[i][j].type;
             int width_offset = device_ctx.grid[i][j].width_offset;
             int height_offset = device_ctx.grid[i][j].height_offset;
             int ipin = device_ctx.rr_nodes[rr_node_id].ptc_num();
             float xcen, ycen;

             int iside;
             for (iside = 0; iside < 4; iside++) {
                 if (type->pinloc[width_offset][height_offset][iside][ipin]) {
                     draw_get_rr_pin_coords(rr_node_id, &xcen, &ycen);
                     rr_node = {{xcen - draw_coords->pin_size, ycen - draw_coords->pin_size},
                                {xcen + draw_coords->pin_size, ycen + draw_coords->pin_size}};
                 }
             }
             break;
         }
         case CHANX:
         case CHANY: {
             rr_node = draw_get_rr_chan_bbox(rr_node_id);
             break;
         }
         default:
             break;
     }

     // zoom to the node
     ezgl::point2d offset = {rr_node.width() * 1.5, rr_node.height() * 1.5};
     ezgl::rectangle zoom_view = {rr_node.m_first - offset, rr_node.m_second + offset};
     (application.get_canvas(application.get_main_canvas_id()))->get_camera().set_world(zoom_view);
 }

 void highlight_blocks(ClusterBlockId clb_index) {
     char msg[vtr::bufsize];
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& place_ctx = g_vpr_ctx.placement();

     /// determine block ///
     ezgl::rectangle clb_bbox;

     VTR_ASSERT(clb_index != EMPTY_BLOCK_ID);

     ezgl::point2d point_in_clb = clb_bbox.bottom_left();
     highlight_sub_block(point_in_clb, clb_index, cluster_ctx.clb_nlist.block_pb(clb_index));

     if (get_selected_sub_block_info().has_selection()) {
         t_pb* selected_subblock = get_selected_sub_block_info().get_selected_pb();
         sprintf(msg, "sub-block %s (a \"%s\") selected",
                 selected_subblock->name, selected_subblock->pb_graph_node->pb_type->name);
     } else {
         /* Highlight block and fan-in/fan-outs. */
         draw_highlight_blocks_color(cluster_ctx.clb_nlist.block_type(clb_index), clb_index);
         sprintf(msg, "Block #%zu (%s) at (%d, %d) selected.", size_t(clb_index), cluster_ctx.clb_nlist.block_name(clb_index).c_str(), place_ctx.block_locs[clb_index].loc.x, place_ctx.block_locs[clb_index].loc.y);
     }

     application.update_message(msg);

     application.refresh_drawing();
 }

 void highlight_nets(ClusterNetId net_id) {
     t_trace* tptr;
     auto& route_ctx = g_vpr_ctx.routing();

     t_draw_state* draw_state = get_draw_state_vars();

     if (int(route_ctx.trace.size()) == 0) return;

     for (tptr = route_ctx.trace[net_id].head; tptr != nullptr; tptr = tptr->next) {
         draw_state->net_color[net_id] = ezgl::MAGENTA;
     }
 }

 void highlight_nets(std::string net_name) {
     auto& cluster_ctx = g_vpr_ctx.clustering();

     ClusterNetId net_id = ClusterNetId::INVALID();
     net_id = cluster_ctx.clb_nlist.find_net(net_name);

     if (net_id == ClusterNetId::INVALID()) {
         warning_dialog_box("Invalid Net Name");
         return; //name not exist
     }

     highlight_nets(net_id); //found net
 }

 void highlight_blocks(std::string block_name) {
     auto& cluster_ctx = g_vpr_ctx.clustering();

     ClusterBlockId block_id = ClusterBlockId::INVALID();
     block_id = cluster_ctx.clb_nlist.find_block(block_name);

     if (block_id == ClusterBlockId::INVALID()) {
         warning_dialog_box("Invalid Block Name");
         return; //name not exist
     }

     highlight_blocks(block_id); //found block
 }

 void warning_dialog_box(const char* message) {
     GObject* main_window;    // parent window over which to add the dialog
     GtkWidget* content_area; // content area of the dialog
     GtkWidget* label;        // label to display a message
     GtkWidget* dialog;
     // get a pointer to the main window
     main_window = application.get_object(application.get_main_window_id().c_str());
     // create a dialog window modal with no button
     dialog = gtk_message_dialog_new(GTK_WINDOW(main_window),
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
                                     GTK_MESSAGE_INFO,
                                     GTK_BUTTONS_NONE,
                                     "Error");
     // create a label and attach it to content area of the dialog
     content_area = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(dialog));
     label = gtk_label_new(message);
     gtk_container_add(GTK_CONTAINER(content_area), label);
     // show the label & child widget of the dialog
     gtk_widget_show_all(dialog);

     g_signal_connect_swapped(dialog,
                              "response",
                              G_CALLBACK(gtk_widget_destroy),
                              dialog);

     return;
 }

 #endif /* NO_GRAPHICS */
	#ifndef NO_GRAPHICS

	# include <cstdio>
	# include <sstream>

	# include "vtr_assert.h"
	# include "vtr_ndoffsetmatrix.h"
	# include "vtr_memory.h"
	# include "vtr_log.h"
	# include "vtr_color_map.h"

	# include "vpr_utils.h"
	# include "vpr_error.h"

	# include "globals.h"
	# include "draw_color.h"
	# include "draw.h"
	# include "read_xml_arch_file.h"
	# include "draw_global.h"
	# include "intra_logic_block.h"
	# include "atom_netlist.h"
	# include "tatum/report/TimingPathCollector.hpp"
	# include "hsl.h"
	# include "route_export.h"
	# include "search_bar.h"

	# ifdef WIN32 /* For runtime tracking in WIN32. The clock() function defined in time.h will *
	* track CPU runtime. */
	# include <time.h>
	# else /* For X11. The clock() function in time.h will not output correct time difference *
	* for X11, because the graphics is processed by the Xserver rather than local CPU, *
	* which means tracking CPU time will not be the same as the actual wall clock time. *
	* Thus, so use gettimeofday() in sys/time.h to track actual calendar time. */
	# include <sys/time.h>
	# endif

	//To process key presses we need the X11 keysym definitions,
	//which are unavailable when building with MINGW
	# if defined(X11) && !defined(__MINGW32__)
	# include <X11/keysym.h>
	# endif

	# include "rr_graph.h"
	# include "route_util.h"
	# include "place_macro.h"

	extern std::string rr_highlight_message;

	void search_and_highlight(GtkWidget* /widget/, ezgl::application* app) {
	auto& device_ctx = g_vpr_ctx.device();
	auto& cluster_ctx = g_vpr_ctx.clustering();

	// get ID from search bar
	GtkEntry* text_entry = (GtkEntry*)app->get_object("TextInput");
	const char* text = gtk_entry_get_text(text_entry);
	std::string user_input = text;
	std::stringstream ss(user_input);

	GObject* combo_box = (GObject*)app->get_object("SearchType");
	gchar* type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo_box));
	std::string search_type(type);

	// reset
	deselect_all();

	if (search_type == "RR Node ID") {
	int rr_node_id = -1;
	ss >> rr_node_id;

	// valid rr node id check
	if (rr_node_id < 0 \|\| rr_node_id >= int(device_ctx.rr_nodes.size())) {
	warning_dialog_box("Invalid RR Node ID");
	app->refresh_drawing();
	return;
	}

	highlight_rr_nodes(rr_node_id);
	auto_zoom_rr_node(rr_node_id);
	}

	else if (search_type == "Block ID") {
	int block_id = -1;
	ss >> block_id;

	// valid block id check
	if (!cluster_ctx.clb_nlist.valid_block_id(ClusterBlockId(block_id))) {
	warning_dialog_box("Invalid Block ID");
	app->refresh_drawing();
	return;
	}

	highlight_blocks((ClusterBlockId)block_id);
	}

	else if (search_type == "Block Name") {
	std::string block_name = "";
	ss >> block_name;

	highlight_blocks((std::string)block_name);
	}

	else if (search_type == "Net ID") {
	int net_id = -1;
	ss >> net_id;

	// valid net id check
	if (!cluster_ctx.clb_nlist.valid_net_id(ClusterNetId(net_id))) {
	warning_dialog_box("Invalid Net ID");
	app->refresh_drawing();
	return;
	}

	highlight_nets((ClusterNetId)net_id);
	}

	else if (search_type == "Net Name") {
	std::string net_name = "";
	ss >> net_name;

	highlight_nets((std::string)net_name);
	}

	else
	return;
	app->refresh_drawing();
	}

	bool highlight_rr_nodes(int hit_node) {
	t_draw_state* draw_state = get_draw_state_vars();

	char message[250] = "";

	if (hit_node != OPEN) {
	auto nodes = draw_expand_non_configurable_rr_nodes(hit_node);
	for (auto node : nodes) {
	if (draw_state->draw_rr_node[node].color != ezgl::MAGENTA) {
	/* If the node hasn't been clicked on before, highlight it
	* in magenta.
	*/
	draw_state->draw_rr_node[node].color = ezgl::MAGENTA;
	draw_state->draw_rr_node[node].node_highlighted = true;

	} else {
	//Using white color to represent de-highlighting (or
	//de-selecting) of node.
	draw_state->draw_rr_node[node].color = ezgl::WHITE;
	draw_state->draw_rr_node[node].node_highlighted = false;
	}
	//Print info about all nodes to terminal
	VTR_LOG("%s\n", describe_rr_node(node).c_str());
	}

	//Show info about only hit node to graphics
	std::string info = describe_rr_node(hit_node);

	sprintf(message, "Selected %s", info.c_str());
	rr_highlight_message = message;

	if (draw_state->draw_rr_toggle != DRAW_NO_RR) {
	// If rr_graph is shown, highlight the fan-in/fan-outs for
	// this node.
	draw_highlight_fan_in_fan_out(nodes);
	}
	} else {
	application.update_message(draw_state->default_message);
	rr_highlight_message = "";
	application.refresh_drawing();
	return false; //No hit
	}

	if (draw_state->show_nets)
	highlight_nets(message, hit_node);
	else
	application.update_message(message);

	application.refresh_drawing();
	return true;
	}

	void auto_zoom_rr_node(int rr_node_id) {
	t_draw_coords* draw_coords = get_draw_coords_vars();
	auto& device_ctx = g_vpr_ctx.device();
	ezgl::rectangle rr_node;

	// find the location of the node
	switch (device_ctx.rr_nodes[rr_node_id].type()) {
	case IPIN:
	case OPIN: {
	int i = device_ctx.rr_nodes[rr_node_id].xlow();
	int j = device_ctx.rr_nodes[rr_node_id].ylow();
	t_physical_tile_type_ptr type = device_ctx.grid[i][j].type;
	int width_offset = device_ctx.grid[i][j].width_offset;
	int height_offset = device_ctx.grid[i][j].height_offset;
	int ipin = device_ctx.rr_nodes[rr_node_id].ptc_num();
	float xcen, ycen;

	int iside;
	for (iside = 0; iside < 4; iside++) {
	if (type->pinloc[width_offset][height_offset][iside][ipin]) {
	draw_get_rr_pin_coords(rr_node_id, &xcen, &ycen);
	rr_node = {{xcen - draw_coords->pin_size, ycen - draw_coords->pin_size},
	{xcen + draw_coords->pin_size, ycen + draw_coords->pin_size}};
	}
	}
	break;
	}
	case CHANX:
	case CHANY: {
	rr_node = draw_get_rr_chan_bbox(rr_node_id);
	break;
	}
	default:
	break;
	}

	// zoom to the node
	ezgl::point2d offset = {rr_node.width() * 1.5, rr_node.height() * 1.5};
	ezgl::rectangle zoom_view = {rr_node.m_first - offset, rr_node.m_second + offset};
	(application.get_canvas(application.get_main_canvas_id()))->get_camera().set_world(zoom_view);
	}

	void highlight_blocks(ClusterBlockId clb_index) {
	char msg[vtr::bufsize];
	auto& cluster_ctx = g_vpr_ctx.clustering();
	auto& place_ctx = g_vpr_ctx.placement();

	/// determine block ///
	ezgl::rectangle clb_bbox;

	VTR_ASSERT(clb_index != EMPTY_BLOCK_ID);

	ezgl::point2d point_in_clb = clb_bbox.bottom_left();
	highlight_sub_block(point_in_clb, clb_index, cluster_ctx.clb_nlist.block_pb(clb_index));

	if (get_selected_sub_block_info().has_selection()) {
	t_pb* selected_subblock = get_selected_sub_block_info().get_selected_pb();
	sprintf(msg, "sub-block %s (a \"%s\") selected",
	selected_subblock->name, selected_subblock->pb_graph_node->pb_type->name);
	} else {
	/* Highlight block and fan-in/fan-outs. */
	draw_highlight_blocks_color(cluster_ctx.clb_nlist.block_type(clb_index), clb_index);
	sprintf(msg, "Block #%zu (%s) at (%d, %d) selected.", size_t(clb_index), cluster_ctx.clb_nlist.block_name(clb_index).c_str(), place_ctx.block_locs[clb_index].loc.x, place_ctx.block_locs[clb_index].loc.y);
	}

	application.update_message(msg);

	application.refresh_drawing();
	}

	void highlight_nets(ClusterNetId net_id) {
	t_trace* tptr;
	auto& route_ctx = g_vpr_ctx.routing();

	t_draw_state* draw_state = get_draw_state_vars();

	if (int(route_ctx.trace.size()) == 0) return;

	for (tptr = route_ctx.trace[net_id].head; tptr != nullptr; tptr = tptr->next) {
	draw_state->net_color[net_id] = ezgl::MAGENTA;
	}
	}

	void highlight_nets(std::string net_name) {
	auto& cluster_ctx = g_vpr_ctx.clustering();

	ClusterNetId net_id = ClusterNetId::INVALID();
	net_id = cluster_ctx.clb_nlist.find_net(net_name);

	if (net_id == ClusterNetId::INVALID()) {
	warning_dialog_box("Invalid Net Name");
	return; //name not exist
	}

	highlight_nets(net_id); //found net
	}

	void highlight_blocks(std::string block_name) {
	auto& cluster_ctx = g_vpr_ctx.clustering();

	ClusterBlockId block_id = ClusterBlockId::INVALID();
	block_id = cluster_ctx.clb_nlist.find_block(block_name);

	if (block_id == ClusterBlockId::INVALID()) {
	warning_dialog_box("Invalid Block Name");
	return; //name not exist
	}

	highlight_blocks(block_id); //found block
	}

	void warning_dialog_box(const char* message) {
	GObject* main_window; // parent window over which to add the dialog
	GtkWidget* content_area; // content area of the dialog
	GtkWidget* label; // label to display a message
	GtkWidget* dialog;
	// get a pointer to the main window
	main_window = application.get_object(application.get_main_window_id().c_str());
	// create a dialog window modal with no button
	dialog = gtk_message_dialog_new(GTK_WINDOW(main_window),
	GTK_DIALOG_DESTROY_WITH_PARENT,
	GTK_MESSAGE_INFO,
	GTK_BUTTONS_NONE,
	"Error");
	// create a label and attach it to content area of the dialog
	content_area = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(dialog));
	label = gtk_label_new(message);
	gtk_container_add(GTK_CONTAINER(content_area), label);
	// show the label & child widget of the dialog
	gtk_widget_show_all(dialog);

	g_signal_connect_swapped(dialog,
	"response",
	G_CALLBACK(gtk_widget_destroy),
	dialog);

	return;
	}

	#endif /* NO_GRAPHICS */