SRC/vpr_utils.c

Go to the documentation of this file.

#include <assert.h>
#include "util.h"
#include "vpr_types.h"
#include "globals.h"
#include "vpr_utils.h"

/* This module contains subroutines that are used in several unrelated parts *
 * of VPR.  They are VPR-specific utility routines.                          */


/******************** Subroutine definitions ********************************/

/* Points the grid structure back to the blocks list */
void
sync_grid_to_blocks(IN int num_blocks,
                    IN const struct s_block block_list[],
                    IN int nx,
                    IN int ny,
                    INOUT struct s_grid_tile **grid)
{
    int i, j, k;

    /* Reset usage and allocate blocks list if needed */
    for(j = 0; j <= (ny + 1); ++j)
        {
            for(i = 0; i <= (nx + 1); ++i)
                {
                    grid[i][j].usage = 0;
                    if(grid[i][j].type)
                        {
                            /* If already allocated, leave it since size doesn't change */
                            if(NULL == grid[i][j].blocks)
                                {
                                    grid[i][j].blocks =
                                        (int *)my_malloc(sizeof(int) *
                                                         grid[i][j].type->
                                                         capacity);

                                    /* Set them as unconnected */
                                    for(k = 0; k < grid[i][j].type->capacity;
                                        ++k)
                                        {
                                            grid[i][j].blocks[k] = OPEN;
                                        }
                                }
                        }
                }
        }

    /* Go through each block */
    for(i = 0; i < num_blocks; ++i)
        {
            /* Check range of block coords */
            if(block[i].x < 0 || block[i].x > (nx + 1) ||
               block[i].y < 0
               || (block[i].y + block[i].type->height - 1) > (ny + 1)
               || block[i].z < 0 || block[i].z > (block[i].type->capacity))
                {
                    printf(ERRTAG
                           "Block %d is at invalid location (%d, %d, %d)\n",
                           i, block[i].x, block[i].y, block[i].z);
                    exit(1);
                }

            /* Check types match */
            if(block[i].type != grid[block[i].x][block[i].y].type)
                {
                    printf(ERRTAG "A block is in a grid location "
                           "(%d x %d) with a conflicting type.\n", block[i].x,
                           block[i].y);
                    exit(1);
                }

            /* Check already in use */
            if(OPEN != grid[block[i].x][block[i].y].blocks[block[i].z])
                {
                    printf(ERRTAG
                           "Location (%d, %d, %d) is used more than once\n",
                           block[i].x, block[i].y, block[i].z);
                    exit(1);
                }

            if(grid[block[i].x][block[i].y].offset != 0)
                {
                    printf(ERRTAG
                           "Large block not aligned in placment for block %d at (%d, %d, %d)",
                           i, block[i].x, block[i].y, block[i].z);
                    exit(1);
                }

            /* Set the block */
            for(j = 0; j < block[i].type->height; j++)
                {
                    grid[block[i].x][block[i].y + j].blocks[block[i].z] = i;
                    grid[block[i].x][block[i].y + j].usage++;
                    assert(grid[block[i].x][block[i].y + j].offset == j);
                }
        }
}

/* This function updates the nets list to point back to blocks list */
void
sync_nets_to_blocks(IN int num_blocks,
                    IN const struct s_block block_list[],
                    IN int num_nets,
                    INOUT struct s_net net_list[])
{
    int i, j, k, l;
    t_type_ptr cur_type;

    /* Count the number of sinks for each net */
    for(i = 0; i < num_nets; ++i)
        {
            for(j = 0; j < num_blocks; ++j)
                {
                    cur_type = block_list[j].type;
                    for(k = 0; k < cur_type->num_pins; ++k)
                        {
                            if(block_list[j].nets[k] == i)
                                {
                                    if(RECEIVER ==
                                       cur_type->class_inf[cur_type->
                                                           pin_class[k]].type)
                                        {
                                            ++net_list[i].num_sinks;
                                        }
                                }
                        }
                }
        }

    /* Alloc and load block lists of nets */
    for(i = 0; i < num_nets; ++i)
        {
            /* The list should be num_sinks + 1 driver. Re-alloc if already allocated. */
            if(net_list[i].node_block)
                {
                    free(net_list[i].node_block);
                }
            net_list[i].node_block =
                (int *)my_malloc(sizeof(int) * (net_list[i].num_sinks + 1));
            if(net_list[i].node_block_pin)
                {
                    free(net_list[i].node_block_pin);
                }
            net_list[i].node_block_pin =
                (int *)my_malloc(sizeof(int) * (net_list[i].num_sinks + 1));

            l = 1;              /* First sink goes at position 1, since 0 is for driver */

            for(j = 0; j < num_blocks; ++j)
                {
                    cur_type = block_list[j].type;
                    for(k = 0; k < cur_type->num_pins; ++k)
                        {
                            if(block_list[j].nets[k] == i)
                                {
                                    if(RECEIVER ==
                                       cur_type->class_inf[cur_type->
                                                           pin_class[k]].type)
                                        {
                                            net_list[i].node_block[l] = j;
                                            net_list[i].node_block_pin[l] = k;
                                            ++l;
                                        }
                                    else
                                        {
                                            assert(DRIVER ==
                                                   cur_type->
                                                   class_inf[cur_type->
                                                             pin_class[k]].
                                                   type);
                                            net_list[i].node_block[0] = j;
                                            net_list[i].node_block_pin[0] = k;
                                        }
                                }
                        }
                }
        }
}

boolean
is_opin(int ipin,
        t_type_ptr type)
{

/* Returns TRUE if this clb pin is an output, FALSE otherwise. */

    int iclass;

    iclass = type->pin_class[ipin];

    if(type->class_inf[iclass].type == DRIVER)
        return (TRUE);
    else
        return (FALSE);
}

void
get_class_range_for_block(IN int iblk,
                          OUT int *class_low,
                          OUT int *class_high)
{
/* Assumes that the placement has been done so each block has a set of pins allocated to it */
    t_type_ptr type;

    type = block[iblk].type;
    assert(type->num_class % type->capacity == 0);
    *class_low = block[iblk].z * (type->num_class / type->capacity);
    *class_high =
        (block[iblk].z + 1) * (type->num_class / type->capacity) - 1;
}


void
load_one_fb_fanout_count(t_subblock * subblock_inf,
                         int num_subblocks,
                         int *num_uses_of_fb_ipin,
                         int **num_uses_of_sblk_opin,
                         int iblk)
{

/* Loads the fanout counts for one block (iblk).  */
    t_type_ptr type = block[iblk].type;
    int isub, ipin, conn_pin, opin;
    int internal_sub, internal_pin;

        /* Reset ipin counts */
        for(ipin = 0; ipin < type->num_pins; ipin++)
        {
            num_uses_of_fb_ipin[ipin] = 0;
        }

    /* First pass, reset fanout counts */
    for(isub = 0; isub < num_subblocks; isub++)
        {
            for(opin = 0; opin < type->max_subblock_outputs; opin++)
                {
                    num_uses_of_sblk_opin[isub][opin] = 0;
                }
        }

    for(isub = 0; isub < num_subblocks; isub++)
        {
            /* Is the subblock output connected to a FB opin that actually goes *
             * somewhere?  Necessary to check that the FB opin connects to      *
             * something because some logic blocks result in netlists where      *
             * subblock outputs being automatically hooked to a FB opin under   *
             * all conditions.                                                   */
            for(opin = 0; opin < type->max_subblock_outputs; opin++)
                {
                    conn_pin = subblock_inf[isub].outputs[opin];
                    if(conn_pin != OPEN)
                        {
                            if(block[iblk].nets[conn_pin] != OPEN)
                                {       /* FB output is used */
                                    num_uses_of_sblk_opin[isub][opin]++;
                                }
                        }
                }

            for(ipin = 0; ipin < type->max_subblock_inputs; ipin++)
                {
                    conn_pin = subblock_inf[isub].inputs[ipin];

                    if(conn_pin != OPEN)
                        {
                            if(conn_pin < type->num_pins)
                                {       /* Driven by FB ipin */
                                    num_uses_of_fb_ipin[conn_pin]++;
                                }
                            else
                                {       /* Driven by sblk output in same fb */
                                    internal_sub =
                                        (conn_pin -
                                         type->num_pins) /
                                        type->max_subblock_outputs;
                                    internal_pin =
                                        (conn_pin -
                                         type->num_pins) %
                                        type->max_subblock_outputs;
                                    num_uses_of_sblk_opin[internal_sub]
                                        [internal_pin]++;
                                }
                        }
                }               /* End for each sblk ipin */

            conn_pin = subblock_inf[isub].clock;        /* Now do clock pin */

            if(conn_pin != OPEN)
                {
                    if(conn_pin < type->num_pins)
                        {       /* Driven by FB ipin */
                            num_uses_of_fb_ipin[conn_pin]++;
                        }
                    else
                        {       /* Driven by sblk output in same clb */
                            internal_sub =
                                (conn_pin -
                                 type->num_pins) / type->max_subblock_outputs;
                            internal_pin =
                                (conn_pin -
                                 type->num_pins) % type->max_subblock_outputs;
                            num_uses_of_sblk_opin[internal_sub]
                                [internal_pin]++;
                        }
                }

        }                       /* End for each subblock */
}

---