| #include <stdio.h> |
| #include <string.h> |
| #include <math.h> |
| #include "util.h" |
| #include "vpr_types.h" |
| #include "vpr_utils.h" |
| #include "globals.h" |
| #include "graphics.h" |
| #include "path_delay.h" |
| #include "draw.h" |
| #include <assert.h> |
| |
| /*************** Types local to this module *********************************/ |
| #define MAX_BLOCK_COLOURS 5 |
| |
| enum e_draw_rr_toggle |
| { |
| DRAW_NO_RR = 0, |
| DRAW_ALL_RR, |
| DRAW_ALL_BUT_BUFFERS_RR, |
| DRAW_NODES_AND_SBOX_RR, |
| DRAW_NODES_RR, |
| DRAW_RR_TOGGLE_MAX |
| }; |
| |
| enum e_draw_net_type |
| { ALL_NETS, HIGHLIGHTED }; |
| |
| enum e_edge_dir |
| { FROM_X_TO_Y, FROM_Y_TO_X }; /* Chanx to chany or vice versa? */ |
| |
| |
| /****************** Variables local to this module. *************************/ |
| |
| static boolean show_nets = FALSE; /* Show nets of placement or routing? */ |
| |
| /* Controls drawing of routing resources on screen, if pic_on_screen is * |
| * ROUTING. */ |
| |
| /* Can toggle to DRAW_NO_RR;*/ |
| static enum e_draw_rr_toggle draw_rr_toggle = DRAW_NO_RR; /* UDSD by AY */ |
| |
| static enum e_route_type draw_route_type; |
| |
| /* Controls if congestion is shown, when ROUTING is on screen. */ |
| |
| static boolean show_congestion = FALSE; |
| |
| static boolean show_graphics; /* Graphics enabled or not? */ |
| |
| static char default_message[BUFSIZE]; /* Default screen message on screen */ |
| |
| static int gr_automode; /* Need user input after: 0: each t, * |
| * 1: each place, 2: never */ |
| |
| static enum pic_type pic_on_screen = NO_PICTURE; /* What do I draw? */ |
| |
| static float *tile_x, *tile_y; |
| |
| /* The left and bottom coordinates of each grid_tile in the FPGA. * |
| * tile_x[0..nx+1] and tile_y[0..ny+1]. * |
| * COORDINATE SYSTEM goes from (0,0) at the lower left corner to * |
| * (tile_x[nx+1]+tile_width, tile_y[ny+1]+tile_width) in the * |
| * upper right corner. */ |
| |
| |
| static float tile_width, pin_size; |
| |
| /* Drawn width (and height) of a grid_tile, and the half-width or half-height of * |
| * a pin, respectiviely. Set when init_draw_coords is called. */ |
| |
| static enum color_types *net_color, *block_color; |
| |
| /* Color in which each block and net should be drawn. * |
| * [0..num_nets-1] and [0..num_blocks-1], respectively. */ |
| |
| |
| /********************** Subroutines local to this module ********************/ |
| |
| static void toggle_nets(void (*drawscreen) (void)); |
| static void toggle_rr(void (*drawscreen) (void)); |
| static void toggle_congestion(void (*drawscreen) (void)); |
| static void highlight_crit_path(void (*drawscreen_ptr) (void)); |
| |
| static void drawscreen(void); |
| static void redraw_screen(void); |
| static void drawplace(void); |
| static void drawnets(void); |
| static void drawroute(enum e_draw_net_type draw_net_type); |
| static void draw_congestion(void); |
| |
| static void highlight_blocks(float x, |
| float y); |
| static void get_block_center(int bnum, |
| float *x, |
| float *y); |
| static void deselect_all(void); |
| |
| static void draw_rr(void); |
| static void draw_rr_edges(int from_node); |
| static void draw_rr_pin(int inode, |
| enum color_types color); |
| static void draw_rr_chanx(int inode, |
| int itrack); |
| static void draw_rr_chany(int inode, |
| int itrack); |
| static void get_rr_pin_draw_coords(int inode, |
| int iside, |
| int ioff, |
| float *xcen, |
| float *ycen); |
| static void draw_pin_to_chan_edge(int pin_node, |
| int chan_node); |
| static void draw_x(float x, |
| float y, |
| float size); |
| static void draw_chany_to_chany_edge(int from_node, |
| int from_track, |
| int to_node, |
| int to_track, |
| short switch_type); |
| static void draw_chanx_to_chanx_edge(int from_node, |
| int from_track, |
| int to_node, |
| int to_track, |
| short switch_type); |
| static void draw_chanx_to_chany_edge(int chanx_node, |
| int chanx_track, |
| int chany_node, |
| int chany_track, |
| enum e_edge_dir edge_dir, |
| short switch_type); |
| static int get_track_num(int inode, |
| int **chanx_track, |
| int **chany_track); |
| static void draw_rr_switch(float from_x, |
| float from_y, |
| float to_x, |
| float to_y, |
| boolean buffered); |
| static void draw_triangle_along_line(float xend, |
| float yend, /* UDSD by AY */ |
| |
| float x1, |
| float x2, /* UDSD by AY */ |
| |
| float y1, |
| float y2); /* UDSD by AY */ |
| |
| |
| /********************** Subroutine definitions ******************************/ |
| |
| |
| void |
| set_graphics_state(boolean show_graphics_val, |
| int gr_automode_val, |
| enum e_route_type route_type) |
| { |
| |
| /* Sets the static show_graphics and gr_automode variables to the * |
| * desired values. They control if graphics are enabled and, if so, * |
| * how often the user is prompted for input. */ |
| |
| show_graphics = show_graphics_val; |
| gr_automode = gr_automode_val; |
| draw_route_type = route_type; |
| } |
| |
| |
| void |
| update_screen(int priority, |
| char *msg, |
| enum pic_type pic_on_screen_val, |
| boolean crit_path_button_enabled) |
| { |
| |
| /* Updates the screen if the user has requested graphics. The priority * |
| * value controls whether or not the Proceed button must be clicked to * |
| * continue. Saves the pic_on_screen_val to allow pan and zoom redraws. */ |
| |
| if(!show_graphics) /* Graphics turned off */ |
| return; |
| |
| |
| |
| /* If it's the type of picture displayed has changed, set up the proper * |
| * buttons. */ |
| if(pic_on_screen != pic_on_screen_val) |
| { |
| if(pic_on_screen_val == PLACEMENT && pic_on_screen == NO_PICTURE) |
| { |
| create_button("Window", "Toggle Nets", toggle_nets); |
| } |
| else if(pic_on_screen_val == ROUTING |
| && pic_on_screen == PLACEMENT) |
| { |
| create_button("Toggle Nets", "Toggle RR", toggle_rr); |
| create_button("Toggle RR", "Congestion", |
| toggle_congestion); |
| |
| if(crit_path_button_enabled) |
| { |
| create_button("Congestion", "Crit. Path", |
| highlight_crit_path); |
| } |
| } |
| else if(pic_on_screen_val == PLACEMENT |
| && pic_on_screen == ROUTING) |
| { |
| destroy_button("Toggle RR"); |
| destroy_button("Congestion"); |
| |
| if(crit_path_button_enabled) |
| { |
| destroy_button("Crit. Path"); |
| } |
| } |
| else if(pic_on_screen_val == ROUTING |
| && pic_on_screen == NO_PICTURE) |
| { |
| create_button("Window", "Toggle Nets", toggle_nets); |
| create_button("Toggle Nets", "Toggle RR", toggle_rr); |
| create_button("Toggle RR", "Congestion", |
| toggle_congestion); |
| |
| if(crit_path_button_enabled) |
| { |
| create_button("Congestion", "Crit. Path", |
| highlight_crit_path); |
| } |
| } |
| } |
| /* Save the main message. */ |
| |
| my_strncpy(default_message, msg, BUFSIZE); |
| |
| pic_on_screen = pic_on_screen_val; |
| update_message(msg); |
| drawscreen(); |
| if(priority >= gr_automode) |
| { |
| event_loop(highlight_blocks, drawscreen); |
| } |
| else |
| { |
| flushinput(); |
| } |
| } |
| |
| |
| static void |
| drawscreen() |
| { |
| |
| /* This is the screen redrawing routine that event_loop assumes exists. * |
| * It erases whatever is on screen, then calls redraw_screen to redraw * |
| * it. */ |
| |
| clearscreen(); |
| redraw_screen(); |
| } |
| |
| |
| static void |
| redraw_screen() |
| { |
| |
| /* The screen redrawing routine called by drawscreen and * |
| * highlight_blocks. Call this routine instead of drawscreen if * |
| * you know you don't need to erase the current graphics, and want * |
| * to avoid a screen "flash". */ |
| |
| setfontsize(20); /* UDSD Modification by WMF */ |
| if(pic_on_screen == PLACEMENT) |
| { |
| drawplace(); |
| if(show_nets) |
| { |
| drawnets(); |
| } |
| } |
| else |
| { /* ROUTING on screen */ |
| drawplace(); |
| |
| if(show_nets) |
| { |
| drawroute(ALL_NETS); |
| } |
| else |
| { |
| draw_rr(); |
| } |
| |
| if(show_congestion) |
| { |
| draw_congestion(); |
| } |
| } |
| } |
| |
| |
| static void |
| toggle_nets(void (*drawscreen_ptr) (void)) |
| { |
| |
| /* Enables/disables drawing of nets when a the user clicks on a button. * |
| * Also disables drawing of routing resources. See graphics.c for details * |
| * of how buttons work. */ |
| |
| show_nets = !show_nets; |
| draw_rr_toggle = DRAW_NO_RR; |
| show_congestion = FALSE; |
| |
| update_message(default_message); |
| drawscreen_ptr(); |
| } |
| |
| |
| static void |
| toggle_rr(void (*drawscreen_ptr) (void)) |
| { |
| |
| /* Cycles through the options for viewing the routing resources available * |
| * in an FPGA. If a routing isn't on screen, the routing graph hasn't been * |
| * built, and this routine doesn't switch the view. Otherwise, this routine * |
| * switches to the routing resource view. Clicking on the toggle cycles * |
| * through the options: DRAW_NO_RR, DRAW_ALL_RR, DRAW_ALL_BUT_BUFFERS_RR, * |
| * DRAW_NODES_AND_SBOX_RR, and DRAW_NODES_RR. */ |
| |
| draw_rr_toggle = (draw_rr_toggle + 1) % (DRAW_RR_TOGGLE_MAX); |
| show_nets = FALSE; |
| show_congestion = FALSE; |
| |
| update_message(default_message); |
| drawscreen_ptr(); |
| } |
| |
| |
| static void |
| toggle_congestion(void (*drawscreen_ptr) (void)) |
| { |
| |
| /* Turns the congestion display on and off. */ |
| char msg[BUFSIZE]; |
| int inode, num_congested; |
| |
| show_nets = FALSE; |
| draw_rr_toggle = DRAW_NO_RR; |
| show_congestion = !show_congestion; |
| |
| if(!show_congestion) |
| { |
| update_message(default_message); |
| } |
| else |
| { |
| num_congested = 0; |
| for(inode = 0; inode < num_rr_nodes; inode++) |
| { |
| if(rr_node[inode].occ > rr_node[inode].capacity) |
| { |
| num_congested++; |
| } |
| } |
| |
| sprintf(msg, "%d routing resources are overused.", num_congested); |
| update_message(msg); |
| } |
| |
| drawscreen_ptr(); |
| } |
| |
| |
| static void |
| highlight_crit_path(void (*drawscreen_ptr) (void)) |
| { |
| |
| /* Highlights all the blocks and nets on the critical path. */ |
| |
| t_linked_int *critical_path_head, *critical_path_node; |
| int inode, iblk, inet, num_nets_seen; |
| static int nets_to_highlight = 1; |
| char msg[BUFSIZE]; |
| |
| if(nets_to_highlight == 0) |
| { /* Clear the display of all highlighting. */ |
| nets_to_highlight = 1; |
| deselect_all(); |
| update_message(default_message); |
| drawscreen_ptr(); |
| return; |
| } |
| |
| critical_path_head = allocate_and_load_critical_path(); |
| critical_path_node = critical_path_head; |
| num_nets_seen = 0; |
| |
| while(critical_path_node != NULL) |
| { |
| inode = critical_path_node->data; |
| get_tnode_block_and_output_net(inode, &iblk, &inet); |
| |
| if(num_nets_seen == nets_to_highlight) |
| { /* Last block */ |
| block_color[iblk] = MAGENTA; |
| } |
| else if(num_nets_seen == nets_to_highlight - 1) |
| { /* 2nd last block */ |
| block_color[iblk] = YELLOW; |
| } |
| else if(num_nets_seen < nets_to_highlight) |
| { /* Earlier block */ |
| block_color[iblk] = DARKGREEN; |
| } |
| |
| if(inet != OPEN) |
| { |
| num_nets_seen++; |
| |
| if(num_nets_seen < nets_to_highlight) |
| { /* First nets. */ |
| net_color[inet] = DARKGREEN; |
| } |
| else if(num_nets_seen == nets_to_highlight) |
| { |
| net_color[inet] = CYAN; /* Last (new) net. */ |
| } |
| } |
| |
| critical_path_node = critical_path_node->next; |
| } |
| |
| if(nets_to_highlight == num_nets_seen) |
| { |
| nets_to_highlight = 0; |
| sprintf(msg, "All %d nets on the critical path highlighted.", |
| num_nets_seen); |
| } |
| else |
| { |
| sprintf(msg, "First %d nets on the critical path highlighted.", |
| nets_to_highlight); |
| nets_to_highlight++; |
| } |
| |
| free_int_list(&critical_path_head); |
| |
| update_message(msg); |
| drawscreen_ptr(); |
| } |
| |
| |
| void |
| alloc_draw_structs(void) |
| { |
| |
| /* Allocate the structures needed to draw the placement and routing. Set * |
| * up the default colors for blocks and nets. */ |
| |
| tile_x = (float *)my_malloc((nx + 2) * sizeof(float)); |
| tile_y = (float *)my_malloc((ny + 2) * sizeof(float)); |
| |
| net_color = (enum color_types *) |
| my_malloc(num_nets * sizeof(enum color_types)); |
| |
| block_color = (enum color_types *) |
| my_malloc(num_blocks * sizeof(enum color_types)); |
| |
| deselect_all(); /* Set initial colors */ |
| } |
| |
| |
| void |
| init_draw_coords(float width_val) |
| { |
| |
| /* Load the arrays containing the left and bottom coordinates of the clbs * |
| * forming the FPGA. tile_width_val sets the width and height of a drawn * |
| * clb. */ |
| |
| int i; |
| int j; |
| |
| if(!show_graphics) |
| return; /* -nodisp was selected. */ |
| |
| tile_width = width_val; |
| pin_size = 0.3; |
| for(i = 0; i < num_types; ++i) |
| { |
| pin_size = |
| min(pin_size, |
| (tile_width / (4.0 * type_descriptors[i].num_pins))); |
| } |
| |
| j = 0; |
| for(i = 0; i < (nx + 1); i++) |
| { |
| tile_x[i] = (i * tile_width) + j; |
| j += chan_width_y[i] + 1; /* N wires need N+1 units of space */ |
| } |
| tile_x[nx + 1] = ((nx + 1) * tile_width) + j; |
| |
| j = 0; |
| for(i = 0; i < (ny + 1); ++i) |
| { |
| tile_y[i] = (i * tile_width) + j; |
| j += chan_width_x[i] + 1; |
| } |
| tile_y[ny + 1] = ((ny + 1) * tile_width) + j; |
| |
| init_world(0.0, |
| tile_y[ny + 1] + tile_width, tile_x[nx + 1] + tile_width, 0.0); |
| } |
| |
| |
| static void |
| drawplace(void) |
| { |
| |
| /* Draws the blocks placed on the proper clbs. Occupied blocks are darker colours * |
| * while empty ones are lighter colours and have a dashed border. */ |
| |
| float sub_tile_step; |
| float x1, y1, x2, y2; |
| int i, j, k, bnum; |
| int num_sub_tiles; |
| int height; |
| |
| setlinewidth(0); |
| |
| for(i = 0; i <= (nx + 1); i++) |
| { |
| for(j = 0; j <= (ny + 1); j++) |
| { |
| /* Only the first block of a group should control drawing */ |
| if(grid[i][j].offset > 0) |
| continue; |
| |
| /* Don't draw corners */ |
| if(((i < 1) || (i > nx)) && ((j < 1) || (j > ny))) |
| continue; |
| |
| num_sub_tiles = grid[i][j].type->capacity; |
| sub_tile_step = tile_width / num_sub_tiles; |
| height = grid[i][j].type->height; |
| |
| if(num_sub_tiles < 1) |
| { |
| setcolor(BLACK); |
| setlinestyle(DASHED); |
| drawrect(tile_x[i], tile_y[j], |
| tile_x[i] + tile_width, |
| tile_y[j] + tile_width); |
| draw_x(tile_x[i] + (tile_width / 2), |
| tile_y[j] + (tile_width / 2), |
| (tile_width / 2)); |
| } |
| |
| for(k = 0; k < num_sub_tiles; ++k) |
| { |
| /* Graphics will look unusual for multiple height and capacity */ |
| assert(height == 1 || num_sub_tiles == 1); |
| /* Get coords of current sub_tile */ |
| if((i < 1) || (i > nx)) |
| { /* left and right fringes */ |
| x1 = tile_x[i]; |
| y1 = tile_y[j] + (k * sub_tile_step); |
| x2 = x1 + tile_width; |
| y2 = y1 + sub_tile_step; |
| } |
| else if((j < 1) || (j > ny)) |
| { /* top and bottom fringes */ |
| x1 = tile_x[i] + (k * sub_tile_step); |
| y1 = tile_y[j]; |
| x2 = x1 + sub_tile_step; |
| y2 = y1 + tile_width; |
| } |
| else |
| { |
| assert(num_sub_tiles <= 1); /* Need to change draw code to support */ |
| |
| x1 = tile_x[i]; |
| y1 = tile_y[j]; |
| x2 = x1 + tile_width; |
| y2 = tile_y[j + height - 1] + tile_width; |
| } |
| |
| /* Look at the tile at start of large block */ |
| bnum = grid[i][j].blocks[k]; |
| |
| |
| /* Draw background */ |
| if(bnum != EMPTY) |
| { |
| setcolor(block_color[bnum]); |
| fillrect(x1, y1, x2, y2); |
| } else { |
| // colour empty blocks a particular colour depending on type |
| if(grid[i][j].type->index < 3) { |
| setcolor(WHITE); |
| } else if(grid[i][j].type->index < 3 + MAX_BLOCK_COLOURS) { |
| setcolor(BISQUE + grid[i][j].type->index - 3); |
| } else { |
| setcolor(BISQUE + MAX_BLOCK_COLOURS - 1); |
| } |
| fillrect(x1, y1, x2, y2); |
| } |
| |
| setcolor(BLACK); |
| |
| setlinestyle((EMPTY == bnum) ? DASHED : SOLID); |
| drawrect(x1, y1, x2, y2); |
| |
| /* Draw text if the space has parts of the netlist */ |
| if(bnum != EMPTY) |
| { |
| drawtext((x1 + x2) / 2.0, (y1 + y2) / 2.0, |
| block[bnum].name, tile_width); |
| } |
| |
| /* Draw text for block type so that user knows what block */ |
| if(grid[i][j].offset == 0) { |
| if(i > 0 && i <= nx && j > 0 && j <= ny) { |
| drawtext((x1 + x2) / 2.0, y1 + (tile_width / 4.0), |
| grid[i][j].type->name, tile_width); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| static void |
| drawnets(void) |
| { |
| |
| /* This routine draws the nets on the placement. The nets have not * |
| * yet been routed, so we just draw a chain showing a possible path * |
| * for each net. This gives some idea of future congestion. */ |
| |
| int inet, ipin, b1, b2; |
| float x1, y1, x2, y2; |
| |
| setlinestyle(SOLID); |
| setlinewidth(0); |
| |
| /* Draw the net as a star from the source to each sink. Draw from centers of * |
| * blocks (or sub blocks in the case of IOs). */ |
| |
| for(inet = 0; inet < num_nets; inet++) |
| { |
| if(net[inet].is_global) |
| continue; /* Don't draw global nets. */ |
| |
| setcolor(net_color[inet]); |
| b1 = net[inet].node_block[0]; /* The DRIVER */ |
| get_block_center(b1, &x1, &y1); |
| |
| for(ipin = 1; ipin < (net[inet].num_sinks + 1); ipin++) |
| { |
| b2 = net[inet].node_block[ipin]; |
| get_block_center(b2, &x2, &y2); |
| drawline(x1, y1, x2, y2); |
| |
| /* Uncomment to draw a chain instead of a star. */ |
| /* x1 = x2; */ |
| /* y1 = y2; */ |
| } |
| } |
| } |
| |
| |
| static void |
| get_block_center(int bnum, |
| float *x, |
| float *y) |
| { |
| |
| /* This routine finds the center of block bnum in the current placement, * |
| * and returns it in *x and *y. This is used in routine shownets. */ |
| |
| int i, j, k; |
| float sub_tile_step; |
| |
| i = block[bnum].x; |
| j = block[bnum].y; |
| k = block[bnum].z; |
| |
| sub_tile_step = tile_width / block[bnum].type->capacity; |
| |
| if((i < 1) || (i > nx)) |
| { /* Left and right fringe */ |
| *x = tile_x[i] + (sub_tile_step * (k + 0.5)); |
| } |
| else |
| { |
| *x = tile_x[i] + (tile_width / 2.0); |
| } |
| |
| if((j < 1) || (j > ny)) |
| { /* Top and bottom fringe */ |
| *y = tile_y[j] + (sub_tile_step * (k + 0.5)); |
| } |
| else |
| { |
| *y = tile_y[j] + (tile_width / 2.0); |
| } |
| } |
| |
| |
| static void |
| draw_congestion(void) |
| { |
| |
| /* Draws all the overused routing resources (i.e. congestion) in RED. */ |
| |
| int inode, itrack; |
| |
| setcolor(RED); |
| setlinewidth(2); |
| |
| for(inode = 0; inode < num_rr_nodes; inode++) |
| { |
| if(rr_node[inode].occ > rr_node[inode].capacity) |
| { |
| switch (rr_node[inode].type) |
| { |
| case CHANX: |
| itrack = rr_node[inode].ptc_num; |
| draw_rr_chanx(inode, itrack); |
| break; |
| |
| case CHANY: |
| itrack = rr_node[inode].ptc_num; |
| draw_rr_chany(inode, itrack); |
| break; |
| |
| case IPIN: |
| case OPIN: |
| draw_rr_pin(inode, RED); |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| void |
| draw_rr(void) |
| { |
| |
| /* Draws the routing resources that exist in the FPGA, if the user wants * |
| * them drawn. */ |
| |
| int inode, itrack; |
| |
| if(draw_rr_toggle == DRAW_NO_RR) |
| { |
| setlinewidth(3); |
| drawroute(HIGHLIGHTED); |
| setlinewidth(0); |
| return; |
| } |
| |
| setlinestyle(SOLID); |
| setlinewidth(0); |
| |
| for(inode = 0; inode < num_rr_nodes; inode++) |
| { |
| switch (rr_node[inode].type) |
| { |
| |
| case SOURCE: |
| case SINK: |
| break; /* Don't draw. */ |
| |
| case CHANX: |
| setcolor(BLACK); |
| itrack = rr_node[inode].ptc_num; |
| draw_rr_chanx(inode, itrack); |
| draw_rr_edges(inode); |
| break; |
| |
| case CHANY: |
| setcolor(BLACK); |
| itrack = rr_node[inode].ptc_num; |
| draw_rr_chany(inode, itrack); |
| draw_rr_edges(inode); |
| break; |
| |
| case IPIN: |
| draw_rr_pin(inode, BLUE); |
| break; |
| |
| case OPIN: |
| draw_rr_pin(inode, RED); |
| setcolor(RED); |
| draw_rr_edges(inode); |
| break; |
| |
| default: |
| printf |
| ("Error in draw_rr: Unexpected rr_node type: %d.\n", |
| rr_node[inode].type); |
| exit(1); |
| } |
| } |
| |
| setlinewidth(3); |
| drawroute(HIGHLIGHTED); |
| setlinewidth(0); |
| } |
| |
| |
| static void |
| draw_rr_chanx(int inode, |
| int itrack) |
| { |
| |
| /* Draws an x-directed channel segment. */ |
| |
| enum |
| { BUFFSIZE = 80 }; |
| float x1, x2, y; |
| float y1, y2; /* UDSD by AY */ |
| int k; /* UDSD by AY */ |
| char str[BUFFSIZE]; |
| |
| /* Track 0 at bottom edge, closest to "owning" clb. */ |
| |
| x1 = tile_x[rr_node[inode].xlow]; |
| x2 = tile_y[rr_node[inode].xhigh] + tile_width; |
| y = tile_y[rr_node[inode].ylow] + tile_width + 1.0 + itrack; |
| drawline(x1, y, x2, y); |
| |
| /* UDSD by AY Start */ |
| y1 = y - 0.25; |
| y2 = y + 0.25; |
| |
| if(rr_node[inode].direction == INC_DIRECTION) |
| { |
| setlinewidth(2); |
| setcolor(YELLOW); |
| drawline(x1, y1, x1, y2); /* Draw a line at start of wire to indicate mux */ |
| |
| /* Mux balence numbers */ |
| setcolor(BLACK); |
| sprintf(str, "%d", rr_node[inode].fan_in); |
| drawtext(x1, y, str, 5); |
| |
| setcolor(BLACK); |
| setlinewidth(0); |
| draw_triangle_along_line(x2 - 0.15, y, x1, x2, y, y); |
| |
| setcolor(LIGHTGREY); |
| /* TODO: this looks odd, why does it ignore final block? does this mean nothing appears with L=1 ? */ |
| for(k = rr_node[inode].xlow; k < rr_node[inode].xhigh; k++) |
| { |
| x2 = tile_x[k] + tile_width; |
| draw_triangle_along_line(x2 - 0.15, y, x1, x2, y, y); |
| x2 = tile_x[k + 1]; |
| draw_triangle_along_line(x2 + 0.15, y, x1, x2, y, y); |
| } |
| setcolor(BLACK); |
| } |
| else if(rr_node[inode].direction == DEC_DIRECTION) |
| { |
| setlinewidth(2); |
| setcolor(YELLOW); |
| drawline(x2, y1, x2, y2); |
| |
| /* Mux balance numbers */ |
| setcolor(BLACK); |
| sprintf(str, "%d", rr_node[inode].fan_in); |
| drawtext(x2, y, str, 5); |
| |
| setlinewidth(0); |
| draw_triangle_along_line(x1 + 0.15, y, x2, x1, y, y); |
| setcolor(LIGHTGREY); |
| for(k = rr_node[inode].xhigh; k > rr_node[inode].xlow; k--) |
| { |
| x1 = tile_x[k]; |
| draw_triangle_along_line(x1 + 0.15, y, x2, x1, y, y); |
| x1 = tile_x[k - 1] + tile_width; |
| draw_triangle_along_line(x1 - 0.15, y, x2, x1, y, y); |
| } |
| setcolor(BLACK); |
| } |
| /* UDSD by AY End */ |
| } |
| |
| |
| static void |
| draw_rr_chany(int inode, |
| int itrack) |
| { |
| |
| /* Draws a y-directed channel segment. */ |
| enum |
| { BUFFSIZE = 80 }; |
| float x, y1, y2; |
| float x1, x2; /* UDSD by AY */ |
| int k; /* UDSD by AY */ |
| char str[BUFFSIZE]; |
| |
| /* Track 0 at left edge, closest to "owning" clb. */ |
| |
| x = tile_x[rr_node[inode].xlow] + tile_width + 1. + itrack; |
| y1 = tile_y[rr_node[inode].ylow]; |
| y2 = tile_y[rr_node[inode].yhigh] + tile_width; |
| drawline(x, y1, x, y2); |
| |
| /* UDSD by AY Start */ |
| x1 = x - 0.25; |
| x2 = x + 0.25; |
| if(rr_node[inode].direction == INC_DIRECTION) |
| { |
| setlinewidth(2); |
| setcolor(YELLOW); |
| drawline(x1, y1, x2, y1); |
| |
| /* UDSD Modifications by WMF Begin */ |
| setcolor(BLACK); |
| sprintf(str, "%d", rr_node[inode].fan_in); |
| drawtext(x, y1, str, 5); |
| setcolor(BLACK); |
| /* UDSD Modifications by WMF End */ |
| |
| setlinewidth(0); |
| draw_triangle_along_line(x, y2 - 0.15, x, x, y1, y2); |
| setcolor(LIGHTGREY); |
| for(k = rr_node[inode].ylow; k < rr_node[inode].yhigh; k++) |
| { |
| y2 = tile_y[k] + tile_width; |
| draw_triangle_along_line(x, y2 - 0.15, x, x, y1, y2); |
| y2 = tile_y[k + 1]; |
| draw_triangle_along_line(x, y2 + 0.15, x, x, y1, y2); |
| } |
| setcolor(BLACK); |
| } |
| else if(rr_node[inode].direction == DEC_DIRECTION) |
| { |
| setlinewidth(2); |
| setcolor(YELLOW); |
| drawline(x1, y2, x2, y2); |
| |
| /* UDSD Modifications by WMF Begin */ |
| setcolor(BLACK); |
| sprintf(str, "%d", rr_node[inode].fan_in); |
| drawtext(x, y2, str, 5); |
| setcolor(BLACK); |
| /* UDSD Modifications by WMF End */ |
| |
| setlinewidth(0); |
| draw_triangle_along_line(x, y1 + 0.15, x, x, y2, y1); |
| setcolor(LIGHTGREY); |
| for(k = rr_node[inode].yhigh; k > rr_node[inode].ylow; k--) |
| { |
| y1 = tile_y[k]; |
| draw_triangle_along_line(x, y1 + 0.15, x, x, y2, y1); |
| y1 = tile_y[k - 1] + tile_width; |
| draw_triangle_along_line(x, y1 - 0.15, x, x, y2, y1); |
| } |
| setcolor(BLACK); |
| } |
| /* UDSD by AY End */ |
| } |
| |
| |
| static void |
| draw_rr_edges(int inode) |
| { |
| |
| /* Draws all the edges that the user wants shown between inode and what it * |
| * connects to. inode is assumed to be a CHANX, CHANY, or OPIN. */ |
| |
| t_rr_type from_type, to_type; |
| int iedge, to_node, from_ptc_num, to_ptc_num; |
| short switch_type; |
| |
| from_type = rr_node[inode].type; |
| |
| if((draw_rr_toggle == DRAW_NODES_RR) || |
| (draw_rr_toggle == DRAW_NODES_AND_SBOX_RR && from_type == OPIN)) |
| { |
| return; /* Nothing to draw. */ |
| } |
| |
| from_ptc_num = rr_node[inode].ptc_num; |
| |
| for(iedge = 0; iedge < rr_node[inode].num_edges; iedge++) |
| { |
| to_node = rr_node[inode].edges[iedge]; |
| to_type = rr_node[to_node].type; |
| to_ptc_num = rr_node[to_node].ptc_num; |
| |
| switch (from_type) |
| { |
| |
| case OPIN: |
| switch (to_type) |
| { |
| case CHANX: |
| case CHANY: |
| setcolor(RED); |
| draw_pin_to_chan_edge(inode, to_node); |
| break; |
| |
| default: |
| printf |
| ("Error in draw_rr_edges: node %d (type: %d) connects to \n" |
| "node %d (type: %d).\n", inode, from_type, |
| to_node, to_type); |
| exit(1); |
| break; |
| } |
| break; |
| |
| case CHANX: /* from_type */ |
| switch (to_type) |
| { |
| case IPIN: |
| if(draw_rr_toggle == DRAW_NODES_AND_SBOX_RR) |
| { |
| break; |
| } |
| |
| setcolor(BLUE); |
| draw_pin_to_chan_edge(to_node, inode); |
| break; |
| |
| case CHANX: |
| setcolor(DARKGREEN); |
| switch_type = rr_node[inode].switches[iedge]; |
| draw_chanx_to_chanx_edge(inode, from_ptc_num, |
| to_node, to_ptc_num, |
| switch_type); |
| break; |
| |
| case CHANY: |
| setcolor(DARKGREEN); |
| switch_type = rr_node[inode].switches[iedge]; |
| draw_chanx_to_chany_edge(inode, from_ptc_num, |
| to_node, to_ptc_num, |
| FROM_X_TO_Y, |
| switch_type); |
| break; |
| |
| default: |
| printf |
| ("Error in draw_rr_edges: node %d (type: %d) connects to \n" |
| "node %d (type: %d).\n", inode, from_type, |
| to_node, to_type); |
| exit(1); |
| break; |
| } |
| break; |
| |
| |
| case CHANY: /* from_type */ |
| switch (to_type) |
| { |
| case IPIN: |
| if(draw_rr_toggle == DRAW_NODES_AND_SBOX_RR) |
| { |
| break; |
| } |
| |
| setcolor(BLUE); |
| draw_pin_to_chan_edge(to_node, inode); |
| break; |
| |
| case CHANX: |
| setcolor(DARKGREEN); |
| switch_type = rr_node[inode].switches[iedge]; |
| draw_chanx_to_chany_edge(to_node, to_ptc_num, |
| inode, from_ptc_num, |
| FROM_Y_TO_X, |
| switch_type); |
| break; |
| |
| case CHANY: |
| setcolor(DARKGREEN); |
| switch_type = rr_node[inode].switches[iedge]; |
| draw_chany_to_chany_edge(inode, from_ptc_num, |
| to_node, to_ptc_num, |
| switch_type); |
| break; |
| |
| default: |
| printf |
| ("Error in draw_rr_edges: node %d (type: %d) connects to \n" |
| "node %d (type: %d).\n", inode, from_type, |
| to_node, to_type); |
| exit(1); |
| break; |
| } |
| break; |
| |
| default: /* from_type */ |
| printf |
| ("Error: draw_rr_edges called with node %d of type %d.\n", |
| inode, from_type); |
| exit(1); |
| break; |
| } |
| } /* End of for each edge loop */ |
| } |
| |
| static void |
| draw_x(float x, |
| float y, |
| float size) |
| { |
| |
| /* Draws an X centered at (x,y). The width and height of the X are each * |
| * 2 * size. */ |
| |
| drawline(x - size, y + size, x + size, y - size); |
| drawline(x - size, y - size, x + size, y + size); |
| } |
| |
| |
| /* UDSD Modifications by WMF: Thank God Andy fixed this. */ |
| static void |
| draw_chanx_to_chany_edge(int chanx_node, |
| int chanx_track, |
| int chany_node, |
| int chany_track, |
| enum e_edge_dir edge_dir, |
| short switch_type) |
| { |
| |
| /* Draws an edge (SBOX connection) between an x-directed channel and a * |
| * y-directed channel. */ |
| |
| float x1, y1, x2, y2; |
| int chanx_y, chany_x, chanx_xlow, chany_ylow; |
| |
| chanx_y = rr_node[chanx_node].ylow; |
| chanx_xlow = rr_node[chanx_node].xlow; |
| chany_x = rr_node[chany_node].xlow; |
| chany_ylow = rr_node[chany_node].ylow; |
| |
| /* (x1,y1): point on CHANX segment, (x2,y2): point on CHANY segment. */ |
| |
| y1 = tile_y[chanx_y] + tile_width + 1. + chanx_track; |
| x2 = tile_x[chany_x] + tile_width + 1. + chany_track; |
| |
| if(chanx_xlow <= chany_x) |
| { /* Can draw connection going right */ |
| x1 = tile_x[chany_x] + tile_width; |
| /* UDSD by AY Start */ |
| if(rr_node[chanx_node].direction != BI_DIRECTION) |
| { |
| if(edge_dir == FROM_X_TO_Y) |
| { |
| if((chanx_track % 2) == 1) |
| { /* UDSD Modifications by WMF: If dec wire, then going left */ |
| x1 = tile_x[chany_x + 1]; |
| } |
| } |
| } |
| /* UDSD by AY End */ |
| } |
| else |
| { /* Must draw connection going left. */ |
| x1 = tile_x[chanx_xlow]; |
| } |
| |
| if(chany_ylow <= chanx_y) |
| { /* Can draw connection going up. */ |
| y2 = tile_y[chanx_y] + tile_width; |
| /* UDSD by AY Start */ |
| if(rr_node[chany_node].direction != BI_DIRECTION) |
| { |
| if(edge_dir == FROM_Y_TO_X) |
| { |
| if((chany_track % 2) == 1) |
| { /* UDSD Modifications by WMF: If dec wire, then going down */ |
| y2 = tile_y[chanx_y + 1]; |
| } |
| } |
| } |
| /* UDSD by AY End */ |
| } |
| else |
| { /* Must draw connection going down. */ |
| y2 = tile_y[chany_ylow]; |
| } |
| |
| drawline(x1, y1, x2, y2); |
| |
| if(draw_rr_toggle != DRAW_ALL_RR) |
| return; |
| |
| if(edge_dir == FROM_X_TO_Y) |
| draw_rr_switch(x1, y1, x2, y2, switch_inf[switch_type].buffered); |
| else |
| draw_rr_switch(x2, y2, x1, y1, switch_inf[switch_type].buffered); |
| } |
| |
| |
| static void |
| draw_chanx_to_chanx_edge(int from_node, |
| int from_track, |
| int to_node, |
| int to_track, |
| short switch_type) |
| { |
| |
| /* Draws a connection between two x-channel segments. Passing in the track * |
| * numbers allows this routine to be used for both rr_graph and routing * |
| * drawing. */ |
| |
| float x1, x2, y1, y2; |
| int from_y, to_y, from_xlow, to_xlow, from_xhigh, to_xhigh; |
| |
| from_y = rr_node[from_node].ylow; |
| from_xlow = rr_node[from_node].xlow; |
| from_xhigh = rr_node[from_node].xhigh; |
| to_y = rr_node[to_node].ylow; |
| to_xlow = rr_node[to_node].xlow; |
| to_xhigh = rr_node[to_node].xhigh; |
| |
| /* (x1, y1) point on from_node, (x2, y2) point on to_node. */ |
| |
| y1 = tile_y[from_y] + tile_width + 1 + from_track; |
| y2 = tile_y[to_y] + tile_width + 1 + to_track; |
| |
| |
| if(to_xhigh < from_xlow) |
| { /* From right to left */ |
| /* UDSD Note by WMF: could never happen for INC wires, unless U-turn. For DEC |
| * wires this handles well */ |
| x1 = tile_x[from_xlow]; |
| x2 = tile_x[to_xhigh] + tile_width; |
| } |
| else if(to_xlow > from_xhigh) |
| { /* From left to right */ |
| /* UDSD Note by WMF: could never happen for DEC wires, unless U-turn. For INC |
| * wires this handles well */ |
| x1 = tile_x[from_xhigh] + tile_width; |
| x2 = tile_x[to_xlow]; |
| } |
| |
| /* Segments overlap in the channel. Figure out best way to draw. Have to * |
| * make sure the drawing is symmetric in the from rr and to rr so the edges * |
| * will be drawn on top of each other for bidirectional connections. */ |
| |
| /* UDSD Modification by WMF Begin */ |
| else |
| { |
| if(rr_node[to_node].direction != BI_DIRECTION) |
| { |
| /* must connect to to_node's wire beginning at x2 */ |
| if(to_track % 2 == 0) |
| { /* INC wire starts at leftmost edge */ |
| assert(from_xlow < to_xlow); |
| x2 = tile_x[to_xlow]; |
| /* since no U-turns from_track must be INC as well */ |
| x1 = tile_x[to_xlow - 1] + tile_width; |
| } |
| else |
| { /* DEC wire starts at rightmost edge */ |
| assert(from_xhigh > to_xhigh); |
| x2 = tile_x[to_xhigh] + tile_width; |
| x1 = tile_x[to_xhigh + 1]; |
| } |
| } |
| else |
| { |
| if(to_xlow < from_xlow) |
| { /* Draw from left edge of one to other */ |
| x1 = tile_x[from_xlow]; |
| x2 = tile_x[from_xlow - 1] + tile_width; |
| } |
| else if(from_xlow < to_xlow) |
| { |
| x1 = tile_x[to_xlow - 1] + tile_width; |
| x2 = tile_x[to_xlow]; |
| } /* The following then is executed when from_xlow == to_xlow */ |
| else if(to_xhigh > from_xhigh) |
| { /* Draw from right edge of one to other */ |
| x1 = tile_x[from_xhigh] + tile_width; |
| x2 = tile_x[from_xhigh + 1]; |
| } |
| else if(from_xhigh > to_xhigh) |
| { |
| x1 = tile_x[to_xhigh + 1]; |
| x2 = tile_x[to_xhigh] + tile_width; |
| } |
| else |
| { /* Complete overlap: start and end both align. Draw outside the sbox */ |
| x1 = tile_x[from_xlow]; |
| x2 = tile_x[from_xlow] + tile_width; |
| } |
| } |
| } |
| /* UDSD Modification by WMF End */ |
| drawline(x1, y1, x2, y2); |
| |
| if(draw_rr_toggle == DRAW_ALL_RR) |
| draw_rr_switch(x1, y1, x2, y2, switch_inf[switch_type].buffered); |
| } |
| |
| |
| static void |
| draw_chany_to_chany_edge(int from_node, |
| int from_track, |
| int to_node, |
| int to_track, |
| short switch_type) |
| { |
| |
| /* Draws a connection between two y-channel segments. Passing in the track * |
| * numbers allows this routine to be used for both rr_graph and routing * |
| * drawing. */ |
| |
| float x1, x2, y1, y2; |
| int from_x, to_x, from_ylow, to_ylow, from_yhigh, to_yhigh; |
| |
| from_x = rr_node[from_node].xlow; |
| from_ylow = rr_node[from_node].ylow; |
| from_yhigh = rr_node[from_node].yhigh; |
| to_x = rr_node[to_node].xlow; |
| to_ylow = rr_node[to_node].ylow; |
| to_yhigh = rr_node[to_node].yhigh; |
| |
| /* (x1, y1) point on from_node, (x2, y2) point on to_node. */ |
| |
| x1 = tile_x[from_x] + tile_width + 1 + from_track; |
| x2 = tile_x[to_x] + tile_width + 1 + to_track; |
| |
| if(to_yhigh < from_ylow) |
| { /* From upper to lower */ |
| y1 = tile_y[from_ylow]; |
| y2 = tile_y[to_yhigh] + tile_width; |
| } |
| else if(to_ylow > from_yhigh) |
| { /* From lower to upper */ |
| y1 = tile_y[from_yhigh] + tile_width; |
| y2 = tile_y[to_ylow]; |
| } |
| |
| /* Segments overlap in the channel. Figure out best way to draw. Have to * |
| * make sure the drawing is symmetric in the from rr and to rr so the edges * |
| * will be drawn on top of each other for bidirectional connections. */ |
| |
| /* UDSD Modification by WMF Begin */ |
| else |
| { |
| if(rr_node[to_node].direction != BI_DIRECTION) |
| { |
| if(to_track % 2 == 0) |
| { /* INC wire starts at bottom edge */ |
| assert(from_ylow < to_ylow); |
| y2 = tile_y[to_ylow]; |
| /* since no U-turns from_track must be INC as well */ |
| y1 = tile_y[to_ylow - 1] + tile_width; |
| } |
| else |
| { /* DEC wire starts at top edge */ |
| if(!(from_yhigh > to_yhigh)) |
| { |
| printf |
| ("from_yhigh (%d) !> to_yhigh (%d).\n", |
| from_yhigh, to_yhigh); |
| printf |
| ("from is (%d, %d) to (%d, %d) track %d.\n", |
| rr_node[from_node].xhigh, |
| rr_node[from_node].yhigh, |
| rr_node[from_node].xlow, |
| rr_node[from_node].ylow, |
| rr_node[from_node].ptc_num); |
| printf |
| ("to is (%d, %d) to (%d, %d) track %d.\n", |
| rr_node[to_node].xhigh, |
| rr_node[to_node].yhigh, |
| rr_node[to_node].xlow, |
| rr_node[to_node].ylow, |
| rr_node[to_node].ptc_num); |
| exit(1); |
| } |
| y2 = tile_y[to_yhigh] + tile_width; |
| y1 = tile_y[to_yhigh + 1]; |
| } |
| } |
| else |
| { |
| if(to_ylow < from_ylow) |
| { /* Draw from bottom edge of one to other. */ |
| y1 = tile_y[from_ylow]; |
| y2 = tile_y[from_ylow - 1] + tile_width; |
| } |
| else if(from_ylow < to_ylow) |
| { |
| y1 = tile_y[to_ylow - 1] + tile_width; |
| y2 = tile_y[to_ylow]; |
| } |
| else if(to_yhigh > from_yhigh) |
| { /* Draw from top edge of one to other. */ |
| y1 = tile_y[from_yhigh] + tile_width; |
| y2 = tile_y[from_yhigh + 1]; |
| } |
| else if(from_yhigh > to_yhigh) |
| { |
| y1 = tile_y[to_yhigh + 1]; |
| y2 = tile_y[to_yhigh] + tile_width; |
| } |
| else |
| { /* Complete overlap: start and end both align. Draw outside the sbox */ |
| y1 = tile_y[from_ylow]; |
| y2 = tile_y[from_ylow] + tile_width; |
| } |
| } |
| } |
| /* UDSD Modification by WMF End */ |
| drawline(x1, y1, x2, y2); |
| |
| if(draw_rr_toggle == DRAW_ALL_RR) |
| draw_rr_switch(x1, y1, x2, y2, switch_inf[switch_type].buffered); |
| } |
| |
| |
| static void |
| draw_rr_switch(float from_x, |
| float from_y, |
| float to_x, |
| float to_y, |
| boolean buffered) |
| { |
| |
| /* Draws a buffer (triangle) or pass transistor (circle) on the edge * |
| * connecting from to to, depending on the status of buffered. The drawing * |
| * is closest to the from_node, since it reflects the switch type of from. */ |
| |
| const float switch_rad = 0.15; |
| float magnitude, xcen, ycen, xdelta, ydelta, xbaseline, ybaseline; |
| float xunit, yunit; |
| t_point poly[3]; |
| |
| xcen = from_x + (to_x - from_x) / 10.; |
| ycen = from_y + (to_y - from_y) / 10.; |
| |
| if(!buffered) |
| { /* Draw a circle for a pass transistor */ |
| drawarc(xcen, ycen, switch_rad, 0., 360.); |
| } |
| else |
| { /* Buffer */ |
| xdelta = to_x - from_x; |
| ydelta = to_y - from_y; |
| magnitude = sqrt(xdelta * xdelta + ydelta * ydelta); |
| xunit = xdelta / magnitude; |
| yunit = ydelta / magnitude; |
| poly[0].x = xcen + xunit * switch_rad; |
| poly[0].y = ycen + yunit * switch_rad; |
| xbaseline = xcen - xunit * switch_rad; |
| ybaseline = ycen - yunit * switch_rad; |
| |
| /* Recall: perpendicular vector to the unit vector along the switch (xv, yv) * |
| * is (yv, -xv). */ |
| |
| poly[1].x = xbaseline + yunit * switch_rad; |
| poly[1].y = ybaseline - xunit * switch_rad; |
| poly[2].x = xbaseline - yunit * switch_rad; |
| poly[2].y = ybaseline + xunit * switch_rad; |
| fillpoly(poly, 3); |
| } |
| } |
| |
| |
| static void |
| draw_rr_pin(int inode, |
| enum color_types color) |
| { |
| |
| /* Draws an IPIN or OPIN rr_node. Note that the pin can appear on more * |
| * than one side of a clb. Also note that this routine can change the * |
| * current color to BLACK. */ |
| |
| int ipin, i, j, iside, iclass, ioff; |
| float xcen, ycen; |
| char str[BUFSIZE]; |
| t_type_ptr type; |
| |
| i = rr_node[inode].xlow; |
| j = rr_node[inode].ylow; |
| ipin = rr_node[inode].ptc_num; |
| type = grid[i][j].type; |
| ioff = grid[i][j].offset; |
| |
| setcolor(color); |
| iclass = type->pin_class[ipin]; |
| /* TODO: This is where we can hide fringe physical pins and also identify globals (hide, color, show) */ |
| for(iside = 0; iside < 4; iside++) |
| { |
| if(type->pinloc[grid[i][j].offset][iside][ipin]) |
| { /* Pin exists on this side. */ |
| get_rr_pin_draw_coords(inode, iside, ioff, &xcen, &ycen); |
| fillrect(xcen - pin_size, ycen - pin_size, |
| xcen + pin_size, ycen + pin_size); |
| sprintf(str, "%d", ipin); |
| setcolor(BLACK); |
| drawtext(xcen, ycen, str, 2 * pin_size); |
| setcolor(color); |
| } |
| } |
| } |
| |
| |
| static void |
| get_rr_pin_draw_coords(int inode, |
| int iside, |
| int ioff, |
| float *xcen, |
| float *ycen) |
| { |
| |
| /* Returns the coordinates at which the center of this pin should be drawn. * |
| * inode gives the node number, and iside gives the side of the clb or pad * |
| * the physical pin is on. */ |
| |
| int i, j, k, ipin, pins_per_sub_tile; |
| float offset, xc, yc, step; |
| t_type_ptr type; |
| |
| i = rr_node[inode].xlow; |
| j = rr_node[inode].ylow + ioff; /* Need correct tile of block */ |
| |
| xc = tile_x[i]; |
| yc = tile_y[j]; |
| |
| ipin = rr_node[inode].ptc_num; |
| type = grid[i][j].type; |
| pins_per_sub_tile = grid[i][j].type->num_pins / grid[i][j].type->capacity; |
| k = ipin / pins_per_sub_tile; |
| |
| /* Since pins numbers go across all sub_tiles in a block in order |
| * we can treat as a block box for this step */ |
| |
| /* For each sub_tile we need and extra padding space */ |
| step = (float)(tile_width) / (float)(type->num_pins + type->capacity); |
| offset = (ipin + k + 1) * step; |
| |
| switch (iside) |
| { |
| case LEFT: |
| yc += offset; |
| break; |
| |
| case RIGHT: |
| xc += tile_width; |
| yc += offset; |
| break; |
| |
| case BOTTOM: |
| xc += offset; |
| break; |
| |
| case TOP: |
| xc += offset; |
| yc += tile_width; |
| break; |
| |
| default: |
| printf("Error in get_rr_pin_draw_coords: Unexpected iside %d.\n", |
| iside); |
| exit(1); |
| break; |
| } |
| |
| *xcen = xc; |
| *ycen = yc; |
| } |
| |
| |
| static void |
| drawroute(enum e_draw_net_type draw_net_type) |
| { |
| |
| /* Draws the nets in the positions fixed by the router. If draw_net_type is * |
| * ALL_NETS, draw all the nets. If it is HIGHLIGHTED, draw only the nets * |
| * that are not coloured black (useful for drawing over the rr_graph). */ |
| |
| /* Next free track in each channel segment if routing is GLOBAL */ |
| |
| static int **chanx_track = NULL; /* [1..nx][0..ny] */ |
| static int **chany_track = NULL; /* [0..nx][1..ny] */ |
| |
| int inet, i, j, inode, prev_node, prev_track, itrack; |
| short switch_type; |
| struct s_trace *tptr; |
| t_rr_type rr_type, prev_type; |
| |
| |
| if(draw_route_type == GLOBAL) |
| { |
| /* Allocate some temporary storage if it's not already available. */ |
| if(chanx_track == NULL) |
| { |
| chanx_track = |
| (int **)alloc_matrix(1, nx, 0, ny, sizeof(int)); |
| } |
| |
| if(chany_track == NULL) |
| { |
| chany_track = |
| (int **)alloc_matrix(0, nx, 1, ny, sizeof(int)); |
| } |
| |
| for(i = 1; i <= nx; i++) |
| for(j = 0; j <= ny; j++) |
| chanx_track[i][j] = (-1); |
| |
| for(i = 0; i <= nx; i++) |
| for(j = 1; j <= ny; j++) |
| chany_track[i][j] = (-1); |
| } |
| |
| setlinestyle(SOLID); |
| |
| /* Now draw each net, one by one. */ |
| |
| for(inet = 0; inet < num_nets; inet++) |
| { |
| if(net[inet].is_global) /* Don't draw global nets. */ |
| continue; |
| |
| if(trace_head[inet] == NULL) /* No routing. Skip. (Allows me to draw */ |
| continue; /* partially complete routes). */ |
| |
| if(draw_net_type == HIGHLIGHTED && net_color[inet] == BLACK) |
| continue; |
| |
| setcolor(net_color[inet]); |
| tptr = trace_head[inet]; /* SOURCE to start */ |
| inode = tptr->index; |
| rr_type = rr_node[inode].type; |
| |
| |
| for(;;) |
| { |
| prev_node = inode; |
| prev_type = rr_type; |
| switch_type = tptr->iswitch; |
| tptr = tptr->next; |
| inode = tptr->index; |
| rr_type = rr_node[inode].type; |
| |
| switch (rr_type) |
| { |
| |
| case OPIN: |
| draw_rr_pin(inode, net_color[inet]); |
| break; |
| |
| case IPIN: |
| draw_rr_pin(inode, net_color[inet]); |
| prev_track = |
| get_track_num(prev_node, chanx_track, |
| chany_track); |
| draw_pin_to_chan_edge(inode, prev_node); |
| break; |
| |
| case CHANX: |
| if(draw_route_type == GLOBAL) |
| chanx_track[rr_node[inode]. |
| xlow][rr_node[inode].ylow]++; |
| |
| itrack = |
| get_track_num(inode, chanx_track, |
| chany_track); |
| draw_rr_chanx(inode, itrack); |
| |
| switch (prev_type) |
| { |
| |
| case CHANX: |
| prev_track = |
| get_track_num(prev_node, chanx_track, |
| chany_track); |
| draw_chanx_to_chanx_edge(prev_node, |
| prev_track, |
| inode, itrack, |
| switch_type); |
| break; |
| |
| case CHANY: |
| prev_track = |
| get_track_num(prev_node, chanx_track, |
| chany_track); |
| draw_chanx_to_chany_edge(inode, itrack, |
| prev_node, |
| prev_track, |
| FROM_Y_TO_X, |
| switch_type); |
| break; |
| |
| case OPIN: |
| draw_pin_to_chan_edge(prev_node, inode); |
| break; |
| |
| default: |
| printf |
| ("Error in drawroute: Unexpected connection from an \n" |
| "rr_node of type %d to one of type %d.\n", |
| prev_type, rr_type); |
| exit(1); |
| } |
| |
| break; |
| |
| case CHANY: |
| if(draw_route_type == GLOBAL) |
| chany_track[rr_node[inode]. |
| xlow][rr_node[inode].ylow]++; |
| |
| itrack = |
| get_track_num(inode, chanx_track, |
| chany_track); |
| draw_rr_chany(inode, itrack); |
| |
| switch (prev_type) |
| { |
| |
| case CHANX: |
| prev_track = |
| get_track_num(prev_node, chanx_track, |
| chany_track); |
| draw_chanx_to_chany_edge(prev_node, |
| prev_track, |
| inode, itrack, |
| FROM_X_TO_Y, |
| switch_type); |
| break; |
| |
| case CHANY: |
| prev_track = |
| get_track_num(prev_node, chanx_track, |
| chany_track); |
| draw_chany_to_chany_edge(prev_node, |
| prev_track, |
| inode, itrack, |
| switch_type); |
| break; |
| |
| case OPIN: |
| draw_pin_to_chan_edge(prev_node, inode); |
| |
| break; |
| |
| default: |
| printf |
| ("Error in drawroute: Unexpected connection from an \n" |
| "rr_node of type %d to one of type %d.\n", |
| prev_type, rr_type); |
| exit(1); |
| } |
| |
| break; |
| |
| default: |
| break; |
| |
| } |
| |
| if(rr_type == SINK) |
| { /* Skip the next segment */ |
| tptr = tptr->next; |
| if(tptr == NULL) |
| break; |
| inode = tptr->index; |
| rr_type = rr_node[inode].type; |
| } |
| |
| } /* End loop over traceback. */ |
| } /* End for (each net) */ |
| } |
| |
| |
| static int |
| get_track_num(int inode, |
| int **chanx_track, |
| int **chany_track) |
| { |
| |
| /* Returns the track number of this routing resource node. */ |
| |
| int i, j; |
| t_rr_type rr_type; |
| |
| if(draw_route_type == DETAILED) |
| return (rr_node[inode].ptc_num); |
| |
| /* GLOBAL route stuff below. */ |
| |
| rr_type = rr_node[inode].type; |
| i = rr_node[inode].xlow; /* NB: Global rr graphs must have only unit */ |
| j = rr_node[inode].ylow; /* length channel segments. */ |
| |
| switch (rr_type) |
| { |
| case CHANX: |
| return (chanx_track[i][j]); |
| |
| case CHANY: |
| return (chany_track[i][j]); |
| |
| default: |
| printf |
| ("Error in get_track_num: unexpected node type %d for node %d." |
| "\n", rr_type, inode); |
| exit(1); |
| } |
| } |
| |
| |
| static void |
| highlight_blocks(float x, |
| float y) |
| { |
| |
| /* This routine is called when the user clicks in the graphics area. * |
| * It determines if a clb was clicked on. If one was, it is * |
| * highlighted in green, it's fanin nets and clbs are highlighted in * |
| * blue and it's fanout is highlighted in red. If no clb was * |
| * clicked on (user clicked on white space) any old highlighting is * |
| * removed. Note that even though global nets are not drawn, their * |
| * fanins and fanouts are highlighted when you click on a block * |
| * attached to them. */ |
| |
| int i, j, k, hit, bnum, ipin, netnum, fanblk; |
| int iclass; |
| float io_step; |
| t_type_ptr type; |
| char msg[BUFSIZE]; |
| |
| deselect_all(); |
| |
| hit = 0; |
| for(i = 0; i <= (nx + 1) && !hit; i++) |
| { |
| if(x <= tile_x[i] + tile_width) |
| { |
| if(x >= tile_x[i]){ |
| for(j = 0; j <= (ny + 1) && !hit; j++) |
| { |
| if(grid[i][j].offset != 0) |
| continue; |
| type = grid[i][j].type; |
| if(y <= tile_y[j + type->height - 1] + tile_width) |
| { |
| if(y >= tile_y[j]) |
| hit = 1; |
| } |
| } |
| |
| } |
| } |
| } |
| i--; |
| j--; |
| |
| if(!hit) |
| { |
| update_message(default_message); |
| drawscreen(); |
| return; |
| } |
| type = grid[i][j].type; |
| hit = 0; |
| |
| if(EMPTY_TYPE == type) |
| { |
| update_message(default_message); |
| drawscreen(); |
| return; |
| } |
| |
| /* The user selected the clb at location (i,j). */ |
| io_step = tile_width / type->capacity; |
| |
| if((i < 1) || (i > nx)) /* Vertical columns of IOs */ |
| k = (int)((y - tile_y[j]) / io_step); |
| else |
| k = (int)((x - tile_x[i]) / io_step); |
| |
| assert(k < type->capacity); |
| if(grid[i][j].blocks[k] == EMPTY) |
| { |
| update_message(default_message); |
| drawscreen(); |
| return; |
| } |
| bnum = grid[i][j].blocks[k]; |
| |
| /* Highlight fanin and fanout. */ |
| |
| for(k = 0; k < type->num_pins; k++) |
| { /* Each pin on a FB */ |
| netnum = block[bnum].nets[k]; |
| |
| if(netnum == OPEN) |
| continue; |
| |
| iclass = type->pin_class[k]; |
| |
| if(type->class_inf[iclass].type == DRIVER) |
| { /* Fanout */ |
| net_color[netnum] = RED; |
| for(ipin = 1; ipin <= net[netnum].num_sinks; ipin++) |
| { |
| fanblk = net[netnum].node_block[ipin]; |
| block_color[fanblk] = RED; |
| } |
| } |
| else |
| { /* This net is fanin to the block. */ |
| net_color[netnum] = BLUE; |
| fanblk = net[netnum].node_block[0]; /* DRIVER to net */ |
| block_color[fanblk] = BLUE; |
| } |
| } |
| |
| block_color[bnum] = GREEN; /* Selected block. */ |
| |
| sprintf(msg, "Block %d (%s) at (%d, %d) selected.", bnum, |
| block[bnum].name, i, j); |
| update_message(msg); |
| drawscreen(); /* Need to erase screen. */ |
| } |
| |
| |
| static void |
| deselect_all(void) |
| { |
| /* Sets the color of all clbs and nets to the default. */ |
| |
| int i; |
| |
| /* Create some colour highlighting */ |
| for(i = 0; i < num_blocks; i++) { |
| if(block[i].type->index < 3) { |
| block_color[i] = LIGHTGREY; |
| } else if(block[i].type->index < 3 + MAX_BLOCK_COLOURS) { |
| block_color[i] = BISQUE + MAX_BLOCK_COLOURS + block[i].type->index - 3; |
| } else { |
| block_color[i] = BISQUE + 2 * MAX_BLOCK_COLOURS - 1; |
| } |
| } |
| |
| for(i = 0; i < num_nets; i++) |
| net_color[i] = BLACK; |
| } |
| |
| |
| /* UDSD by AY Start */ |
| static void |
| draw_triangle_along_line(float xend, |
| float yend, |
| float x1, |
| float x2, |
| float y1, |
| float y2) |
| { |
| float switch_rad = 0.15; |
| float xdelta, ydelta; |
| float magnitude; |
| float xunit, yunit; |
| float xbaseline, ybaseline; |
| t_point poly[3]; |
| |
| xdelta = x2 - x1; |
| ydelta = y2 - y1; |
| magnitude = sqrt(xdelta * xdelta + ydelta * ydelta); |
| xunit = xdelta / magnitude; |
| yunit = ydelta / magnitude; |
| |
| poly[0].x = xend + xunit * switch_rad; |
| poly[0].y = yend + yunit * switch_rad; |
| xbaseline = xend - xunit * switch_rad; |
| ybaseline = yend - yunit * switch_rad; |
| poly[1].x = xbaseline + yunit * switch_rad; |
| poly[1].y = ybaseline - xunit * switch_rad; |
| poly[2].x = xbaseline - yunit * switch_rad; |
| poly[2].y = ybaseline + xunit * switch_rad; |
| |
| fillpoly(poly, 3); |
| } |
| |
| |
| static void |
| draw_pin_to_chan_edge(int pin_node, |
| int chan_node) |
| { |
| |
| /* This routine draws an edge from the pin_node to the chan_node (CHANX or * |
| * CHANY). The connection is made to the nearest end of the track instead * |
| * of perpundicular to the track to symbolize a single-drive connection. * |
| * If mark_conn is TRUE, draw a box where the pin connects to the track * |
| * (useful for drawing the rr graph) */ |
| |
| /* TODO: Fix this for global routing, currently for detailed only */ |
| |
| t_rr_type chan_type; |
| int grid_x, grid_y, pin_num, chan_xlow, chan_ylow, ioff, height; |
| float x1, x2, y1, y2; |
| int start, end, i; |
| int itrack; |
| float xend, yend; |
| float draw_pin_off; |
| enum e_direction direction; |
| enum e_side iside; |
| t_type_ptr type; |
| |
| direction = rr_node[chan_node].direction; |
| grid_x = rr_node[pin_node].xlow; |
| grid_y = rr_node[pin_node].ylow; |
| pin_num = rr_node[pin_node].ptc_num; |
| chan_type = rr_node[chan_node].type; |
| itrack = rr_node[chan_node].ptc_num; |
| type = grid[grid_x][grid_y].type; |
| |
| ioff = grid[grid_x][grid_y].offset; |
| /* large block begins at primary tile (offset == 0) */ |
| grid_y = grid_y - ioff; |
| height = grid[grid_x][grid_y].type->height; |
| chan_ylow = rr_node[chan_node].ylow; |
| chan_xlow = rr_node[chan_node].xlow; |
| start = -1; |
| end = -1; |
| |
| |
| switch (chan_type) |
| { |
| |
| case CHANX: |
| start = rr_node[chan_node].xlow; |
| end = rr_node[chan_node].xhigh; |
| if(is_opin(pin_num, type)) |
| { |
| if(direction == INC_DIRECTION) |
| { |
| end = rr_node[chan_node].xlow; |
| } |
| else if(direction == DEC_DIRECTION) |
| { |
| start = rr_node[chan_node].xhigh; |
| } |
| } |
| |
| start = max(start, grid_x); |
| end = min(end, grid_x); /* Width is 1 always */ |
| assert(end >= start); /* Make sure we are nearby */ |
| |
| if((grid_y + height - 1) == chan_ylow) |
| { |
| iside = TOP; |
| ioff = height - 1; |
| draw_pin_off = pin_size; |
| } |
| else |
| { |
| assert((grid_y - 1) == chan_ylow); |
| |
| iside = BOTTOM; |
| ioff = 0; |
| draw_pin_off = -pin_size; |
| } |
| assert(grid[grid_x][grid_y].type->pinloc[ioff][iside][pin_num]); |
| |
| get_rr_pin_draw_coords(pin_node, iside, ioff, &x1, &y1); |
| y1 += draw_pin_off; |
| |
| y2 = tile_y[rr_node[chan_node].ylow] + tile_width + 1. + itrack; |
| x2 = x1; |
| if(is_opin(pin_num, type)) |
| { |
| if(direction == INC_DIRECTION) |
| { |
| x2 = tile_x[rr_node[chan_node].xlow]; |
| } |
| else if(direction == DEC_DIRECTION) |
| { |
| x2 = tile_x[rr_node[chan_node].xhigh] + |
| tile_width; |
| } |
| } |
| break; |
| |
| case CHANY: |
| start = rr_node[chan_node].ylow; |
| end = rr_node[chan_node].yhigh; |
| if(is_opin(pin_num, type)) |
| { |
| if(direction == INC_DIRECTION) |
| { |
| end = rr_node[chan_node].ylow; |
| } |
| else if(direction == DEC_DIRECTION) |
| { |
| start = rr_node[chan_node].yhigh; |
| } |
| } |
| |
| start = max(start, grid_y); |
| end = min(end, (grid_y + height - 1)); /* Width is 1 always */ |
| assert(end >= start); /* Make sure we are nearby */ |
| |
| if((grid_x) == chan_xlow) |
| { |
| iside = RIGHT; |
| draw_pin_off = pin_size; |
| } |
| else |
| { |
| assert((grid_x - 1) == chan_xlow); |
| iside = LEFT; |
| draw_pin_off = -pin_size; |
| } |
| for(i = start; i <= end; i++) |
| { |
| ioff = i - grid_y; |
| assert(ioff >= 0 && ioff < type->height); |
| /* Once we find the location, break out, this will leave ioff pointing |
| * to the correct offset. If an offset is not found, the assertion after |
| * this will fail. With the correct routing graph, the assertion will not |
| * be triggered. This also takes care of connecting a wire once to multiple |
| * physical pins on the same side. */ |
| if(grid[grid_x][grid_y].type-> |
| pinloc[ioff][iside][pin_num]) |
| { |
| break; |
| } |
| } |
| assert(grid[grid_x][grid_y].type->pinloc[ioff][iside][pin_num]); |
| |
| get_rr_pin_draw_coords(pin_node, iside, ioff, &x1, &y1); |
| x1 += draw_pin_off; |
| |
| x2 = tile_x[chan_xlow] + tile_width + 1 + itrack; |
| y2 = y1; |
| if(is_opin(pin_num, type)) |
| { |
| if(direction == INC_DIRECTION) |
| { |
| y2 = tile_y[rr_node[chan_node].ylow]; |
| } |
| else if(direction == DEC_DIRECTION) |
| { |
| y2 = tile_y[rr_node[chan_node].yhigh] + |
| tile_width; |
| } |
| } |
| break; |
| |
| default: |
| printf |
| ("Error in draw_pin_to_chan_edge: invalid channel node %d.\n", |
| chan_node); |
| exit(1); |
| } |
| |
| drawline(x1, y1, x2, y2); |
| if(direction == BI_DIRECTION || !is_opin(pin_num, type)) |
| { |
| draw_x(x2, y2, 0.7 * pin_size); |
| } |
| else |
| { |
| xend = x2 + (x1 - x2) / 10.; |
| yend = y2 + (y1 - y2) / 10.; |
| draw_triangle_along_line(xend, yend, x1, x2, y1, y2); |
| } |
| } |
| |
| /* UDSD by AY End */ |
