#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include "util.h"
#include "vpr_types.h"
#include "physical_types.h"
#include "globals.h"
#include "place.h"
#include "read_xml_arch_file.h"
#include "ReadOptions.h"
#include "place_macro.h"
#include "vpr_utils.h"

Include dependency graph for place_macro.c:

Functions
static void	find_all_the_macro (int num_of_macro, int pl_macro_member_blk_num_of_this_blk, int pl_macro_idirect, int pl_macro_num_members, int **pl_macro_member_blk_num)

static void	free_imacro_from_iblk (void)

static void	alloc_and_load_imacro_from_iblk (t_pl_macro *macros, int num_macros)

int	alloc_and_load_placement_macros (t_direct_inf directs, int num_directs, t_pl_macro *macros)

void	get_imacro_from_iblk (int imacro, int iblk, t_pl_macro macros, int num_macros)

void	free_placement_macros_structs (void)

Variables
static int **	f_idirect_from_blk_pin = NULL

static int **	f_direct_type_from_blk_pin = NULL

static int *	f_imacro_from_iblk = NULL

Function Documentation

static void alloc_and_load_imacro_from_iblk	(	t_pl_macro *	macros,
		int	num_macros
	)

static

Definition at line 394 of file place_macro.c.

                                                                                  {
 
     /* Allocates and loads imacro_from_iblk array.                           *
      *                                                                       *
      * The array is freed in free_placement_structs()                        */
 
     int * temp_imacro_from_iblk = NULL;
     int imacro, imember, iblk;
 
     /* Allocate and initialize the values to OPEN (-1). */
     temp_imacro_from_iblk = (int *)my_malloc(num_blocks * sizeof(int));
     for(iblk = 0; iblk < num_blocks; iblk ++) {
         temp_imacro_from_iblk[iblk] = OPEN;
     }
     
     /* Load the values */
     for (imacro = 0; imacro < num_macros; imacro++) {
         for (imember = 0; imember < macros[imacro].num_blocks; imember++) {
             iblk = macros[imacro].members[imember].blk_index;
             temp_imacro_from_iblk[iblk] = imacro;
         }
     }
     
     /* Sets the file_scope variables to point at the arrays. */
     f_imacro_from_iblk = temp_imacro_from_iblk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int alloc_and_load_placement_macros	(	t_direct_inf *	directs,
		int	num_directs,
		t_pl_macro **	macros
	)

Definition at line 281 of file place_macro.c.

                                                                                                  {
     
     /* This function allocates and loads the macros placement macros   *
      * and returns the total number of macros in 2 steps.              *
      *   1) Allocate temporary data structure for maximum possible     *
      *      size and loops through all the blocks storing the data     *
      *      relevant to the carry chains. At the same time, also count *
      *      the amount of memory required for the actual variables.    *
      *   2) Allocate the actual variables with the exact amount of     *
      *      memory. Then loads the data from the temporary data        *
      *       structures before freeing them.                           *
      *                                                                 *
      * For pl_macro_member_blk_num, allocate for the first dimension   *
      * only at first. Allocate for the second dimemsion when I know    *
      * the size. Otherwise, the array is going to be of size           *
      * num_blocks^2 (There are big benckmarks VPR that have num_blocks *
      * in the 100k's range).                                           *
      *                                                                 *
      * The placement macro array is freed by the caller(s).            */
 
     /* Declaration of local variables */
     int imacro, imember, num_macro;
     int *pl_macro_idirect, *pl_macro_num_members, **pl_macro_member_blk_num, 
             *pl_macro_member_blk_num_of_this_blk;
     
     t_pl_macro * macro = NULL;
     
     /* Sets up the required variables. */
     alloc_and_load_idirect_from_blk_pin(directs, num_directs, 
             &f_idirect_from_blk_pin, &f_direct_type_from_blk_pin);
 
     /* Allocate maximum memory for temporary variables. */
     pl_macro_num_members = (int *) my_calloc (num_blocks , sizeof(int));
     pl_macro_idirect = (int *) my_calloc (num_blocks , sizeof(int));
     pl_macro_member_blk_num = (int **) my_calloc (num_blocks , sizeof(int*));
     pl_macro_member_blk_num_of_this_blk = (int *) my_calloc (num_blocks , sizeof(int));
 
     /* Compute required size:                                                *
      * Go through all the pins with possible direct connections in           *
      * f_idirect_from_blk_pin. Count the number of heads (which is the same  *
      * as the number macros) and also the length of each macro               *
      * Head - blocks with to_pin OPEN and from_pin connected                 *
      * Tail - blocks with to_pin connected and from_pin OPEN                 */
     num_macro = 0;
     find_all_the_macro (&num_macro, pl_macro_member_blk_num_of_this_blk, 
             pl_macro_idirect, pl_macro_num_members, pl_macro_member_blk_num);
 
     /* Allocate the memories for the macro. */
     macro = (t_pl_macro *) my_malloc (num_macro * sizeof(t_pl_macro));
 
     /* Allocate the memories for the chaim members.             *
      * Load the values from the temporary data structures.      */
     for (imacro = 0; imacro < num_macro; imacro++) {
         macro[imacro].num_blocks = pl_macro_num_members[imacro];
         macro[imacro].members = (t_pl_macro_member *) my_malloc 
                                         (macro[imacro].num_blocks * sizeof(t_pl_macro_member));
 
         /* Load the values for each member of the macro */
         for (imember = 0; imember < macro[imacro].num_blocks; imember++) {
             macro[imacro].members[imember].x_offset = imember * directs[pl_macro_idirect[imacro]].x_offset;
             macro[imacro].members[imember].y_offset = imember * directs[pl_macro_idirect[imacro]].y_offset;
             macro[imacro].members[imember].z_offset = directs[pl_macro_idirect[imacro]].z_offset;
             macro[imacro].members[imember].blk_index = pl_macro_member_blk_num[imacro][imember];
         }
     }
 
     /* Frees up the temporary data structures. */
     free(pl_macro_num_members);
     free(pl_macro_idirect);
     for(imacro=0; imacro < num_macro; imacro++) {
         free(pl_macro_member_blk_num[imacro]);
     }
     free(pl_macro_member_blk_num);
     free(pl_macro_member_blk_num_of_this_blk);
     
     /* Returns the pointer to the macro by reference. */
     *macros = macro;
     return (num_macro);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void find_all_the_macro	(	int *	num_of_macro,
		int *	pl_macro_member_blk_num_of_this_blk,
		int *	pl_macro_idirect,
		int *	pl_macro_num_members,
		int **	pl_macro_member_blk_num
	)

static

Definition at line 183 of file place_macro.c.

                                                                                             {
 
     /* Compute required size:                                                *
      * Go through all the pins with possible direct connections in           *
      * f_idirect_from_blk_pin. Count the number of heads (which is the same  *
      * as the number macros) and also the length of each macro               *
      * Head - blocks with to_pin OPEN and from_pin connected                 *
      * Tail - blocks with to_pin connected and from_pin OPEN                 */
 
     int iblk, from_iblk_pin, to_iblk_pin, from_inet, to_inet, from_idirect, to_idirect, 
             from_src_or_sink, to_src_or_sink;
     int next_iblk, curr_iblk, next_inet, curr_inet;
     int num_blk_pins, num_macro; 
     int imember;
 
     num_macro = 0;
     for (iblk = 0; iblk < num_blocks; iblk++) {
 
         num_blk_pins = block[iblk].type->num_pins;
         for (to_iblk_pin = 0; to_iblk_pin < num_blk_pins; to_iblk_pin++) {
             
             to_inet = block[iblk].nets[to_iblk_pin];
             to_idirect = f_idirect_from_blk_pin[block[iblk].type->index][to_iblk_pin];
             to_src_or_sink = f_direct_type_from_blk_pin[block[iblk].type->index][to_iblk_pin];
             
             // Find to_pins (SINKs) with possible direct connection but are not 
             // connected to any net (Possible head of macro)
             if ( to_src_or_sink == SINK && to_idirect != OPEN && to_inet == OPEN ) {
 
                 for (from_iblk_pin = 0; from_iblk_pin < num_blk_pins; from_iblk_pin++) {
                     from_inet = block[iblk].nets[from_iblk_pin];
                     from_idirect = f_idirect_from_blk_pin[block[iblk].type->index][from_iblk_pin];
                     from_src_or_sink = f_direct_type_from_blk_pin[block[iblk].type->index][from_iblk_pin];
 
                     // Find from_pins with the same possible direct connection that are connected.
                     // Confirmed head of macro
                     if ( from_src_or_sink == SOURCE && to_idirect == from_idirect && from_inet != OPEN) {
                         
                         // Mark down that this is the first block in the macro
                         pl_macro_member_blk_num_of_this_blk[0] = iblk;
                         pl_macro_idirect[num_macro] = to_idirect;
                         
                         // Increment the num_member count.
                         pl_macro_num_members[num_macro]++;
                         
                         // Also find out how many members are in the macros, 
                         // there are at least 2 members - 1 head and 1 tail.
                         
                         // Initialize the variables
                         next_inet = from_inet;
                         next_iblk = iblk;
 
                         // Start finding the other members
                         while (next_inet != OPEN) {
 
                             curr_iblk = next_iblk;
                             curr_inet = next_inet;
                             
                             // Assume that carry chains only has 1 sink - direct connection
                             assert(clb_net[curr_inet].num_sinks == 1);
                             next_iblk = clb_net[curr_inet].node_block[1];
                             
                             // Assume that the from_iblk_pin index is the same for the next block
                             assert (f_idirect_from_blk_pin[block[next_iblk].type->index][from_iblk_pin] == from_idirect
                                     && f_direct_type_from_blk_pin[block[next_iblk].type->index][from_iblk_pin] == SOURCE);
                             next_inet = block[next_iblk].nets[from_iblk_pin];
 
                             // Mark down this block as a member of the macro
                             imember = pl_macro_num_members[num_macro];
                             pl_macro_member_blk_num_of_this_blk[imember] = next_iblk;
 
                             // Increment the num_member count.
                             pl_macro_num_members[num_macro]++;
 
                         } // Found all the members of this macro at this point
 
                         // Allocate the second dimension of the blk_num array since I now know the size
                         pl_macro_member_blk_num[num_macro] = 
                                 (int *) my_calloc (pl_macro_num_members[num_macro] , sizeof(int));
                         // Copy the data from the temporary array to the newly allocated array.
                         for (imember = 0; imember < pl_macro_num_members[num_macro]; imember ++)
                             pl_macro_member_blk_num[num_macro][imember] = pl_macro_member_blk_num_of_this_blk[imember];
 
                         // Increment the macro count
                         num_macro ++;
 
                     } // Do nothing if the from_pins does not have same possible direct connection.
                 } // Finish going through all the pins for from_pins.
             } // Do nothing if the to_pins does not have same possible direct connection.
         } // Finish going through all the pins for to_pins.
     } // Finish going through all blocks.
     
     // Now, all the data is readily stored in the temporary data structures.
     *num_of_macro = num_macro;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_imacro_from_iblk ( void )

static

Definition at line 380 of file place_macro.c.

                                         {
 
     /* Frees the f_imacro_from_iblk array.                    *
      *                                                        *
      * This function is called when the arrays are freed in   *
      * free_placement_structs()                               */
 
     if (f_imacro_from_iblk != NULL) {
         free(f_imacro_from_iblk);
         f_imacro_from_iblk = NULL;
     }
 
 }

Here is the caller graph for this function:

void free_placement_macros_structs ( void )

Definition at line 421 of file place_macro.c.

                                          {
 
     /* This function frees up all the static data structures used. */
 
     // This frees up the two arrays and set the pointers to NULL
     int itype;
     if ( f_idirect_from_blk_pin != NULL ) {
         for (itype = 1; itype < num_types; itype++) {
             free(f_idirect_from_blk_pin[itype]);
         }
         free(f_idirect_from_blk_pin);
         f_idirect_from_blk_pin = NULL;
     }
 
     if ( f_direct_type_from_blk_pin != NULL ) {
         for (itype = 1; itype < num_types; itype++) {
             free(f_direct_type_from_blk_pin[itype]);
         }
         free(f_direct_type_from_blk_pin);
         f_direct_type_from_blk_pin = NULL;
     }
 
     // This frees up the imacro from iblk mapping array.
     free_imacro_from_iblk();
     
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_imacro_from_iblk	(	int *	imacro,
		int	iblk,
		t_pl_macro *	macros,
		int	num_macros
	)

Definition at line 362 of file place_macro.c.

                                                                                        {
 
     /* This mapping is needed for fast lookup's whether the block with index *
      * iblk belongs to a placement macro or not.                             *
      *                                                                       *
      * The array f_imacro_from_iblk is used for the mapping for speed reason *
      * [0...num_blocks-1]                                                    */
 
     /* If the array is not allocated and loaded, allocate it.                */ 
     if (f_imacro_from_iblk == NULL) {
         alloc_and_load_imacro_from_iblk(macros, num_macros);
     }
 
     /* Return the imacro for the block. */
     *imacro = f_imacro_from_iblk[iblk];
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

int** f_direct_type_from_blk_pin = NULL

static

Definition at line 164 of file place_macro.c.

int** f_idirect_from_blk_pin = NULL

static

Definition at line 157 of file place_macro.c.

int* f_imacro_from_iblk = NULL

static

Definition at line 169 of file place_macro.c.

Functions

Variables

Function Documentation

Variable Documentation