place_macro.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	s_pl_macro_member
struct	s_pl_macro

Macros
#define	PALCE_MACRO_H

Typedefs
typedef struct s_pl_macro_member	t_pl_macro_member
typedef struct s_pl_macro	t_pl_macro

Functions
int	alloc_and_load_placement_macros (t_direct_inf *directs, int num_directs, t_pl_macro **chains)
void	get_imacro_from_iblk (int *imacro, int iblk, t_pl_macro *macros, int num_macros)
void	free_placement_macros_structs (void)

Macro Definition Documentation

#define PALCE_MACRO_H

Definition at line 136 of file place_macro.h.

Typedef Documentation

typedef struct s_pl_macro t_pl_macro

typedef struct s_pl_macro_member t_pl_macro_member

Function Documentation

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

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:

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: