#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <map>
#include "util.h"
#include "vpr_types.h"
#include "globals.h"
#include "cluster.h"
#include "heapsort.h"
#include "output_clustering.h"
#include "output_blif.h"
#include "SetupGrid.h"
#include "read_xml_arch_file.h"
#include "cluster_legality.h"
#include "path_delay2.h"
#include "path_delay.h"
#include "vpr_utils.h"
#include "cluster_placement.h"
#include "ReadOptions.h"

Include dependency graph for cluster.c:

Data Structures
struct	s_molecule_link

Macros
#define	AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC 2 /* Maximum relative number of pins that can exceed input pins before giving up */

#define	AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST 5 /* Maximum constant number of pins that can exceed input pins before giving up */

#define	AAPACK_MAX_FEASIBLE_BLOCK_ARRAY_SIZE 30 /* This value is used to determine the max size of the priority queue for candidates that pass the early filter legality test but not the more detailed routing test */

#define	AAPACK_MAX_NET_SINKS_IGNORE 256 /* The packer looks at all sinks of a net when deciding what next candidate block to pack, for high-fanout nets, this is too runtime costly for marginal benefit, thus ignore those high fanout nets */

#define	AAPACK_MAX_HIGH_FANOUT_EXPLORE 10 /* For high-fanout nets that are ignored, consider a maximum of this many nets */

#define	SCALE_NUM_PATHS

#define	SCALE_DISTANCE_VAL

#define	MARKED_FRAC 2

Enumerations
enum	e_gain_update { GAIN, NO_GAIN }

enum	e_feasibility { FEASIBLE, INFEASIBLE }

enum	e_gain_type { HILL_CLIMBING, NOT_HILL_CLIMBING }

enum	e_removal_policy { REMOVE_CLUSTERED, LEAVE_CLUSTERED }

enum	e_net_relation_to_clustered_block { INPUT, OUTPUT }

enum	e_detailed_routing_stages { E_DETAILED_ROUTE_AT_END_ONLY = 0, E_DETAILED_ROUTE_FOR_EACH_ATOM, E_DETAILED_ROUTE_END }

Functions
static void	check_clocks (boolean *is_clock)

static boolean	is_logical_blk_in_pb (int iblk, t_pb *pb)

static void	add_molecule_to_pb_stats_candidates (t_pack_molecule molecule, std::map< int, float > &gain, t_pb pb)

static void	alloc_and_init_clustering (boolean global_clocks, float alpha, float beta, int max_cluster_size, int max_molecule_inputs, int max_pb_depth, int max_models, t_cluster_placement_stats cluster_placement_stats, t_pb_graph_node primitives_list, t_pack_molecule molecules_head, int num_molecules)

static void	free_pb_stats_recursive (t_pb *pb)

static void	try_update_lookahead_pins_used (t_pb *cur_pb)

static void	reset_lookahead_pins_used (t_pb *cur_pb)

static void	compute_and_mark_lookahead_pins_used (int ilogical_block)

static void	compute_and_mark_lookahead_pins_used_for_pin (t_pb_graph_pin pb_graph_pin, t_pb primitive_pb, int inet)

static void	commit_lookahead_pins_used (t_pb *cur_pb)

static boolean	check_lookahead_pins_used (t_pb *cur_pb)

static boolean	primitive_feasible (int iblk, t_pb *cur_pb)

static boolean	primitive_type_and_memory_feasible (int iblk, const t_pb_type cur_pb_type, t_pb memory_class_pb, int sibling_memory_blk)

static t_pack_molecule *	get_molecule_by_num_ext_inputs (INP enum e_packer_algorithm packer_algorithm, INOUTP t_pb cur_pb, INP int ext_inps, INP enum e_removal_policy remove_flag, INP t_cluster_placement_stats cluster_placement_stats_ptr)

static t_pack_molecule *	get_free_molecule_with_most_ext_inputs_for_cluster (INP enum e_packer_algorithm packer_algorithm, INOUTP t_pb cur_pb, INP t_cluster_placement_stats cluster_placement_stats_ptr)

static t_pack_molecule *	get_seed_logical_molecule_with_most_ext_inputs (int max_molecule_inputs)

static enum e_block_pack_status	try_pack_molecule (INOUTP t_cluster_placement_stats cluster_placement_stats_ptr, INP t_pack_molecule molecule, INOUTP t_pb_graph_node *primitives_list, INOUTP t_pb pb, INP int max_models, INP int max_cluster_size, INP int clb_index, INP int max_nets_in_pb_type, INP int detailed_routing_stage)

static enum e_block_pack_status	try_place_logical_block_rec (INP t_pb_graph_node pb_graph_node, INP int ilogical_block, INP t_pb cb, OUTP t_pb *parent, INP int max_models, INP int max_cluster_size, INP int clb_index, INP int max_nets_in_pb_type, INP t_cluster_placement_stats cluster_placement_stats_ptr, INP boolean is_root_of_chain, INP t_pb_graph_pin *chain_root_pin)

static void	revert_place_logical_block (INP int ilogical_block, INP int max_models)

static void	update_connection_gain_values (int inet, int clustered_block, t_pb *cur_pb, enum e_net_relation_to_clustered_block net_relation_to_clustered_block)

static void	update_timing_gain_values (int inet, int clustered_block, t_pb cur_pb, enum e_net_relation_to_clustered_block net_relation_to_clustered_block, t_slack slacks)

static void	mark_and_update_partial_gain (int inet, enum e_gain_update gain_flag, int clustered_block, int port_on_clustered_block, int pin_on_clustered_block, boolean timing_driven, boolean connection_driven, enum e_net_relation_to_clustered_block net_relation_to_clustered_block, t_slack *slacks)

static void	update_total_gain (float alpha, float beta, boolean timing_driven, boolean connection_driven, boolean global_clocks, t_pb *pb)

static void	update_cluster_stats (INP t_pack_molecule molecule, INP int clb_index, INP boolean is_clock, INP boolean global_clocks, INP float alpha, INP float beta, INP boolean timing_driven, INP boolean connection_driven, INP t_slack *slacks)

static void	start_new_cluster (INP t_cluster_placement_stats cluster_placement_stats, INP t_pb_graph_node primitives_list, INP const t_arch arch, INOUTP t_block new_cluster, INP int clb_index, INP t_pack_molecule molecule, INP float aspect, INOUTP int num_used_instances_type, INOUTP int num_instances_type, INP int num_models, INP int max_cluster_size, INP int max_nets_in_pb_type, INP int detailed_routing_stage)

static t_pack_molecule *	get_highest_gain_molecule (INP enum e_packer_algorithm packer_algorithm, INOUTP t_pb cur_pb, INP enum e_gain_type gain_mode, INP t_cluster_placement_stats cluster_placement_stats_ptr)

static t_pack_molecule *	get_molecule_for_cluster (INP enum e_packer_algorithm packer_algorithm, INP t_pb cur_pb, INP boolean allow_unrelated_clustering, INOUTP int num_unrelated_clustering_attempts, INP t_cluster_placement_stats *cluster_placement_stats_ptr)

static void	alloc_and_load_cluster_info (INP int num_clb, INOUTP t_block *clb)

static void	check_clustering (int num_clb, t_block clb, boolean is_clock)

static void	check_cluster_logical_blocks (t_pb pb, boolean blocks_checked)

static t_pack_molecule *	get_most_critical_seed_molecule (int *indexofcrit)

static float	get_molecule_gain (t_pack_molecule *molecule, std::map< int, float > &blk_gain)

static int	compare_molecule_gain (const void a, const void b)

static int	get_net_corresponding_to_pb_graph_pin (t_pb cur_pb, t_pb_graph_pin pb_graph_pin)

static void	print_block_criticalities (const char *fname)

void	do_clustering (const t_arch arch, t_pack_molecule molecule_head, int num_models, boolean global_clocks, boolean is_clock, boolean hill_climbing_flag, char out_fname, boolean timing_driven, enum e_cluster_seed cluster_seed_type, float alpha, float beta, int recompute_timing_after, float block_delay, float intra_cluster_net_delay, float inter_cluster_net_delay, float aspect, boolean allow_unrelated_clustering, boolean allow_early_exit, boolean connection_driven, enum e_packer_algorithm packer_algorithm, t_timing_inf timing_inf)

static void	alloc_and_load_pb_stats (t_pb *pb, int max_models, int max_nets_in_pb_type)

static void	start_new_cluster (INP t_cluster_placement_stats cluster_placement_stats, INOUTP t_pb_graph_node primitives_list, INP const t_arch arch, INOUTP t_block new_cluster, INP int clb_index, INP t_pack_molecule molecule, INP float aspect, INOUTP int num_used_instances_type, INOUTP int num_instances_type, INP int num_models, INP int max_cluster_size, INP int max_nets_in_pb_type, INP int detailed_routing_stage)

static t_pack_molecule *	get_molecule_for_cluster (INP enum e_packer_algorithm packer_algorithm, INOUTP t_pb cur_pb, INP boolean allow_unrelated_clustering, INOUTP int num_unrelated_clustering_attempts, INP t_cluster_placement_stats *cluster_placement_stats_ptr)

Variables
static struct s_molecule_link *	unclustered_list_head

int	unclustered_list_head_size

static struct s_molecule_link *	memory_pool

static int *	net_output_feeds_driving_block_input

static float *	block_criticality = NULL

static int *	critindexarray = NULL

Macro Definition Documentation

#define AAPACK_MAX_FEASIBLE_BLOCK_ARRAY_SIZE 30 /* This value is used to determine the max size of the priority queue for candidates that pass the early filter legality test but not the more detailed routing test */

Definition at line 34 of file cluster.c.

#define AAPACK_MAX_HIGH_FANOUT_EXPLORE 10 /* For high-fanout nets that are ignored, consider a maximum of this many nets */

Definition at line 36 of file cluster.c.

#define AAPACK_MAX_NET_SINKS_IGNORE 256 /* The packer looks at all sinks of a net when deciding what next candidate block to pack, for high-fanout nets, this is too runtime costly for marginal benefit, thus ignore those high fanout nets */

Definition at line 35 of file cluster.c.

#define AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST 5 /* Maximum constant number of pins that can exceed input pins before giving up */

Definition at line 32 of file cluster.c.

#define AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC 2 /* Maximum relative number of pins that can exceed input pins before giving up */

Definition at line 31 of file cluster.c.

#define MARKED_FRAC 2

Definition at line 86 of file cluster.c.

#define SCALE_DISTANCE_VAL

Value:

1e-4  /*this value is used as a multiplier to assign a    *
                  *slightly higher criticality value to nets that    *
                  *are otherwise equal but one is  farther           *
                  *from sources (the farther one being made slightly *
                  *more critical)                                    */

Definition at line 47 of file cluster.c.

#define SCALE_NUM_PATHS

Value:

1e-2     /*this value is used as a multiplier to assign a    *
                  *slightly higher criticality value to nets that    *
                  *affect a large number of critical paths versus    *
                  *nets that do not have such a broad effect.        *
                  *Note that this multiplier is intentionally very   * 
                  *small compared to the total criticality because   *
                  *we want to make sure that vpack_net criticality is      *
                  *primarily determined by slacks, with this acting  *
                  *only as a tie-breaker between otherwise equal nets*/

Definition at line 38 of file cluster.c.

Enumeration Type Documentation

enum e_detailed_routing_stages

Enumerator
E_DETAILED_ROUTE_AT_END_ONLY
E_DETAILED_ROUTE_FOR_EACH_ATOM
E_DETAILED_ROUTE_END

Definition at line 70 of file cluster.c.

                                {
     E_DETAILED_ROUTE_AT_END_ONLY = 0, E_DETAILED_ROUTE_FOR_EACH_ATOM, E_DETAILED_ROUTE_END
 };

enum e_feasibility

Enumerator
FEASIBLE
INFEASIBLE

Definition at line 56 of file cluster.c.

                    {
     FEASIBLE, INFEASIBLE
 };

enum e_gain_type

Enumerator
HILL_CLIMBING
NOT_HILL_CLIMBING

Definition at line 59 of file cluster.c.

                  {
     HILL_CLIMBING, NOT_HILL_CLIMBING
 };

enum e_gain_update

Enumerator
GAIN
NO_GAIN

Definition at line 53 of file cluster.c.

                    {
     GAIN, NO_GAIN
 };

enum e_net_relation_to_clustered_block

Enumerator
INPUT
OUTPUT

Definition at line 66 of file cluster.c.

                                        {
     INPUT, OUTPUT
 };

enum e_removal_policy

Enumerator
REMOVE_CLUSTERED
LEAVE_CLUSTERED

Definition at line 62 of file cluster.c.

                       {
     REMOVE_CLUSTERED, LEAVE_CLUSTERED
 };

Function Documentation

static void add_molecule_to_pb_stats_candidates	(	t_pack_molecule *	molecule,
		std::map< int, float > &	gain,
		t_pb *	pb
	)

static

Definition at line 664 of file cluster.c.

                                             {
     int i, j;
 
     for (i = 0; i < pb->pb_stats->num_feasible_blocks; i++) {
         if (pb->pb_stats->feasible_blocks[i] == molecule) {
             return; /* already in queue, do nothing */
         }
     }
 
     if (pb->pb_stats->num_feasible_blocks
             >= AAPACK_MAX_FEASIBLE_BLOCK_ARRAY_SIZE - 1) {
         /* maximum size for array, remove smallest gain element and sort */
         if (get_molecule_gain(molecule, gain)
                 > get_molecule_gain(pb->pb_stats->feasible_blocks[0], gain)) {
             /* single loop insertion sort */
             for (j = 0; j < pb->pb_stats->num_feasible_blocks - 1; j++) {
                 if (get_molecule_gain(molecule, gain)
                         <= get_molecule_gain(
                                 pb->pb_stats->feasible_blocks[j + 1], gain)) {
                     pb->pb_stats->feasible_blocks[j] = molecule;
                     break;
                 } else {
                     pb->pb_stats->feasible_blocks[j] =
                             pb->pb_stats->feasible_blocks[j + 1];
                 }
             }
             if (j == pb->pb_stats->num_feasible_blocks - 1) {
                 pb->pb_stats->feasible_blocks[j] = molecule;
             }
         }
     } else {
         /* Expand array and single loop insertion sort */
         for (j = pb->pb_stats->num_feasible_blocks - 1; j >= 0; j--) {
             if (get_molecule_gain(pb->pb_stats->feasible_blocks[j], gain)
                     > get_molecule_gain(molecule, gain)) {
                 pb->pb_stats->feasible_blocks[j + 1] =
                         pb->pb_stats->feasible_blocks[j];
             } else {
                 pb->pb_stats->feasible_blocks[j + 1] = molecule;
                 break;
             }
         }
         if (j < 0) {
             pb->pb_stats->feasible_blocks[0] = molecule;
         }
         pb->pb_stats->num_feasible_blocks++;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void alloc_and_init_clustering	(	boolean	global_clocks,
		float	alpha,
		float	beta,
		int	max_cluster_size,
		int	max_molecule_inputs,
		int	max_pb_depth,
		int	max_models,
		t_cluster_placement_stats **	cluster_placement_stats,
		t_pb_graph_node ***	primitives_list,
		t_pack_molecule *	molecules_head,
		int	num_molecules
	)

static

cluster_placement_stats = alloc_and_load_cluster_placement_stats();

Definition at line 715 of file cluster.c.

                            {
 
     /* Allocates the main data structures used for clustering and properly *
      * initializes them.                                                   */
 
     int i, ext_inps, ipin, driving_blk, inet;
     struct s_molecule_link *next_ptr;
     t_pack_molecule *cur_molecule;
     t_pack_molecule **molecule_array;
     int max_molecule_size;
 
     alloc_and_load_cluster_legality_checker();
     /**cluster_placement_stats = alloc_and_load_cluster_placement_stats();*/
 
     for (i = 0; i < num_logical_blocks; i++) {
         logical_block[i].clb_index = NO_CLUSTER;
     }
 
     /* alloc and load list of molecules to pack */
     unclustered_list_head = (struct s_molecule_link *) my_calloc(
             max_molecule_inputs + 1, sizeof(struct s_molecule_link));
     unclustered_list_head_size = max_molecule_inputs + 1;
 
     for (i = 0; i <= max_molecule_inputs; i++) {
         unclustered_list_head[i].next = NULL;
     }
 
     molecule_array = (t_pack_molecule **) my_malloc(
             num_molecules * sizeof(t_pack_molecule*));
     cur_molecule = molecules_head;
     for (i = 0; i < num_molecules; i++) {
         assert(cur_molecule != NULL);
         molecule_array[i] = cur_molecule;
         cur_molecule = cur_molecule->next;
     }
     assert(cur_molecule == NULL);
     qsort((void*) molecule_array, num_molecules, sizeof(t_pack_molecule*),
             compare_molecule_gain);
 
     memory_pool = (struct s_molecule_link *) my_malloc(
             num_molecules * sizeof(struct s_molecule_link));
     next_ptr = memory_pool;
 
     for (i = 0; i < num_molecules; i++) {
         ext_inps = molecule_array[i]->num_ext_inputs;
         next_ptr->moleculeptr = molecule_array[i];
         next_ptr->next = unclustered_list_head[ext_inps].next;
         unclustered_list_head[ext_inps].next = next_ptr;
         next_ptr++;
     }
     free(molecule_array);
 
     /* alloc and load net info */
     net_output_feeds_driving_block_input = (int *) my_malloc(
             num_logical_nets * sizeof(int));
 
     for (inet = 0; inet < num_logical_nets; inet++) {
         net_output_feeds_driving_block_input[inet] = 0;
         driving_blk = vpack_net[inet].node_block[0];
         for (ipin = 1; ipin <= vpack_net[inet].num_sinks; ipin++) {
             if (vpack_net[inet].node_block[ipin] == driving_blk) {
                 net_output_feeds_driving_block_input[inet]++;
             }
         }
     }
 
     /* alloc and load cluster placement info */
     *cluster_placement_stats = alloc_and_load_cluster_placement_stats();
 
     /* alloc array that will store primitives that a molecule gets placed to, 
      primitive_list is referenced by index, for example a logical block in index 2 of a molecule matches to a primitive in index 2 in primitive_list
      this array must be the size of the biggest molecule
      */
     max_molecule_size = 1;
     cur_molecule = molecules_head;
     while (cur_molecule != NULL) {
         if (cur_molecule->num_blocks > max_molecule_size) {
             max_molecule_size = cur_molecule->num_blocks;
         }
         cur_molecule = cur_molecule->next;
     }
     *primitives_list = (t_pb_graph_node **)my_calloc(max_molecule_size, sizeof(t_pb_graph_node *));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void alloc_and_load_cluster_info	(	INP int	num_clb,
		INOUTP t_block *	clb
	)

static

Definition at line 2176 of file cluster.c.

                                                                               {
 
     /* Loads all missing clustering info necessary to complete clustering.  */
     int i, j, i_clb, node_index, ipin, iclass;
     int inport, outport, clockport;
 
     const t_pb_type * pb_type;
     t_pb *pb;
 
     for (i_clb = 0; i_clb < num_clb; i_clb++) {
         rr_node = clb[i_clb].pb->rr_graph;
         pb_type = clb[i_clb].pb->pb_graph_node->pb_type;
         pb = clb[i_clb].pb;
 
         clb[i_clb].nets = (int*)my_malloc(clb[i_clb].type->num_pins * sizeof(int));
         for (i = 0; i < clb[i_clb].type->num_pins; i++) {
             clb[i_clb].nets[i] = OPEN;
         }
 
         inport = outport = clockport = 0;
         ipin = 0;
         /* Assume top-level pb and clb share a one-to-one connection */
         for (i = 0; i < pb_type->num_ports; i++) {
             if (!pb_type->ports[i].is_clock
                     && pb_type->ports[i].type == IN_PORT) {
                 for (j = 0; j < pb_type->ports[i].num_pins; j++) {
                     iclass = clb[i_clb].type->pin_class[ipin];
                     assert(clb[i_clb].type->class_inf[iclass].type == RECEIVER);
                     assert(clb[i_clb].type->is_global_pin[ipin] == pb->pb_graph_node->input_pins[inport][j].port->is_non_clock_global);
                     node_index =
                             pb->pb_graph_node->input_pins[inport][j].pin_count_in_cluster;
                     clb[i_clb].nets[ipin] = rr_node[node_index].net_num;
                     ipin++;
                 }
                 inport++;
             } else if (pb_type->ports[i].type == OUT_PORT) {
                 for (j = 0; j < pb_type->ports[i].num_pins; j++) {
                     iclass = clb[i_clb].type->pin_class[ipin];
                     assert(clb[i_clb].type->class_inf[iclass].type == DRIVER);
                     node_index =
                             pb->pb_graph_node->output_pins[outport][j].pin_count_in_cluster;
                     clb[i_clb].nets[ipin] = rr_node[node_index].net_num;
                     ipin++;
                 }
                 outport++;
             } else {
                 assert(
                         pb_type->ports[i].is_clock && pb_type->ports[i].type == IN_PORT);
                 for (j = 0; j < pb_type->ports[i].num_pins; j++) {
                     iclass = clb[i_clb].type->pin_class[ipin];
                     assert(clb[i_clb].type->class_inf[iclass].type == RECEIVER);
                     assert(clb[i_clb].type->is_global_pin[ipin]);
                     node_index =
                             pb->pb_graph_node->clock_pins[clockport][j].pin_count_in_cluster;
                     clb[i_clb].nets[ipin] = rr_node[node_index].net_num;
                     ipin++;
                 }
                 clockport++;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void alloc_and_load_pb_stats	(	t_pb *	pb,
		int	max_models,
		int	max_nets_in_pb_type
	)

static

Definition at line 1082 of file cluster.c.

                                  {
 
     /* Call this routine when starting to fill up a new cluster.  It resets *
      * the gain vector, etc.                                                */
 
     int i, j;
 
     pb->pb_stats = new t_pb_stats;
 
     /* If statement below is for speed.  If nets are reasonably low-fanout,  *
      * only a relatively small number of blocks will be marked, and updating *
      * only those logical_block structures will be fastest.  If almost all blocks    *
      * have been touched it should be faster to just run through them all    *
      * in order (less addressing and better cache locality).                 */
     pb->pb_stats->input_pins_used = (int **) my_malloc(
             pb->pb_graph_node->num_input_pin_class * sizeof(int*));
     pb->pb_stats->output_pins_used = (int **) my_malloc(
             pb->pb_graph_node->num_output_pin_class * sizeof(int*));
     pb->pb_stats->lookahead_input_pins_used = (int **) my_malloc(
             pb->pb_graph_node->num_input_pin_class * sizeof(int*));
     pb->pb_stats->lookahead_output_pins_used = (int **) my_malloc(
             pb->pb_graph_node->num_output_pin_class * sizeof(int*));
     pb->pb_stats->num_feasible_blocks = NOT_VALID;
     pb->pb_stats->feasible_blocks = (t_pack_molecule**) my_calloc(
             AAPACK_MAX_FEASIBLE_BLOCK_ARRAY_SIZE, sizeof(t_pack_molecule *));
 
     pb->pb_stats->tie_break_high_fanout_net = OPEN;
     for (i = 0; i < pb->pb_graph_node->num_input_pin_class; i++) {
         pb->pb_stats->input_pins_used[i] = (int*) my_malloc(
                 pb->pb_graph_node->input_pin_class_size[i] * sizeof(int));
         for (j = 0; j < pb->pb_graph_node->input_pin_class_size[i]; j++) {
             pb->pb_stats->input_pins_used[i][j] = OPEN;
         }
     }
 
     for (i = 0; i < pb->pb_graph_node->num_output_pin_class; i++) {
         pb->pb_stats->output_pins_used[i] = (int*) my_malloc(
                 pb->pb_graph_node->output_pin_class_size[i] * sizeof(int));
         for (j = 0; j < pb->pb_graph_node->output_pin_class_size[i]; j++) {
             pb->pb_stats->output_pins_used[i][j] = OPEN;
         }
     }
 
     for (i = 0; i < pb->pb_graph_node->num_input_pin_class; i++) {
         pb->pb_stats->lookahead_input_pins_used[i] = (int*) my_malloc(
             (AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST + pb->pb_graph_node->input_pin_class_size[i]
                         * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC) * sizeof(int));
         for (j = 0;
                 j
                         < pb->pb_graph_node->input_pin_class_size[i]
                                 * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST; j++) {
             pb->pb_stats->lookahead_input_pins_used[i][j] = OPEN;
         }
     }
 
     for (i = 0; i < pb->pb_graph_node->num_output_pin_class; i++) {
         pb->pb_stats->lookahead_output_pins_used[i] = (int*) my_malloc(
             (AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST + 
                 pb->pb_graph_node->output_pin_class_size[i]
                         * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC) * sizeof(int));
         for (j = 0;
                 j
                         < pb->pb_graph_node->output_pin_class_size[i]
                                 * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST; j++) {
             pb->pb_stats->lookahead_output_pins_used[i][j] = OPEN;
         }
     }
 
     pb->pb_stats->gain.clear();
     pb->pb_stats->timinggain.clear();
     pb->pb_stats->connectiongain.clear();
     pb->pb_stats->sharinggain.clear();
     pb->pb_stats->hillgain.clear();
 
     pb->pb_stats->num_pins_of_net_in_pb.clear();
 
     pb->pb_stats->marked_nets = (int *) my_malloc(
             max_nets_in_pb_type * sizeof(int));
     pb->pb_stats->marked_blocks = (int *) my_malloc(
             num_logical_blocks * sizeof(int));
 
     pb->pb_stats->num_marked_nets = 0;
     pb->pb_stats->num_marked_blocks = 0;
 
     pb->pb_stats->num_child_blocks_in_pb = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void check_clocks ( boolean * is_clock )

static

Definition at line 619 of file cluster.c.

                                             {
 
     /* Checks that nets used as clock inputs to latches are never also used *
      * as VPACK_LUT inputs.  It's electrically questionable, and more importantly *
      * would break the clustering code.                                     */
 
     int inet, iblk, ipin;
     t_model_ports *port;
 
     for (iblk = 0; iblk < num_logical_blocks; iblk++) {
         if (logical_block[iblk].type != VPACK_OUTPAD) {
             port = logical_block[iblk].model->inputs;
             while (port) {
                 for (ipin = 0; ipin < port->size; ipin++) {
                     inet = logical_block[iblk].input_nets[port->index][ipin];
                     if (inet != OPEN) {
                         if (is_clock[inet]) {
                             vpr_printf(TIO_MESSAGE_ERROR, "Error in check_clocks.\n");
                             vpr_printf(TIO_MESSAGE_ERROR, "Net %d (%s) is a clock, but also connects to a logic block input on logical_block %d (%s).\n",
                                     inet, vpack_net[inet].name, iblk, logical_block[iblk].name);
                             vpr_printf(TIO_MESSAGE_ERROR, "This would break the current clustering implementation and is electrically questionable, so clustering has been aborted.\n");
                             exit(1);
                         }
                     }
                 }
                 port = port->next;
             }
         }
     }
 }

Here is the caller graph for this function:

static void check_cluster_logical_blocks	(	t_pb *	pb,
		boolean *	blocks_checked
	)

static

Definition at line 2287 of file cluster.c.

                                                                             {
     int i, j;
     const t_pb_type *pb_type;
     boolean has_child;
 
     has_child = FALSE;
     pb_type = pb->pb_graph_node->pb_type;
     if (pb_type->num_modes == 0) {
         /* primitive */
         if (pb->logical_block != OPEN) {
             if (blocks_checked[pb->logical_block] != FALSE) {
                 vpr_printf(TIO_MESSAGE_ERROR, "pb %s contains logical block %s #%d but logical block is already contained in another pb.\n",
                         pb->name, logical_block[pb->logical_block].name, pb->logical_block);
                 exit(1);
             }
             blocks_checked[pb->logical_block] = TRUE;
             if (pb != logical_block[pb->logical_block].pb) {
                 vpr_printf(TIO_MESSAGE_ERROR, "pb %s contains logical block %s #%d but logical block does not link to pb.\n",
                         pb->name, logical_block[pb->logical_block].name, pb->logical_block);
                 exit(1);
             }
         }
     } else {
         /* this is a container pb, all container pbs must contain children */
         for (i = 0; i < pb_type->modes[pb->mode].num_pb_type_children; i++) {
             for (j = 0; j < pb_type->modes[pb->mode].pb_type_children[i].num_pb;
                     j++) {
                 if (pb->child_pbs[i] != NULL) {
                     if (pb->child_pbs[i][j].name != NULL) {
                         has_child = TRUE;
                         check_cluster_logical_blocks(&pb->child_pbs[i][j],
                                 blocks_checked);
                     }
                 }
             }
         }
         assert(has_child);
     }
 }

Here is the caller graph for this function:

static void check_clustering	(	int	num_clb,
		t_block *	clb,
		boolean *	is_clock
	)

static

Definition at line 2241 of file cluster.c.

                                                                            {
     int i;
     t_pb * cur_pb;
     boolean * blocks_checked;
 
     blocks_checked = (boolean*)my_calloc(num_logical_blocks, sizeof(boolean));
 
     /* 
      * Check that each logical block connects to one primitive and that the primitive links up to the parent clb
      */
     for (i = 0; i < num_blocks; i++) {
         if (logical_block[i].pb->logical_block != i) {
             vpr_printf(TIO_MESSAGE_ERROR, "pb %s does not contain logical block %s but logical block %s #%d links to pb.\n",
                     logical_block[i].pb->name, logical_block[i].name, logical_block[i].name, i);
             exit(1);
         }
         cur_pb = logical_block[i].pb;
         assert(strcmp(cur_pb->name, logical_block[i].name) == 0);
         while (cur_pb->parent_pb) {
             cur_pb = cur_pb->parent_pb;
             assert(cur_pb->name);
         }
         if (cur_pb != clb[num_clb].pb) {
             vpr_printf(TIO_MESSAGE_ERROR, "CLB %s does not match CLB contained by pb %s.\n",
                     cur_pb->name, logical_block[i].pb->name);
             exit(1);
         }
     }
 
     /* Check that I do not have spurious links in children pbs */
     for (i = 0; i < num_clb; i++) {
         check_cluster_logical_blocks(clb[i].pb, blocks_checked);
     }
 
     for (i = 0; i < num_logical_blocks; i++) {
         if (blocks_checked[i] == FALSE) {
             vpr_printf(TIO_MESSAGE_ERROR, "Logical block %s #%d not found in any cluster.\n",
                     logical_block[i].name, i);
             exit(1);
         }
     }
 
     free(blocks_checked);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean check_lookahead_pins_used ( t_pb * cur_pb )

static

Definition at line 2731 of file cluster.c.

                                                        {
     int i, j;
     int ipin;
     const t_pb_type *pb_type = cur_pb->pb_graph_node->pb_type;
     boolean success;
 
     success = TRUE;
 
     if (pb_type->num_modes > 0 && cur_pb->name != NULL) {
         for (i = 0; i < cur_pb->pb_graph_node->num_input_pin_class && success;
                 i++) {
             ipin = 0;
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->input_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 if (cur_pb->pb_stats->lookahead_input_pins_used[i][j] != OPEN) {
                     ipin++;
                 }
             }
             if (ipin > cur_pb->pb_graph_node->input_pin_class_size[i]) {
                 success = FALSE;
             }
         }
 
         for (i = 0; i < cur_pb->pb_graph_node->num_output_pin_class && success;
                 i++) {
             ipin = 0;
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->output_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 if (cur_pb->pb_stats->lookahead_output_pins_used[i][j] != OPEN) {
                     ipin++;
                 }
             }
             if (ipin > cur_pb->pb_graph_node->output_pin_class_size[i]) {
                 success = FALSE;
             }
         }
 
         if (success && cur_pb->child_pbs != NULL) {
             for (i = 0;
                     success
                             && i
                                     < pb_type->modes[cur_pb->mode].num_pb_type_children;
                     i++) {
                 if (cur_pb->child_pbs[i] != NULL) {
                     for (j = 0;
                             success
                                     && j
                                             < pb_type->modes[cur_pb->mode].pb_type_children[i].num_pb;
                             j++) {
                         success = check_lookahead_pins_used(
                                 &cur_pb->child_pbs[i][j]);
                     }
                 }
             }
         }
     }
     return success;
 }

Here is the caller graph for this function:

static void commit_lookahead_pins_used ( t_pb * cur_pb )

static

Definition at line 2797 of file cluster.c.

                                                      {
     int i, j;
     int ipin;
     const t_pb_type *pb_type = cur_pb->pb_graph_node->pb_type;
 
     if (pb_type->num_modes > 0 && cur_pb->name != NULL) {
         for (i = 0; i < cur_pb->pb_graph_node->num_input_pin_class; i++) {
             ipin = 0;
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->input_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 if (cur_pb->pb_stats->lookahead_input_pins_used[i][j] != OPEN) {
                     cur_pb->pb_stats->input_pins_used[i][ipin] =
                             cur_pb->pb_stats->lookahead_input_pins_used[i][j];
                     ipin++;
                 }
                 assert(ipin <= cur_pb->pb_graph_node->input_pin_class_size[i]);
             }
         }
 
         for (i = 0; i < cur_pb->pb_graph_node->num_output_pin_class; i++) {
             ipin = 0;
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->output_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 if (cur_pb->pb_stats->lookahead_output_pins_used[i][j] != OPEN) {
                     cur_pb->pb_stats->output_pins_used[i][ipin] =
                             cur_pb->pb_stats->lookahead_output_pins_used[i][j];
                     ipin++;
                 }
                 assert(ipin <= cur_pb->pb_graph_node->output_pin_class_size[i]);
             }
         }
 
         if (cur_pb->child_pbs != NULL) {
             for (i = 0; i < pb_type->modes[cur_pb->mode].num_pb_type_children;
                     i++) {
                 if (cur_pb->child_pbs[i] != NULL) {
                     for (j = 0;
                             j
                                     < pb_type->modes[cur_pb->mode].pb_type_children[i].num_pb;
                             j++) {
                         commit_lookahead_pins_used(&cur_pb->child_pbs[i][j]);
                     }
                 }
             }
         }
     }
 }

Here is the caller graph for this function:

static int compare_molecule_gain	(	const void *	a,
		const void *	b
	)

static

Definition at line 2418 of file cluster.c.

                                                                {
     float base_gain_a, base_gain_b, diff;
     const t_pack_molecule *molecule_a, *molecule_b;
     molecule_a = (*(const t_pack_molecule * const *) a);
     molecule_b = (*(const t_pack_molecule * const *) b);
 
     base_gain_a = molecule_a->base_gain;
     base_gain_b = molecule_b->base_gain;
     diff = base_gain_a - base_gain_b;
     if (diff > 0) {
         return 1;
     }
     if (diff < 0) {
         return -1;
     }
     return 0;
 }

Here is the caller graph for this function:

static void compute_and_mark_lookahead_pins_used ( int ilogical_block )

static

Definition at line 2511 of file cluster.c.

                                                                      {
     int i, j;
     t_pb *cur_pb;
     t_pb_graph_node *pb_graph_node;
     const t_pb_type *pb_type;
     t_port *prim_port;
 
     int input_port;
     int output_port;
     int clock_port;
 
     assert(logical_block[ilogical_block].pb != NULL);
 
     cur_pb = logical_block[ilogical_block].pb;
     pb_graph_node = cur_pb->pb_graph_node;
     pb_type = pb_graph_node->pb_type;
 
     /* Walk through inputs, outputs, and clocks marking pins off of the same class */
     /* TODO: This is inelegant design, I should change the primitive ports in pb_type to be input, output, or clock instead of this lookup */
     input_port = output_port = clock_port = 0;
     for (i = 0; i < pb_type->num_ports; i++) {
         prim_port = &pb_type->ports[i];
         if (prim_port->is_clock) {
             assert(prim_port->type == IN_PORT);
             assert(prim_port->num_pins == 1 && clock_port == 0);
             /* currently support only one clock for primitives */
             if (logical_block[ilogical_block].clock_net != OPEN) {
                 compute_and_mark_lookahead_pins_used_for_pin(
                         &pb_graph_node->clock_pins[0][0], cur_pb,
                         logical_block[ilogical_block].clock_net);
             }
             clock_port++;
         } else if (prim_port->type == IN_PORT) {
             for (j = 0; j < prim_port->num_pins; j++) {
                 if (logical_block[ilogical_block].input_nets[prim_port->model_port->index][j]
                         != OPEN) {
                     compute_and_mark_lookahead_pins_used_for_pin(
                             &pb_graph_node->input_pins[input_port][j], cur_pb,
                             logical_block[ilogical_block].input_nets[prim_port->model_port->index][j]);
                 }
             }
             input_port++;
         } else if (prim_port->type == OUT_PORT) {
             for (j = 0; j < prim_port->num_pins; j++) {
                 if (logical_block[ilogical_block].output_nets[prim_port->model_port->index][j]
                         != OPEN) {
                     compute_and_mark_lookahead_pins_used_for_pin(
                             &pb_graph_node->output_pins[output_port][j], cur_pb,
                             logical_block[ilogical_block].output_nets[prim_port->model_port->index][j]);
                 }
             }
             output_port++;
         } else {
             assert(0);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void compute_and_mark_lookahead_pins_used_for_pin	(	t_pb_graph_pin *	pb_graph_pin,
		t_pb *	primitive_pb,
		int	inet
	)

static

Definition at line 2570 of file cluster.c.

                                                                     {
     int depth, i;
     int pin_class, output_port;
     t_pb * cur_pb;
     t_pb * check_pb;
     const t_pb_type *pb_type;
     t_port *prim_port;
     t_pb_graph_pin *output_pb_graph_pin;
     int count;
 
     boolean skip, found;
 
     cur_pb = primitive_pb->parent_pb;
 
     while (cur_pb) {
         depth = cur_pb->pb_graph_node->pb_type->depth;
         pin_class = pb_graph_pin->parent_pin_class[depth];
         assert(pin_class != OPEN);
 
         if (pb_graph_pin->port->type == IN_PORT) {
             /* find location of net driver if exist in clb, NULL otherwise */
             output_pb_graph_pin = NULL;
             if (logical_block[vpack_net[inet].node_block[0]].clb_index
                     == logical_block[primitive_pb->logical_block].clb_index) {
                 pb_type =
                         logical_block[vpack_net[inet].node_block[0]].pb->pb_graph_node->pb_type;
                 output_port = 0;
                 found = FALSE;
                 for (i = 0; i < pb_type->num_ports && !found; i++) {
                     prim_port = &pb_type->ports[i];
                     if (prim_port->type == OUT_PORT) {
                         if (pb_type->ports[i].model_port->index
                                 == vpack_net[inet].node_block_port[0]) {
                             found = TRUE;
                             break;
                         }
                         output_port++;
                     }
                 }
                 assert(found);
                 output_pb_graph_pin =
                         &(logical_block[vpack_net[inet].node_block[0]].pb->pb_graph_node->output_pins[output_port][vpack_net[inet].node_block_pin[0]]);
             }
 
             skip = FALSE;
 
             /* check if driving pin for input is contained within the currently investigated cluster, if yes, do nothing since no input needs to be used */
             if (output_pb_graph_pin != NULL) {
                 check_pb = logical_block[vpack_net[inet].node_block[0]].pb;
                 while (check_pb != NULL && check_pb != cur_pb) {
                     check_pb = check_pb->parent_pb;
                 }
                 if (check_pb != NULL) {
                     for (i = 0;
                             skip == FALSE
                                     && i
                                             < output_pb_graph_pin->num_connectable_primtive_input_pins[depth];
                             i++) {
                         if (pb_graph_pin
                                 == output_pb_graph_pin->list_of_connectable_input_pin_ptrs[depth][i]) {
                             skip = TRUE;
                         }
                     }
                 }
             }
 
             /* Must use input pin */
             if (!skip) {
                 /* Check if already in pin class, if yes, skip */
                 skip = FALSE;
                 for (i = 0;
                         i
                                 < cur_pb->pb_graph_node->input_pin_class_size[pin_class]
                                         * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                         i++) {
                     if (cur_pb->pb_stats->lookahead_input_pins_used[pin_class][i]
                             == inet) {
                         skip = TRUE;
                     }
                 }
                 if (!skip) {
                     /* Net must take up a slot */
                     for (i = 0;
                             i
                                     < cur_pb->pb_graph_node->input_pin_class_size[pin_class]
                                             * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                             i++) {
                         if (cur_pb->pb_stats->lookahead_input_pins_used[pin_class][i]
                                 == OPEN) {
                             cur_pb->pb_stats->lookahead_input_pins_used[pin_class][i] =
                                     inet;
                             break;
                         }
                     }
                 }
             }
         } else {
             assert(pb_graph_pin->port->type == OUT_PORT);
 
             skip = FALSE;
             if (pb_graph_pin->num_connectable_primtive_input_pins[depth]
                     >= vpack_net[inet].num_sinks) {
                 /* Important: This runtime penalty looks a lot scarier than it really is.  For high fan-out nets, I at most look at the number of pins within the cluster which limits runtime.
                  DO NOT REMOVE THIS INITIAL FILTER WITHOUT CAREFUL ANALYSIS ON RUNTIME!!!
                  
                  Key Observation:
                  For LUT-based designs it is impossible for the average fanout to exceed the number of LUT inputs so it's usually around 4-5 (pigeon-hole argument, if the average fanout is greater than the 
                  number of LUT inputs, where do the extra connections go?  Therefore, average fanout must be capped to a small constant where the constant is equal to the number of LUT inputs).  The real danger to runtime
                  is when the number of sinks of a net gets doubled
                  
                  */
                 for (i = 1; i <= vpack_net[inet].num_sinks; i++) {
                     if (logical_block[vpack_net[inet].node_block[i]].clb_index
                             != logical_block[vpack_net[inet].node_block[0]].clb_index) {
                         break;
                     }
                 }
                 if (i == vpack_net[inet].num_sinks + 1) {
                     count = 0;
                     /* TODO: I should cache the absorbed outputs, once net is absorbed, net is forever absorbed, no point in rechecking every time */
                     for (i = 0;
                             i
                                     < pb_graph_pin->num_connectable_primtive_input_pins[depth];
                             i++) {
                         if (get_net_corresponding_to_pb_graph_pin(cur_pb,
                                 pb_graph_pin->list_of_connectable_input_pin_ptrs[depth][i])
                                 == inet) {
                             count++;
                         }
                     }
                     if (count == vpack_net[inet].num_sinks) {
                         skip = TRUE;
                     }
                 }
             }
 
             if (!skip) {
                 /* This output must exit this cluster */
                 for (i = 0;
                         i
                                 < cur_pb->pb_graph_node->output_pin_class_size[pin_class]
                                         * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                         i++) {
                     assert(
                             cur_pb->pb_stats->lookahead_output_pins_used[pin_class][i] != inet);
                     if (cur_pb->pb_stats->lookahead_output_pins_used[pin_class][i]
                             == OPEN) {
                         cur_pb->pb_stats->lookahead_output_pins_used[pin_class][i] =
                                 inet;
                         break;
                     }
                 }
             }
         }
 
         cur_pb = cur_pb->parent_pb;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void do_clustering	(	const t_arch *	arch,
		t_pack_molecule *	molecule_head,
		int	num_models,
		boolean	global_clocks,
		boolean *	is_clock,
		boolean	hill_climbing_flag,
		char *	out_fname,
		boolean	timing_driven,
		enum e_cluster_seed	cluster_seed_type,
		float	alpha,
		float	beta,
		int	recompute_timing_after,
		float	block_delay,
		float	intra_cluster_net_delay,
		float	inter_cluster_net_delay,
		float	aspect,
		boolean	allow_unrelated_clustering,
		boolean	allow_early_exit,
		boolean	connection_driven,
		enum e_packer_algorithm	packer_algorithm,
		t_timing_inf	timing_inf
	)

Definition at line 232 of file cluster.c.

                                                                            {
 
     /* Does the actual work of clustering multiple netlist blocks *
      * into clusters.                                                  */
 
     /* Algorithm employed
      1.  Find type that can legally hold block and create cluster with pb info
      2.  Populate started cluster
      3.  Repeat 1 until no more blocks need to be clustered
      
      */
 
     int i, iblk, num_molecules, blocks_since_last_analysis, num_clb, max_nets_in_pb_type,  
         cur_nets_in_pb_type, num_blocks_hill_added, max_cluster_size, cur_cluster_size, 
         max_molecule_inputs, max_pb_depth, cur_pb_depth, num_unrelated_clustering_attempts,
         indexofcrit, savedindexofcrit /* index of next most timing critical block */,
         detailed_routing_stage, *hill_climbing_inputs_avail;
 
     int *num_used_instances_type, *num_instances_type; 
     /* [0..num_types] Holds array for total number of each cluster_type available */
 
     boolean early_exit, is_cluster_legal;
     enum e_block_pack_status block_pack_status;
     float crit;
 
     t_cluster_placement_stats *cluster_placement_stats, *cur_cluster_placement_stats_ptr;
     t_pb_graph_node **primitives_list;
     t_block *clb;
     t_slack * slacks = NULL;
     t_pack_molecule *istart, *next_molecule, *prev_molecule, *cur_molecule;
     
 #ifdef PATH_COUNTING
     int inet, ipin;
 #else
     int inode;
     float num_paths_scaling, distance_scaling;
 #endif
 
     /* TODO: This is memory inefficient, fix if causes problems */
     clb = (t_block*)my_calloc(num_logical_blocks, sizeof(t_block));
     num_clb = 0;
     istart = NULL;
 
     /* determine bound on cluster size and primitive input size */
     max_cluster_size = 0;
     max_molecule_inputs = 0;
     max_pb_depth = 0;
     max_nets_in_pb_type = 0;
 
     indexofcrit = 0;
 
     cur_molecule = molecule_head;
     num_molecules = 0;
     while (cur_molecule != NULL) {
         cur_molecule->valid = TRUE;
         if (cur_molecule->num_ext_inputs > max_molecule_inputs) {
             max_molecule_inputs = cur_molecule->num_ext_inputs;
         }
         num_molecules++;
         cur_molecule = cur_molecule->next;
     }
 
     for (i = 0; i < num_types; i++) {
         if (EMPTY_TYPE == &type_descriptors[i])
             continue;
         cur_cluster_size = get_max_primitives_in_pb_type(
                 type_descriptors[i].pb_type);
         cur_pb_depth = get_max_depth_of_pb_type(type_descriptors[i].pb_type);
         cur_nets_in_pb_type = get_max_nets_in_pb_type(
                 type_descriptors[i].pb_type);
         if (cur_cluster_size > max_cluster_size) {
             max_cluster_size = cur_cluster_size;
         }
         if (cur_pb_depth > max_pb_depth) {
             max_pb_depth = cur_pb_depth;
         }
         if (cur_nets_in_pb_type > max_nets_in_pb_type) {
             max_nets_in_pb_type = cur_nets_in_pb_type;
         }
     }
 
     if (hill_climbing_flag) {
         hill_climbing_inputs_avail = (int *) my_calloc(max_cluster_size + 1,
                 sizeof(int));
     } else {
         hill_climbing_inputs_avail = NULL; /* if used, die hard */
     }
 
     /* TODO: make better estimate for nx and ny */
     nx = ny = 1;
 
     check_clocks(is_clock);
 #if 0
     check_for_duplicate_inputs ();
 #endif
     alloc_and_init_clustering(global_clocks, alpha, beta, max_cluster_size,
             max_molecule_inputs, max_pb_depth, num_models,
             &cluster_placement_stats, &primitives_list, molecule_head,
             num_molecules);
 
     blocks_since_last_analysis = 0;
     early_exit = FALSE;
     num_blocks_hill_added = 0;
     num_used_instances_type = (int*) my_calloc(num_types, sizeof(int));
     num_instances_type = (int*) my_calloc(num_types, sizeof(int));
 
     assert(max_cluster_size < MAX_SHORT);
     /* Limit maximum number of elements for each cluster */
 
     if (timing_driven) {
         slacks = alloc_and_load_pre_packing_timing_graph(block_delay,
                 inter_cluster_net_delay, arch->models, timing_inf);
         do_timing_analysis(slacks, TRUE, FALSE, FALSE);
 
         if (getEchoEnabled()) {
             if(isEchoFileEnabled(E_ECHO_PRE_PACKING_TIMING_GRAPH))
                 print_timing_graph(getEchoFileName(E_ECHO_PRE_PACKING_TIMING_GRAPH));
 #ifndef PATH_COUNTING
             if(isEchoFileEnabled(E_ECHO_CLUSTERING_TIMING_INFO))
                 print_clustering_timing_info(getEchoFileName(E_ECHO_CLUSTERING_TIMING_INFO));
 #endif
             if(isEchoFileEnabled(E_ECHO_PRE_PACKING_SLACK))
                 print_slack(slacks->slack, FALSE, getEchoFileName(E_ECHO_PRE_PACKING_SLACK));
             if(isEchoFileEnabled(E_ECHO_PRE_PACKING_CRITICALITY))
                 print_criticality(slacks, FALSE, getEchoFileName(E_ECHO_PRE_PACKING_CRITICALITY));
         }
 
         block_criticality = (float*) my_calloc(num_logical_blocks, sizeof(float));
 
         critindexarray = (int*) my_malloc(num_logical_blocks * sizeof(int));
 
         for (i = 0; i < num_logical_blocks; i++) {
             assert(logical_block[i].index == i);
             critindexarray[i] = i;
         }
 
 #ifdef PATH_COUNTING
         /* Calculate block criticality from a weighted sum of timing and path criticalities. */
         for (inet = 0; inet < num_logical_nets; inet++) { 
             for (ipin = 1; ipin <= vpack_net[inet].num_sinks; ipin++) { 
             
                 /* Find the logical block iblk which this pin is a sink on. */
                 iblk = vpack_net[inet].node_block[ipin];
                     
                 /* The criticality of this pin is a sum of its timing and path criticalities. */
                 crit =      PACK_PATH_WEIGHT  * slacks->path_criticality[inet][ipin] 
                      + (1 - PACK_PATH_WEIGHT) * slacks->timing_criticality[inet][ipin]; 
 
                 /* The criticality of each block is the maximum of the criticalities of all its pins. */
                 if (block_criticality[iblk] < crit) {
                     block_criticality[iblk] = crit;
                 }
             }
         }
 
 #else
         /* Calculate criticality based on slacks and tie breakers (# paths, distance from source) */
         for (inode = 0; inode < num_tnodes; inode++) {
             /* Only calculate for tnodes which have valid normalized values.
             Either all values will be accurate or none will, so we only have
             to check whether one particular value (normalized_T_arr) is valid 
             Tnodes that do not have both times valid were not part of the analysis. 
             Because we calloc-ed the array criticality, such nodes will have criticality 0, the lowest possible value. */
             if (has_valid_normalized_T_arr(inode)) {
                 iblk = tnode[inode].block;
                 num_paths_scaling = SCALE_NUM_PATHS
                         * (float) tnode[inode].prepacked_data->normalized_total_critical_paths;
                 distance_scaling = SCALE_DISTANCE_VAL
                         * (float) tnode[inode].prepacked_data->normalized_T_arr;
                 crit = (1 - tnode[inode].prepacked_data->normalized_slack) + num_paths_scaling
                         + distance_scaling;
                 if (block_criticality[iblk] < crit) {
                     block_criticality[iblk] = crit;
                 }
             }
         }
 #endif
         heapsort(critindexarray, block_criticality, num_logical_blocks, 1);
         
         if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_CLUSTERING_BLOCK_CRITICALITIES)) {
             print_block_criticalities(getEchoFileName(E_ECHO_CLUSTERING_BLOCK_CRITICALITIES));
         }
 
 
         if (cluster_seed_type == VPACK_TIMING) {
             istart = get_most_critical_seed_molecule(&indexofcrit);
         } else {/*max input seed*/
             istart = get_seed_logical_molecule_with_most_ext_inputs(
                     max_molecule_inputs);
         }
 
     } else /*cluster seed is max input (since there is no timing information)*/ {
         istart = get_seed_logical_molecule_with_most_ext_inputs(
                 max_molecule_inputs);
     }
 
 
     while (istart != NULL) {
         is_cluster_legal = FALSE;
         savedindexofcrit = indexofcrit;
         for (detailed_routing_stage = (int)E_DETAILED_ROUTE_AT_END_ONLY; !is_cluster_legal && detailed_routing_stage != (int)E_DETAILED_ROUTE_END; detailed_routing_stage++) {
             reset_legalizer_for_cluster(&clb[num_clb]);
 
             /* start a new cluster and reset all stats */
             start_new_cluster(cluster_placement_stats, primitives_list, arch,
                     &clb[num_clb], num_clb, istart, aspect, num_used_instances_type,
                     num_instances_type, num_models, max_cluster_size,
                     max_nets_in_pb_type, detailed_routing_stage);
             vpr_printf(TIO_MESSAGE_INFO, "Complex block %d: %s, type: %s\n", 
                     num_clb, clb[num_clb].name, clb[num_clb].type->name);
             vpr_printf(TIO_MESSAGE_INFO, "\t");
             fflush(stdout);
             update_cluster_stats(istart, num_clb, is_clock, global_clocks, alpha,
                     beta, timing_driven, connection_driven, slacks);
             num_clb++;
 
             if (timing_driven && !early_exit) {
                 blocks_since_last_analysis++;
                 /*it doesn't make sense to do a timing analysis here since there*
                  *is only one logical_block clustered it would not change anything      */
             }
             cur_cluster_placement_stats_ptr = &cluster_placement_stats[clb[num_clb
                     - 1].type->index];
             num_unrelated_clustering_attempts = 0;
             next_molecule = get_molecule_for_cluster(PACK_BRUTE_FORCE,
                     clb[num_clb - 1].pb, allow_unrelated_clustering,
                     &num_unrelated_clustering_attempts,
                     cur_cluster_placement_stats_ptr);
             prev_molecule = istart;
             while (next_molecule != NULL && prev_molecule != next_molecule) {
                 block_pack_status = try_pack_molecule(
                         cur_cluster_placement_stats_ptr, next_molecule,
                         primitives_list, clb[num_clb - 1].pb, num_models,
                         max_cluster_size, num_clb - 1, max_nets_in_pb_type, detailed_routing_stage);
                 prev_molecule = next_molecule;
                 if (block_pack_status != BLK_PASSED) {
                     if (next_molecule != NULL) {
                         if (block_pack_status == BLK_FAILED_ROUTE) {
 #ifdef DEBUG_FAILED_PACKING_CANDIDATES
                             vpr_printf(TIO_MESSAGE_DIRECT, "\tNO_ROUTE:%s type %s/n", 
                                     next_molecule->logical_block_ptrs[next_molecule->root]->name, 
                                     next_molecule->logical_block_ptrs[next_molecule->root]->model->name);
                             fflush(stdout);
     #else
                             vpr_printf(TIO_MESSAGE_DIRECT, ".");
     #endif
                         } else {
     #ifdef DEBUG_FAILED_PACKING_CANDIDATES
                             vpr_printf(TIO_MESSAGE_DIRECT, "\tFAILED_CHECK:%s type %s check %d\n", 
                                     next_molecule->logical_block_ptrs[next_molecule->root]->name, 
                                     next_molecule->logical_block_ptrs[next_molecule->root]->model->name, 
                                     block_pack_status);
                             fflush(stdout);
     #else
                             vpr_printf(TIO_MESSAGE_DIRECT, ".");
     #endif
                         }
                     }
 
                     next_molecule = get_molecule_for_cluster(PACK_BRUTE_FORCE,
                             clb[num_clb - 1].pb, allow_unrelated_clustering,
                             &num_unrelated_clustering_attempts,
                             cur_cluster_placement_stats_ptr);
                     continue;
                 } else {
                     /* Continue packing by filling smallest cluster */
     #ifdef DEBUG_FAILED_PACKING_CANDIDATES          
                     vpr_printf(TIO_MESSAGE_DIRECT, "\tPASSED:%s type %s\n", 
                             next_molecule->logical_block_ptrs[next_molecule->root]->name, 
                             next_molecule->logical_block_ptrs[next_molecule->root]->model->name);
                     fflush(stdout);
     #else
                     vpr_printf(TIO_MESSAGE_DIRECT, ".");
     #endif
                 }
                 update_cluster_stats(next_molecule, num_clb - 1, is_clock,
                         global_clocks, alpha, beta, timing_driven,
                         connection_driven, slacks);
                 num_unrelated_clustering_attempts = 0;
 
                 if (timing_driven && !early_exit) {
                     blocks_since_last_analysis++; /* historically, timing slacks were recomputed after X number of blocks were packed, but this doesn't significantly alter results so I (jluu) did not port the code */
                 }
                 next_molecule = get_molecule_for_cluster(PACK_BRUTE_FORCE,
                         clb[num_clb - 1].pb, allow_unrelated_clustering,
                         &num_unrelated_clustering_attempts,
                         cur_cluster_placement_stats_ptr);
             }
             vpr_printf(TIO_MESSAGE_DIRECT, "\n");
             if (detailed_routing_stage == (int)E_DETAILED_ROUTE_AT_END_ONLY) {
                 is_cluster_legal = try_breadth_first_route_cluster();
                 if (is_cluster_legal == TRUE) {
                     vpr_printf(TIO_MESSAGE_INFO, "Passed route at end.\n");
                 } else {
                     vpr_printf(TIO_MESSAGE_INFO, "Failed route at end, repack cluster trying detailed routing at each stage.\n");
                 }
             } else {
                 is_cluster_legal = TRUE;
             }
             if (is_cluster_legal == TRUE) {
                 save_cluster_solution();
                 if (timing_driven) {
                     if (num_blocks_hill_added > 0 && !early_exit) {
                         blocks_since_last_analysis += num_blocks_hill_added;
                     }
                     if (cluster_seed_type == VPACK_TIMING) {
                         istart = get_most_critical_seed_molecule(&indexofcrit);
                     } else { /*max input seed*/
                         istart = get_seed_logical_molecule_with_most_ext_inputs(
                                 max_molecule_inputs);
                     }
                 } else
                     /*cluster seed is max input (since there is no timing information)*/
                     istart = get_seed_logical_molecule_with_most_ext_inputs(
                             max_molecule_inputs);
                 
                 free_pb_stats_recursive(clb[num_clb - 1].pb);
             } else {
                 /* Free up data structures and requeue used molecules */
                 num_used_instances_type[clb[num_clb - 1].type->index]--;
                 free_cb(clb[num_clb - 1].pb);
                 free(clb[num_clb - 1].pb);
                 free(clb[num_clb - 1].name);
                 clb[num_clb - 1].name = NULL;
                 clb[num_clb - 1].pb = NULL;
                 num_clb--;
                 indexofcrit = savedindexofcrit;
             }
         }
     }
 
     free_cluster_legality_checker();
 
     alloc_and_load_cluster_info(num_clb, clb);
 
     check_clustering(num_clb, clb, is_clock);
 
     output_clustering(clb, num_clb, global_clocks, is_clock, out_fname, FALSE);
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_POST_PACK_NETLIST)) {
         output_blif (clb, num_clb, global_clocks, is_clock,
             getEchoFileName(E_ECHO_POST_PACK_NETLIST), FALSE);
     }
 
     if (hill_climbing_flag) {
         free(hill_climbing_inputs_avail);
     }
     free_cluster_placement_stats(cluster_placement_stats);
 
     for (i = 0; i < num_clb; i++) {
         free_cb(clb[i].pb);
         free(clb[i].name);
         free(clb[i].nets);
         free(clb[i].pb);
     }
     free(clb);
 
     free(num_used_instances_type);
     free(num_instances_type);
     free(unclustered_list_head);
     free(memory_pool);
     free(net_output_feeds_driving_block_input);
 
     if (timing_driven) {
         free(block_criticality);
         free(critindexarray);
 
         block_criticality = NULL;
         critindexarray = NULL;
     }
 
     if (timing_driven) {
         free_timing_graph(slacks);
     }
 
  free (primitives_list);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_pb_stats_recursive ( t_pb * pb )

static

Definition at line 805 of file cluster.c.

                                               {
 
     int i, j;
     /* Releases all the memory used by clustering data structures.   */
     if (pb) {
         if (pb->pb_graph_node != NULL) {
             if (pb->pb_graph_node->pb_type->num_modes != 0) {
                 for (i = 0;
                         i
                                 < pb->pb_graph_node->pb_type->modes[pb->mode].num_pb_type_children;
                         i++) {
                     for (j = 0;
                             j
                                     < pb->pb_graph_node->pb_type->modes[pb->mode].pb_type_children[i].num_pb;
                             j++) {
                         if (pb->child_pbs && pb->child_pbs[i]) {
                             free_pb_stats_recursive(&pb->child_pbs[i][j]);
                         }
                     }
                 }
             }
         }
         free_pb_stats(pb);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static t_pack_molecule * get_free_molecule_with_most_ext_inputs_for_cluster	(	INP enum e_packer_algorithm	packer_algorithm,
		INOUTP t_pb *	cur_pb,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr
	)

static

Definition at line 1012 of file cluster.c.

                                                                     {
 
     /* This routine is used to find new blocks for clustering when there are no feasible       *
      * blocks with any attraction to the current cluster (i.e. it finds       *
      * blocks which are unconnected from the current cluster).  It returns    *
      * the logical_block with the largest number of used inputs that satisfies the    *
      * clocking and number of inputs constraints.  If no suitable logical_block is    *
      * found, the routine returns NO_CLUSTER.                                 
      * TODO: Analyze if this function is useful in more detail, also, should probably not include clock in input count
      */
 
     int ext_inps;
     int i, j;
     t_pack_molecule *molecule;
 
     int inputs_avail = 0;
 
     for (i = 0; i < cur_pb->pb_graph_node->num_input_pin_class; i++) {
         for (j = 0; j < cur_pb->pb_graph_node->input_pin_class_size[i]; j++) {
             if (cur_pb->pb_stats->input_pins_used[i][j] != OPEN)
                 inputs_avail++;
         }
     }
 
     molecule = NULL;
 
     if (inputs_avail >= unclustered_list_head_size) {
         inputs_avail = unclustered_list_head_size - 1;
     }
 
     for (ext_inps = inputs_avail; ext_inps >= 0; ext_inps--) {
         molecule = get_molecule_by_num_ext_inputs(packer_algorithm, cur_pb,
                 ext_inps, LEAVE_CLUSTERED, cluster_placement_stats_ptr);
         if (molecule != NULL) {
             break;
         }
     }
     return molecule;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static t_pack_molecule * get_highest_gain_molecule	(	INP enum e_packer_algorithm	packer_algorithm,
		INOUTP t_pb *	cur_pb,
		INP enum e_gain_type	gain_mode,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr
	)

static

Definition at line 1988 of file cluster.c.

                                                                     {
 
     /* This routine populates a list of feasible blocks outside the cluster then returns the best one for the list    *
      * not currently in a cluster and satisfies the feasibility     *
      * function passed in as is_feasible.  If there are no feasible *
      * blocks it returns NO_CLUSTER.                                */
 
     int i, j, iblk, index, inet, count;
     boolean success;
     struct s_linked_vptr *cur;
 
     t_pack_molecule *molecule;
     molecule = NULL;
 
     if (gain_mode == HILL_CLIMBING) {
         vpr_printf(TIO_MESSAGE_ERROR, "Hill climbing not supported yet, error out.\n");
         exit(1);
     }
 
     if (cur_pb->pb_stats->num_feasible_blocks == NOT_VALID) {
         /* Divide into two cases for speed only. */
         /* Typical case:  not too many blocks have been marked. */
 
         cur_pb->pb_stats->num_feasible_blocks = 0;
 
         if (cur_pb->pb_stats->num_marked_blocks
                 < num_logical_blocks / MARKED_FRAC) {
             for (i = 0; i < cur_pb->pb_stats->num_marked_blocks; i++) {
                 iblk = cur_pb->pb_stats->marked_blocks[i];
                 if (logical_block[iblk].clb_index == NO_CLUSTER) {
                     cur = logical_block[iblk].packed_molecules;
                     while (cur != NULL) {
                         molecule = (t_pack_molecule *) cur->data_vptr;
                         if (molecule->valid) {
                             success = TRUE;
                             for (j = 0;
                                     j < get_array_size_of_molecule(molecule);
                                     j++) {
                                 if (molecule->logical_block_ptrs[j] != NULL) {
                                     assert(
                                             molecule->logical_block_ptrs[j]->clb_index == NO_CLUSTER);
                                     if (!exists_free_primitive_for_logical_block(
                                             cluster_placement_stats_ptr,
                                             iblk)) { /* TODO: debating whether to check if placement exists for molecule (more robust) or individual logical blocks (faster) */
                                         success = FALSE;
                                         break;
                                     }
                                 }
                             }
                             if (success) {
                                 add_molecule_to_pb_stats_candidates(molecule,
                                         cur_pb->pb_stats->gain, cur_pb);
                             }
                         }
                         cur = cur->next;
                     }
                 }
             }
         } else { /* Some high fanout nets marked lots of blocks. */
             for (iblk = 0; iblk < num_logical_blocks; iblk++) {
                 if (logical_block[iblk].clb_index == NO_CLUSTER) {
                     cur = logical_block[iblk].packed_molecules;
                     while (cur != NULL) {
                         molecule = (t_pack_molecule *) cur->data_vptr;
                         if (molecule->valid) {
                             success = TRUE;
                             for (j = 0;
                                     j < get_array_size_of_molecule(molecule);
                                     j++) {
                                 if (molecule->logical_block_ptrs[j] != NULL) {
                                     assert(
                                             molecule->logical_block_ptrs[j]->clb_index == NO_CLUSTER);
                                     if (!exists_free_primitive_for_logical_block(
                                             cluster_placement_stats_ptr,
                                             iblk)) {
                                         success = FALSE;
                                         break;
                                     }
                                 }
                             }
                             if (success) {
                                 add_molecule_to_pb_stats_candidates(molecule,
                                         cur_pb->pb_stats->gain, cur_pb);
                             }
                         }
                         cur = cur->next;
                     }
                 }
             }
         }
     }
     if(cur_pb->pb_stats->num_feasible_blocks == 0 && cur_pb->pb_stats->tie_break_high_fanout_net != OPEN) {
         /* Because the packer ignores high fanout nets when marking what blocks to consider, use one of the ignored high fanout net to fill up lightly related blocks */
         reset_tried_but_unused_cluster_placements(cluster_placement_stats_ptr);
         inet = cur_pb->pb_stats->tie_break_high_fanout_net;
         count = 0;
         for (i = 0; i <= vpack_net[inet].num_sinks && count < AAPACK_MAX_HIGH_FANOUT_EXPLORE; i++) {
             iblk = vpack_net[inet].node_block[i];
             if (logical_block[iblk].clb_index == NO_CLUSTER) {
                 cur = logical_block[iblk].packed_molecules;
                 while (cur != NULL) {
                     molecule = (t_pack_molecule *) cur->data_vptr;
                     if (molecule->valid) {
                         success = TRUE;
                         for (j = 0;
                                 j < get_array_size_of_molecule(molecule);
                                 j++) {
                             if (molecule->logical_block_ptrs[j] != NULL) {
                                 assert(
                                         molecule->logical_block_ptrs[j]->clb_index == NO_CLUSTER);
                                 if (!exists_free_primitive_for_logical_block(
                                         cluster_placement_stats_ptr,
                                         iblk)) { /* TODO: debating whether to check if placement exists for molecule (more robust) or individual logical blocks (faster) */
                                     success = FALSE;
                                     break;
                                 }
                             }
                         }
                         if (success) {
                             add_molecule_to_pb_stats_candidates(molecule,
                                     cur_pb->pb_stats->gain, cur_pb);
                             count++;
                         }
                     }
                     cur = cur->next;
                 }
             }
         }
         cur_pb->pb_stats->tie_break_high_fanout_net = OPEN; /* Mark off that this high fanout net has been considered */
     }
     molecule = NULL;
     for (j = 0; j < cur_pb->pb_stats->num_feasible_blocks; j++) {
         if (cur_pb->pb_stats->num_feasible_blocks != 0) {
             cur_pb->pb_stats->num_feasible_blocks--;
             index = cur_pb->pb_stats->num_feasible_blocks;
             molecule = cur_pb->pb_stats->feasible_blocks[index];
             assert(molecule->valid == TRUE);
             return molecule;
         }
     }
 
     return molecule;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static t_pack_molecule * get_molecule_by_num_ext_inputs	(	INP enum e_packer_algorithm	packer_algorithm,
		INOUTP t_pb *	cur_pb,
		INP int	ext_inps,
		INP enum e_removal_policy	remove_flag,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr
	)

static

Definition at line 958 of file cluster.c.

                                                                     {
 
     /* This routine returns a logical_block which has not been clustered, has  *
      * no connection to the current cluster, satisfies the cluster     *
      * clock constraints, is a valid subblock inside the cluster, does not exceed the cluster subblock units available,
      and has ext_inps external inputs.  If        *
      * there is no such logical_block it returns NO_CLUSTER.  Remove_flag      *
      * controls whether or not blocks that have already been clustered *
      * are removed from the unclustered_list data structures.  NB:     *
      * to get a logical_block regardless of clock constraints just set clocks_ *
      * avail > 0.                                                      */
 
     struct s_molecule_link *ptr, *prev_ptr;
     int ilogical_blk, i;
     boolean success;
 
     prev_ptr = &unclustered_list_head[ext_inps];
     ptr = unclustered_list_head[ext_inps].next;
     while (ptr != NULL) {
         /* TODO: Get better candidate logical block in future, eg. return most timing critical or some other smarter metric */
         if (ptr->moleculeptr->valid) {
             success = TRUE;
             for (i = 0; i < get_array_size_of_molecule(ptr->moleculeptr); i++) {
                 if (ptr->moleculeptr->logical_block_ptrs[i] != NULL) {
                     ilogical_blk =
                             ptr->moleculeptr->logical_block_ptrs[i]->index;
                     if (!exists_free_primitive_for_logical_block(
                             cluster_placement_stats_ptr, ilogical_blk)) { /* TODO: I should be using a better filtering check especially when I'm dealing with multiple clock/multiple global reset signals where the clock/reset packed in matters, need to do later when I have the circuits to check my work */
                         success = FALSE;
                         break;
                     }
                 }
             }
             if (success == TRUE) {
                 return ptr->moleculeptr;
             }
             prev_ptr = ptr;
         }
 
         else if (remove_flag == REMOVE_CLUSTERED) {
             assert(0); /* this doesn't work right now with 2 the pass packing for each complex block */
             prev_ptr->next = ptr->next;
         }
 
         ptr = ptr->next;
     }
 
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static t_pack_molecule* get_molecule_for_cluster	(	INP enum e_packer_algorithm	packer_algorithm,
		INP t_pb *	cur_pb,
		INP boolean	allow_unrelated_clustering,
		INOUTP int *	num_unrelated_clustering_attempts,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr
	)

static

Here is the caller graph for this function:

static t_pack_molecule* get_molecule_for_cluster	(	INP enum e_packer_algorithm	packer_algorithm,
		INOUTP t_pb *	cur_pb,
		INP boolean	allow_unrelated_clustering,
		INOUTP int *	num_unrelated_clustering_attempts,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr
	)

static

Definition at line 2136 of file cluster.c.

                                                                     {
 
     /* Finds the vpack block with the the greatest gain that satisifies the      *
      * input, clock and capacity constraints of a cluster that are       *
      * passed in.  If no suitable vpack block is found it returns NO_CLUSTER.   
      */
 
     t_pack_molecule *best_molecule;
 
     /* If cannot pack into primitive, try packing into cluster */
 
     best_molecule = get_highest_gain_molecule(packer_algorithm, cur_pb,
             NOT_HILL_CLIMBING, cluster_placement_stats_ptr);
 
     /* If no blocks have any gain to the current cluster, the code above *
      * will not find anything.  However, another logical_block with no inputs in *
      * common with the cluster may still be inserted into the cluster.   */
 
     if (allow_unrelated_clustering) {
         if (best_molecule == NULL) {
             if (*num_unrelated_clustering_attempts == 0) {
                 best_molecule =
                         get_free_molecule_with_most_ext_inputs_for_cluster(
                                 packer_algorithm, cur_pb,
                                 cluster_placement_stats_ptr);
                 (*num_unrelated_clustering_attempts)++;
             }
         } else {
             *num_unrelated_clustering_attempts = 0;
         }
     }
 
     return best_molecule;
 }

Here is the call graph for this function:

static float get_molecule_gain	(	t_pack_molecule *	molecule,
		std::map< int, float > &	blk_gain
	)

static

Definition at line 2366 of file cluster.c.

                                                                                         {
     float gain;
     int i, ipin, iport, inet, iblk;
     int num_introduced_inputs_of_indirectly_related_block;
     t_model_ports *cur;
 
     gain = 0;
     num_introduced_inputs_of_indirectly_related_block = 0;
     for (i = 0; i < get_array_size_of_molecule(molecule); i++) {
         if (molecule->logical_block_ptrs[i] != NULL) {
             if(blk_gain.count(molecule->logical_block_ptrs[i]->index) > 0) {
                 gain += blk_gain[molecule->logical_block_ptrs[i]->index];
             } else {
                 /* This block has no connection with current cluster, penalize molecule for having this block 
                  */
                 cur = molecule->logical_block_ptrs[i]->model->inputs;
                 iport = 0;
                 while (cur != NULL) {
                     if (cur->is_clock != TRUE) {
                         for (ipin = 0; ipin < cur->size; ipin++) {
                             inet =
                                     molecule->logical_block_ptrs[i]->input_nets[iport][ipin];
                             if (inet != OPEN) {
                                 num_introduced_inputs_of_indirectly_related_block++;
                                 for (iblk = 0;
                                         iblk
                                                 < get_array_size_of_molecule(
                                                         molecule); iblk++) {
                                     if (molecule->logical_block_ptrs[iblk]
                                             != NULL
                                             && vpack_net[inet].node_block[0]
                                                     == molecule->logical_block_ptrs[iblk]->index) {
                                         num_introduced_inputs_of_indirectly_related_block--;
                                         break;
                                     }
                                 }
                             }
                         }
                         iport++;
                     }
                     cur = cur->next;
                 }
             }
         }
     }
 
     gain += molecule->base_gain * 0.0001; /* Use base gain as tie breaker TODO: need to sweep this value and perhaps normalize */
     gain -= num_introduced_inputs_of_indirectly_related_block * (0.001);
 
     return gain;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static t_pack_molecule * get_most_critical_seed_molecule ( int * indexofcrit )

static

Definition at line 2327 of file cluster.c.

                                                                            {
     /* Do_timing_analysis must be called before this, or this function 
      * will return garbage. Returns molecule with most critical block;
      * if block belongs to multiple molecules, return the biggest molecule. */
 
     int blkidx;
     t_pack_molecule *molecule, *best;
     struct s_linked_vptr *cur;
 
     while (*indexofcrit < num_logical_blocks) {
 
         blkidx = critindexarray[(*indexofcrit)++];
 
         if (logical_block[blkidx].clb_index == NO_CLUSTER) {
             cur = logical_block[blkidx].packed_molecules;
             best = NULL;
             while (cur != NULL) {
                 molecule = (t_pack_molecule *) cur->data_vptr;
                 if (molecule->valid) {
                     if (best == NULL
                             || (best->base_gain) < (molecule->base_gain)) {
                         best = molecule;
                     }
                 }
                 cur = cur->next;
             }
             assert(best != NULL);
             return best;
         }
     }
 
     /*if it makes it to here , there are no more blocks available*/
     return NULL;
 }

Here is the caller graph for this function:

static int get_net_corresponding_to_pb_graph_pin	(	t_pb *	cur_pb,
		t_pb_graph_pin *	pb_graph_pin
	)

static

Definition at line 2852 of file cluster.c.

                                       {
     t_pb_graph_node *pb_graph_node;
     int i;
     t_model_ports *model_port;
     int ilogical_block;
 
     if (cur_pb->name == NULL) {
         return OPEN;
     }
     if (cur_pb->pb_graph_node->pb_type->num_modes != 0) {
         pb_graph_node = pb_graph_pin->parent_node;
         while (pb_graph_node->parent_pb_graph_node->pb_type->depth
                 > cur_pb->pb_graph_node->pb_type->depth) {
             pb_graph_node = pb_graph_node->parent_pb_graph_node;
         }
         if (pb_graph_node->parent_pb_graph_node == cur_pb->pb_graph_node) {
             if (cur_pb->mode != pb_graph_node->pb_type->parent_mode->index) {
                 return OPEN;
             }
             for (i = 0;
                     i
                             < cur_pb->pb_graph_node->pb_type->modes[cur_pb->mode].num_pb_type_children;
                     i++) {
                 if (pb_graph_node
                         == &cur_pb->pb_graph_node->child_pb_graph_nodes[cur_pb->mode][i][pb_graph_node->placement_index]) {
                     break;
                 }
             }
             assert(
                     i < cur_pb->pb_graph_node->pb_type->modes[cur_pb->mode].num_pb_type_children);
             return get_net_corresponding_to_pb_graph_pin(
                     &cur_pb->child_pbs[i][pb_graph_node->placement_index],
                     pb_graph_pin);
         } else {
             return OPEN;
         }
     } else {
         ilogical_block = cur_pb->logical_block;
         if (ilogical_block == OPEN) {
             return OPEN;
         } else {
             model_port = pb_graph_pin->port->model_port;
             if (model_port->is_clock) {
                 assert(model_port->dir == IN_PORT);
                 return logical_block[ilogical_block].clock_net;
             } else if (model_port->dir == IN_PORT) {
                 return logical_block[ilogical_block].input_nets[model_port->index][pb_graph_pin->pin_number];
             } else {
                 assert(model_port->dir == OUT_PORT);
                 return logical_block[ilogical_block].output_nets[model_port->index][pb_graph_pin->pin_number];
             }
         }
     }
 }

Here is the caller graph for this function:

static t_pack_molecule * get_seed_logical_molecule_with_most_ext_inputs ( int max_molecule_inputs )

static

Definition at line 1055 of file cluster.c.

                                  {
 
     /* This routine is used to find the first seed logical_block for the clustering.  It returns    *
      * the logical_block with the largest number of used inputs that satisfies the    *
      * clocking and number of inputs constraints.  If no suitable logical_block is    *
      * found, the routine returns NO_CLUSTER.                                 */
 
     int ext_inps;
     struct s_molecule_link *ptr;
 
     for (ext_inps = max_molecule_inputs; ext_inps >= 0; ext_inps--) {
         ptr = unclustered_list_head[ext_inps].next;
 
         while (ptr != NULL) {
             if (ptr->moleculeptr->valid) {
                 return ptr->moleculeptr;
             }
             ptr = ptr->next;
         }
     }
     return NULL;
 }

Here is the caller graph for this function:

static boolean is_logical_blk_in_pb	(	int	iblk,
		t_pb *	pb
	)

static

Definition at line 651 of file cluster.c.

                                                         {
     t_pb * cur_pb;
     cur_pb = logical_block[iblk].pb;
     while (cur_pb) {
         if (cur_pb == pb) {
             return TRUE;
         }
         cur_pb = cur_pb->parent_pb;
     }
     return FALSE;
 }

Here is the caller graph for this function:

static void mark_and_update_partial_gain	(	int	inet,
		enum e_gain_update	gain_flag,
		int	clustered_block,
		int	port_on_clustered_block,
		int	pin_on_clustered_block,
		boolean	timing_driven,
		boolean	connection_driven,
		enum e_net_relation_to_clustered_block	net_relation_to_clustered_block,
		t_slack *	slacks
	)

static

Definition at line 1588 of file cluster.c.

                           {
 
     /* Updates the marked data structures, and if gain_flag is GAIN,  *
      * the gain when a logic logical_block is added to a cluster.  The        *
      * sharinggain is the number of inputs that a logical_block shares with   *
      * blocks that are already in the cluster. Hillgain is the        *
      * reduction in number of pins-required by adding a logical_block to the  *
      * cluster. The timinggain is the criticality of the most critical*
      * vpack_net between this logical_block and a logical_block in the cluster.             */
 
     int iblk, ipin, ifirst, stored_net;
     t_pb *cur_pb;
 
     cur_pb = logical_block[clustered_block].pb->parent_pb;
 
     
     if (vpack_net[inet].num_sinks > AAPACK_MAX_NET_SINKS_IGNORE) {
         /* Optimization: It can be too runtime costly for marking all sinks for a high fanout-net that probably has no hope of ever getting packed, thus ignore those high fanout nets */
         if(vpack_net[inet].is_global != TRUE) {
             /* If no low/medium fanout nets, we may need to consider high fan-out nets for packing, so select one and store it */ 
             while(cur_pb->parent_pb != NULL) {
                 cur_pb = cur_pb->parent_pb;
             }
             stored_net = cur_pb->pb_stats->tie_break_high_fanout_net;
             if(stored_net == OPEN || vpack_net[inet].num_sinks < vpack_net[stored_net].num_sinks) {
                 cur_pb->pb_stats->tie_break_high_fanout_net = inet;
             }
         }
         return;
     }
 
     while (cur_pb) {
         /* Mark vpack_net as being visited, if necessary. */
 
         if (cur_pb->pb_stats->num_pins_of_net_in_pb.count(inet) == 0) {
             cur_pb->pb_stats->marked_nets[cur_pb->pb_stats->num_marked_nets] =
                     inet;
             cur_pb->pb_stats->num_marked_nets++;
         }
 
         /* Update gains of affected blocks. */
 
         if (gain_flag == GAIN) {
 
             /* Check if this vpack_net lists its driving logical_block twice.  If so, avoid  *
              * double counting this logical_block by skipping the first (driving) pin. */
 
             if (net_output_feeds_driving_block_input[inet] == 0)
                 ifirst = 0;
             else
                 ifirst = 1;
 
             if (cur_pb->pb_stats->num_pins_of_net_in_pb.count(inet) == 0) {
                 for (ipin = ifirst; ipin <= vpack_net[inet].num_sinks; ipin++) {
                     iblk = vpack_net[inet].node_block[ipin];
                     if (logical_block[iblk].clb_index == NO_CLUSTER) {
 
                         if (cur_pb->pb_stats->sharinggain.count(iblk) == 0) {
                             cur_pb->pb_stats->marked_blocks[cur_pb->pb_stats->num_marked_blocks] =
                                     iblk;
                             cur_pb->pb_stats->num_marked_blocks++;
                             cur_pb->pb_stats->sharinggain[iblk] = 1;
                             cur_pb->pb_stats->hillgain[iblk] = 1
                                     - num_ext_inputs_logical_block(iblk);
                         } else {
                             cur_pb->pb_stats->sharinggain[iblk]++;
                             cur_pb->pb_stats->hillgain[iblk]++;
                         }
                     }
                 }
             }
 
             if (connection_driven) {
                 update_connection_gain_values(inet, clustered_block, cur_pb,
                         net_relation_to_clustered_block);
             }
 
             if (timing_driven) {
                 update_timing_gain_values(inet, clustered_block, cur_pb,
                         net_relation_to_clustered_block, slacks);
             }
         }
         if(cur_pb->pb_stats->num_pins_of_net_in_pb.count(inet) == 0) {
             cur_pb->pb_stats->num_pins_of_net_in_pb[inet] = 0;
         }
         cur_pb->pb_stats->num_pins_of_net_in_pb[inet]++;
         cur_pb = cur_pb->parent_pb;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean primitive_feasible	(	int	iblk,
		t_pb *	cur_pb
	)

static

Definition at line 831 of file cluster.c.

                                                           {
     const t_pb_type *cur_pb_type;
     int i;
     t_pb *memory_class_pb; /* Used for memory class only, for memories, open pins must be the same among siblings */
     int sibling_memory_blk;
 
     cur_pb_type = cur_pb->pb_graph_node->pb_type;
     memory_class_pb = NULL;
     sibling_memory_blk = OPEN;
 
     assert(cur_pb_type->num_modes == 0);
     /* primitive */
     if (cur_pb->logical_block != OPEN && cur_pb->logical_block != iblk) {
         /* This pb already has a different logical block */
         return FALSE;
     }
 
     if (cur_pb_type->class_type == MEMORY_CLASS) {
         /* memory class is special, all siblings must share all nets, including open nets, with the exception of data nets */
         /* find sibling if one exists */
         memory_class_pb = cur_pb->parent_pb;
         for (i = 0; i < cur_pb_type->parent_mode->num_pb_type_children; i++) {
             if (memory_class_pb->child_pbs[cur_pb->mode][i].name != NULL
                     && memory_class_pb->child_pbs[cur_pb->mode][i].logical_block
                             != OPEN) {
                 sibling_memory_blk =
                         memory_class_pb->child_pbs[cur_pb->mode][i].logical_block;
             }
         }
         if (sibling_memory_blk == OPEN) {
             memory_class_pb = NULL;
         }
     }
 
     return primitive_type_and_memory_feasible(iblk, cur_pb_type,
             memory_class_pb, sibling_memory_blk);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean primitive_type_and_memory_feasible	(	int	iblk,
		const t_pb_type *	cur_pb_type,
		t_pb *	memory_class_pb,
		int	sibling_memory_blk
	)

static

Definition at line 869 of file cluster.c.

                                 {
     t_model_ports *port;
     int i, j;
     boolean second_pass;
 
     /* check if ports are big enough */
     /* for memories, also check that pins are the same with existing siblings */
     port = logical_block[iblk].model->inputs;
     second_pass = FALSE;
     while (port || !second_pass) {
         /* TODO: This is slow if the number of ports are large, fix if becomes a problem */
         if (!port) {
             second_pass = TRUE;
             port = logical_block[iblk].model->outputs;
         }
         for (i = 0; i < cur_pb_type->num_ports; i++) {
             if (cur_pb_type->ports[i].model_port == port) {
                 /* TODO: This is slow, I only need to check from 0 if it is a memory block, other blocks I can check from port->size onwards */
                 for (j = 0; j < port->size; j++) {
                     if (port->dir == IN_PORT && !port->is_clock) {
                         if (memory_class_pb) {
                             if (cur_pb_type->ports[i].port_class == NULL
                                     || strstr(cur_pb_type->ports[i].port_class,
                                             "data")
                                             != cur_pb_type->ports[i].port_class) {
                                 if (logical_block[iblk].input_nets[port->index][j]
                                         != logical_block[sibling_memory_blk].input_nets[port->index][j]) {
                                     return FALSE;
                                 }
                             }
                         }
                         if (logical_block[iblk].input_nets[port->index][j]
                                 != OPEN
                                 && j >= cur_pb_type->ports[i].num_pins) {
                             return FALSE;
                         }
                     } else if (port->dir == OUT_PORT) {
                         if (memory_class_pb) {
                             if (cur_pb_type->ports[i].port_class == NULL
                                     || strstr(cur_pb_type->ports[i].port_class,
                                             "data")
                                             != cur_pb_type->ports[i].port_class) {
                                 if (logical_block[iblk].output_nets[port->index][j]
                                         != logical_block[sibling_memory_blk].output_nets[port->index][j]) {
                                     return FALSE;
                                 }
                             }
                         }
                         if (logical_block[iblk].output_nets[port->index][j]
                                 != OPEN
                                 && j >= cur_pb_type->ports[i].num_pins) {
                             return FALSE;
                         }
                     } else {
                         assert(port->dir == IN_PORT && port->is_clock);
                         assert(j == 0);
                         if (memory_class_pb) {
                             if (logical_block[iblk].clock_net
                                     != logical_block[sibling_memory_blk].clock_net) {
                                 return FALSE;
                             }
                         }
                         if (logical_block[iblk].clock_net != OPEN
                                 && j >= cur_pb_type->ports[i].num_pins) {
                             return FALSE;
                         }
                     }
                 }
                 break;
             }
         }
         if (i == cur_pb_type->num_ports) {
             if (((logical_block[iblk].model->inputs != NULL) && !second_pass)
                     || (logical_block[iblk].model->outputs != NULL
                             && second_pass)) {
                 /* physical port not found */
                 return FALSE;
             }
         }
         if (port) {
             port = port->next;
         }
     }
     return TRUE;
 }

Here is the caller graph for this function:

static void print_block_criticalities ( const char * fname )

static

Definition at line 2908 of file cluster.c.

                                                           {
     /* Prints criticality and critindexarray for each logical block to a file. */
     
     int iblock, len;
     FILE * fp;
     char * name;
 
     fp = my_fopen(fname, "w", 0);
     fprintf(fp, "Index \tLogical block name \tCriticality \tCritindexarray\n\n");
     for (iblock = 0; iblock < num_logical_blocks; iblock++) {
         name = logical_block[iblock].name;
         len = strlen(name);
         fprintf(fp, "%d\t%s\t", logical_block[iblock].index, name);
         if (len < 8) {
             fprintf(fp, "\t\t");
         } else if (len < 16) {
             fprintf(fp, "\t");
         }
         fprintf(fp, "%f\t%d\n", block_criticality[iblock], critindexarray[iblock]);
     }
     fclose(fp);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void reset_lookahead_pins_used ( t_pb * cur_pb )

static

Definition at line 2466 of file cluster.c.

                                                     {
     int i, j;
     const t_pb_type *pb_type = cur_pb->pb_graph_node->pb_type;
     if (cur_pb->pb_stats == NULL) {
         return; /* No pins used, no need to continue */
     }
 
     if (pb_type->num_modes > 0 && cur_pb->name != NULL) {
         for (i = 0; i < cur_pb->pb_graph_node->num_input_pin_class; i++) {
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->input_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 cur_pb->pb_stats->lookahead_input_pins_used[i][j] = OPEN;
             }
         }
 
         for (i = 0; i < cur_pb->pb_graph_node->num_output_pin_class; i++) {
             for (j = 0;
                     j
                             < cur_pb->pb_graph_node->output_pin_class_size[i]
                                     * AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_FAC + AAPACK_MAX_OVERUSE_LOOKAHEAD_PINS_CONST;
                     j++) {
                 cur_pb->pb_stats->lookahead_output_pins_used[i][j] = OPEN;
             }
         }
 
         if (cur_pb->child_pbs != NULL) {
             for (i = 0; i < pb_type->modes[cur_pb->mode].num_pb_type_children;
                     i++) {
                 if (cur_pb->child_pbs[i] != NULL) {
                     for (j = 0;
                             j
                                     < pb_type->modes[cur_pb->mode].pb_type_children[i].num_pb;
                             j++) {
                         reset_lookahead_pins_used(&cur_pb->child_pbs[i][j]);
                     }
                 }
             }
         }
     }
 }

Here is the caller graph for this function:

static void revert_place_logical_block	(	INP int	ilogical_block,
		INP int	max_models
	)

static

Definition at line 1412 of file cluster.c.

                                                                            {
     t_pb *pb, *next;
 
     pb = logical_block[iblock].pb;
     logical_block[iblock].clb_index = NO_CLUSTER;
     logical_block[iblock].pb = NULL;
 
     if (pb != NULL) {
         /* When freeing molecules, the current block might already have been freed by a prior revert 
          When this happens, no need to do anything beyond basic book keeping at the logical block
          */
 
         next = pb->parent_pb;
         free_pb(pb);
         pb = next;
 
         while (pb != NULL) {
             /* If this is pb is created only for the purposes of holding new molecule, remove it
              Must check if cluster is already freed (which can be the case)
              */
             next = pb->parent_pb;
             
             if (pb->child_pbs != NULL && pb->pb_stats != NULL
                     && pb->pb_stats->num_child_blocks_in_pb == 0) {
                 set_pb_graph_mode(pb->pb_graph_node, pb->mode, 0); /* default mode is to use mode 1 */
                 set_pb_graph_mode(pb->pb_graph_node, 0, 1);
                 if (next != NULL) {
                     /* If the code gets here, then that means that placing the initial seed molecule failed, don't free the actual complex block itself as the seed needs to find another placement */
                     free_pb(pb);
                 }
             }
             pb = next;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void start_new_cluster	(	INP t_cluster_placement_stats *	cluster_placement_stats,
		INP t_pb_graph_node **	primitives_list,
		INP const t_arch *	arch,
		INOUTP t_block *	new_cluster,
		INP int	clb_index,
		INP t_pack_molecule *	molecule,
		INP float	aspect,
		INOUTP int *	num_used_instances_type,
		INOUTP int *	num_instances_type,
		INP int	num_models,
		INP int	max_cluster_size,
		INP int	max_nets_in_pb_type,
		INP int	detailed_routing_stage
	)

static

Here is the caller graph for this function:

static void start_new_cluster	(	INP t_cluster_placement_stats *	cluster_placement_stats,
		INOUTP t_pb_graph_node **	primitives_list,
		INP const t_arch *	arch,
		INOUTP t_block *	new_cluster,
		INP int	clb_index,
		INP t_pack_molecule *	molecule,
		INP float	aspect,
		INOUTP int *	num_used_instances_type,
		INOUTP int *	num_instances_type,
		INP int	num_models,
		INP int	max_cluster_size,
		INP int	max_nets_in_pb_type,
		INP int	detailed_routing_stage
	)

static

Definition at line 1878 of file cluster.c.

                                                                      {
     /* Given a starting seed block, start_new_cluster determines the next cluster type to use 
      It expands the FPGA if it cannot find a legal cluster for the logical block
      */
     int i, j;
     boolean success;
     int count;
 
     assert(new_cluster->name == NULL);
     /* Check if this cluster is really empty */
 
     /* Allocate a dummy initial cluster and load a logical block as a seed and check if it is legal */
     new_cluster->name = (char*) my_malloc(
             (strlen(molecule->logical_block_ptrs[molecule->root]->name) + 4) * sizeof(char));
     sprintf(new_cluster->name, "cb.%s",
             molecule->logical_block_ptrs[molecule->root]->name);
     new_cluster->nets = NULL;
     new_cluster->type = NULL;
     new_cluster->pb = NULL;
     new_cluster->x = UNDEFINED;
     new_cluster->y = UNDEFINED;
     new_cluster->z = UNDEFINED;
 
     success = FALSE;
 
     while (!success) {
         count = 0;
         for (i = 0; i < num_types; i++) {
             if (num_used_instances_type[i] < num_instances_type[i]) {
                 new_cluster->type = &type_descriptors[i];
                 if (new_cluster->type == EMPTY_TYPE) {
                     continue;
                 }
                 new_cluster->pb = (t_pb*)my_calloc(1, sizeof(t_pb));
                 new_cluster->pb->pb_graph_node =
                         new_cluster->type->pb_graph_head;
                 alloc_and_load_pb_stats(new_cluster->pb, num_models,
                         max_nets_in_pb_type);
                 new_cluster->pb->parent_pb = NULL;
 
                 alloc_and_load_legalizer_for_cluster(new_cluster, clb_index,
                         arch);
                 for (j = 0;
                         j < new_cluster->type->pb_graph_head->pb_type->num_modes
                                 && !success; j++) {
                     new_cluster->pb->mode = j;
                     reset_cluster_placement_stats(&cluster_placement_stats[i]);
                     set_mode_cluster_placement_stats(
                             new_cluster->pb->pb_graph_node, j);
                     success = (boolean) (BLK_PASSED
                             == try_pack_molecule(&cluster_placement_stats[i],
                                     molecule, primitives_list, new_cluster->pb,
                                     num_models, max_cluster_size, clb_index,
                                     max_nets_in_pb_type, detailed_routing_stage));
                 }
                 if (success) {
                     /* TODO: For now, just grab any working cluster, in the future, heuristic needed to grab best complex block based on supply and demand */
                     break;
                 } else {
                     free_legalizer_for_cluster(new_cluster, TRUE);
                     free_pb_stats(new_cluster->pb);
                     free(new_cluster->pb);
                 }
                 count++;
             }
         }
         if (count == num_types - 1) {
             vpr_printf(TIO_MESSAGE_ERROR, "Can not find any logic block that can implement molecule.\n");
             if (molecule->type == MOLECULE_FORCED_PACK) {
                 vpr_printf(TIO_MESSAGE_ERROR, "\tPattern %s %s\n", 
                         molecule->pack_pattern->name,
                         molecule->logical_block_ptrs[molecule->root]->name);
             } else {
                 vpr_printf(TIO_MESSAGE_ERROR, "\tAtom %s\n",
                         molecule->logical_block_ptrs[molecule->root]->name);
             }
             exit(1);
         }
 
         /* Expand FPGA size and recalculate number of available cluster types*/
         if (!success) {
             if (aspect >= 1.0) {
                 ny++;
                 nx = nint(ny * aspect);
             } else {
                 nx++;
                 ny = nint(nx / aspect);
             }
             vpr_printf(TIO_MESSAGE_INFO, "Not enough resources expand FPGA size to x = %d y = %d.\n",
                     nx, ny);
             if ((nx > MAX_SHORT) || (ny > MAX_SHORT)) {
                 vpr_printf(TIO_MESSAGE_ERROR, "Circuit cannot pack into architecture, architecture size (nx = %d, ny = %d) exceeds packer range.\n",
                         nx, ny);
                 exit(1);
             }
             alloc_and_load_grid(num_instances_type);
             freeGrid();
         }
     }
     num_used_instances_type[new_cluster->type->index]++;
 }

Here is the call graph for this function:

static enum e_block_pack_status try_pack_molecule	(	INOUTP t_cluster_placement_stats *	cluster_placement_stats_ptr,
		INP t_pack_molecule *	molecule,
		INOUTP t_pb_graph_node **	primitives_list,
		INOUTP t_pb *	pb,
		INP int	max_models,
		INP int	max_cluster_size,
		INP int	clb_index,
		INP int	max_nets_in_pb_type,
		INP int	detailed_routing_stage
	)

static

Try pack molecule into current cluster

Definition at line 1174 of file cluster.c.

                                                                                         {
     int molecule_size, failed_location;
     int i;
     enum e_block_pack_status block_pack_status;
     struct s_linked_vptr *cur_molecule;
     t_pb *parent;
     t_pb *cur_pb;
     t_logical_block *chain_root_block;
     boolean is_root_of_chain;
     t_pb_graph_pin *chain_root_pin;
 
     
     parent = NULL;
     
     block_pack_status = BLK_STATUS_UNDEFINED;
 
     molecule_size = get_array_size_of_molecule(molecule);
     failed_location = 0;
 
     while (block_pack_status != BLK_PASSED) {
         save_and_reset_routing_cluster(); /* save current routing information because speculative packing will change routing*/
         if (get_next_primitive_list(cluster_placement_stats_ptr, molecule,
                 primitives_list, clb_index)) {
             block_pack_status = BLK_PASSED;
             
             for (i = 0; i < molecule_size && block_pack_status == BLK_PASSED;
                     i++) {
                 assert(
                         (primitives_list[i] == NULL) == (molecule->logical_block_ptrs[i] == NULL));
                 failed_location = i + 1;
                 if (molecule->logical_block_ptrs[i] != NULL) {
                     if(molecule->type == MOLECULE_FORCED_PACK && molecule->pack_pattern->is_chain && i == molecule->pack_pattern->root_block->block_id) {
                         chain_root_pin = molecule->pack_pattern->chain_root_pin;
                         is_root_of_chain = TRUE;
                     } else {
                         chain_root_pin = NULL;
                         is_root_of_chain = FALSE;
                     }
                     block_pack_status = try_place_logical_block_rec(
                             primitives_list[i],
                             molecule->logical_block_ptrs[i]->index, pb, &parent,
                             max_models, max_cluster_size, clb_index,
                             max_nets_in_pb_type, cluster_placement_stats_ptr, is_root_of_chain, chain_root_pin);
                 }
             }
             if (block_pack_status == BLK_PASSED) {
                 /* Check if pin usage is feasible for the current packing assigment */
                 reset_lookahead_pins_used(pb);
                 try_update_lookahead_pins_used(pb);
                 if (!check_lookahead_pins_used(pb)) {
                     block_pack_status = BLK_FAILED_FEASIBLE;
                 }
             }
             if (block_pack_status == BLK_PASSED) {
                 /* Try to route if heuristic is to route for every atom
                     Skip routing if heuristic is to route at the end of packing complex block
                 */
                 setup_intracluster_routing_for_molecule(molecule, primitives_list);
                 if (detailed_routing_stage == (int)E_DETAILED_ROUTE_FOR_EACH_ATOM && try_breadth_first_route_cluster() == FALSE) {
                     /* Cannot pack */
                     block_pack_status = BLK_FAILED_ROUTE;
                 } else {
                     /* Pack successful, commit 
                      TODO: SW Engineering note - may want to update cluster stats here too instead of doing it outside
                      */
                     assert(block_pack_status == BLK_PASSED);
                     if(molecule->type == MOLECULE_FORCED_PACK && molecule->pack_pattern->is_chain) {
                         /* Chained molecules often take up lots of area and are important, if a chain is packed in, want to rename logic block to match chain name */
                         chain_root_block = molecule->logical_block_ptrs[molecule->pack_pattern->root_block->block_id];
                         cur_pb = chain_root_block->pb->parent_pb;
                         while(cur_pb != NULL) {
                             free(cur_pb->name);
                             cur_pb->name = my_strdup(chain_root_block->name);
                             cur_pb = cur_pb->parent_pb;
                         }
                     }
                     for (i = 0; i < molecule_size; i++) {
                         if (molecule->logical_block_ptrs[i] != NULL) {
                             /* invalidate all molecules that share logical block with current molecule */
                             cur_molecule =
                                     molecule->logical_block_ptrs[i]->packed_molecules;
                             while (cur_molecule != NULL) {
                                 ((t_pack_molecule*) cur_molecule->data_vptr)->valid =
                                         FALSE;
                                 cur_molecule = cur_molecule->next;
                             }
                             commit_primitive(cluster_placement_stats_ptr,
                                     primitives_list[i]);
                         }
                     }
                 }
             }
             if (block_pack_status != BLK_PASSED) {
                 for (i = 0; i < failed_location; i++) {
                     if (molecule->logical_block_ptrs[i] != NULL) {
                         revert_place_logical_block(
                                 molecule->logical_block_ptrs[i]->index,
                                 max_models);
                     }
                 }
                 restore_routing_cluster();
             }
         } else {
             block_pack_status = BLK_FAILED_FEASIBLE;
             restore_routing_cluster();
             break; /* no more candidate primitives available, this molecule will not pack, return fail */
         }
     }
     return block_pack_status;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static enum e_block_pack_status try_place_logical_block_rec	(	INP t_pb_graph_node *	pb_graph_node,
		INP int	ilogical_block,
		INP t_pb *	cb,
		OUTP t_pb **	parent,
		INP int	max_models,
		INP int	max_cluster_size,
		INP int	clb_index,
		INP int	max_nets_in_pb_type,
		INP t_cluster_placement_stats *	cluster_placement_stats_ptr,
		INP boolean	is_root_of_chain,
		INP t_pb_graph_pin *	chain_root_pin
	)

static

Try place logical block into current primitive location

Definition at line 1293 of file cluster.c.

                                                                           {
     int i, j;
     boolean is_primitive;
     enum e_block_pack_status block_pack_status;
 
     t_pb *my_parent;
     t_pb *pb, *parent_pb;
     const t_pb_type *pb_type;
 
     t_model_ports *root_port;
 
     my_parent = NULL;
 
     block_pack_status = BLK_PASSED;
 
     /* Discover parent */
     if (pb_graph_node->parent_pb_graph_node != cb->pb_graph_node) {
         block_pack_status = try_place_logical_block_rec(
                 pb_graph_node->parent_pb_graph_node, ilogical_block, cb,
                 &my_parent, max_models, max_cluster_size, clb_index,
                 max_nets_in_pb_type, cluster_placement_stats_ptr, is_root_of_chain, chain_root_pin);
         parent_pb = my_parent;
     } else {
         parent_pb = cb;
     }
 
     /* Create siblings if siblings are not allocated */
     if (parent_pb->child_pbs == NULL) {
         assert(parent_pb->name == NULL);
         parent_pb->logical_block = OPEN;
         parent_pb->name = my_strdup(logical_block[ilogical_block].name);
         parent_pb->mode = pb_graph_node->pb_type->parent_mode->index;
         set_pb_graph_mode(parent_pb->pb_graph_node, 0, 0); /* TODO: default mode is to use mode 0, document this! */
         set_pb_graph_mode(parent_pb->pb_graph_node, parent_pb->mode, 1);
         parent_pb->child_pbs =
                 (t_pb **) my_calloc(
                         parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].num_pb_type_children,
                         sizeof(t_pb *));
         for (i = 0;
                 i
                         < parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].num_pb_type_children;
                 i++) {
             parent_pb->child_pbs[i] =
                     (t_pb *) my_calloc(
                             parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].pb_type_children[i].num_pb,
                             sizeof(t_pb));
             for (j = 0;
                     j
                             < parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].pb_type_children[i].num_pb;
                     j++) {
                 parent_pb->child_pbs[i][j].parent_pb = parent_pb;
                 parent_pb->child_pbs[i][j].logical_block = OPEN;
                 parent_pb->child_pbs[i][j].pb_graph_node =
                         &(parent_pb->pb_graph_node->child_pb_graph_nodes[parent_pb->mode][i][j]);
             }
         }
     } else {
         assert(parent_pb->mode == pb_graph_node->pb_type->parent_mode->index);
     }
 
     for (i = 0;
             i
                     < parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].num_pb_type_children;
             i++) {
         if (pb_graph_node->pb_type
                 == &parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].pb_type_children[i]) {
             break;
         }
     }
     assert(
             i < parent_pb->pb_graph_node->pb_type->modes[parent_pb->mode].num_pb_type_children);
     pb = &parent_pb->child_pbs[i][pb_graph_node->placement_index];
     *parent = pb; /* this pb is parent of it's child that called this function */
     assert(pb->pb_graph_node == pb_graph_node);
     if (pb->pb_stats == NULL) {
         alloc_and_load_pb_stats(pb, max_models, max_nets_in_pb_type);
     }
     pb_type = pb_graph_node->pb_type;
 
     is_primitive = (boolean) (pb_type->num_modes == 0);
 
     if (is_primitive) {
         assert(
                 pb->logical_block == OPEN && logical_block[ilogical_block].pb == NULL && logical_block[ilogical_block].clb_index == NO_CLUSTER);
         /* try pack to location */
         pb->name = my_strdup(logical_block[ilogical_block].name);
         pb->logical_block = ilogical_block;
         logical_block[ilogical_block].clb_index = clb_index;
         logical_block[ilogical_block].pb = pb;
 
         if (!primitive_feasible(ilogical_block, pb)) {
             /* failed location feasibility check, revert pack */
             block_pack_status = BLK_FAILED_FEASIBLE;
         }
 
         if (block_pack_status == BLK_PASSED && is_root_of_chain == TRUE) {
             /* is carry chain, must check if this carry chain spans multiple logic blocks or not */
             root_port = chain_root_pin->port->model_port;
             if(logical_block[ilogical_block].input_nets[root_port->index][chain_root_pin->pin_number] != OPEN) {
                 /* this carry chain spans multiple logic blocks, must match up correctly with previous chain for this to route */
                 if(pb_graph_node != chain_root_pin->parent_node) {
                     /* this location does not match with the dedicated chain input from outside logic block, therefore not feasible */
                     block_pack_status = BLK_FAILED_FEASIBLE;
                 }
             }
         }
     }
 
     return block_pack_status;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void try_update_lookahead_pins_used ( t_pb * cur_pb )

static

Definition at line 2439 of file cluster.c.

                                                          {
     int i, j;
     const t_pb_type *pb_type = cur_pb->pb_graph_node->pb_type;
 
     if (pb_type->num_modes > 0 && cur_pb->name != NULL) {
         if (cur_pb->child_pbs != NULL) {
             for (i = 0; i < pb_type->modes[cur_pb->mode].num_pb_type_children;
                     i++) {
                 if (cur_pb->child_pbs[i] != NULL) {
                     for (j = 0;
                             j
                                     < pb_type->modes[cur_pb->mode].pb_type_children[i].num_pb;
                             j++) {
                         try_update_lookahead_pins_used(
                                 &cur_pb->child_pbs[i][j]);
                     }
                 }
             }
         }
     } else {
         if (pb_type->blif_model != NULL && cur_pb->logical_block != OPEN) {
             compute_and_mark_lookahead_pins_used(cur_pb->logical_block);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_cluster_stats	(	INP t_pack_molecule *	molecule,
		INP int	clb_index,
		INP boolean *	is_clock,
		INP boolean	global_clocks,
		INP float	alpha,
		INP float	beta,
		INP boolean	timing_driven,
		INP boolean	connection_driven,
		INP t_slack *	slacks
	)

static

Definition at line 1774 of file cluster.c.

                                                              {
 
     /* Updates cluster stats such as gain, used pins, and clock structures.  */
 
     int ipin, inet;
     int new_blk, molecule_size;
     int iblock;
     t_model_ports *port;
     t_pb *cur_pb, *cb;
 
     /* TODO: what a scary comment from Vaughn, we'll have to watch out for this causing problems */
     /* Output can be open so the check is necessary.  I don't change  *
      * the gain for clock outputs when clocks are globally distributed  *
      * because I assume there is no real need to pack similarly clocked *
      * FFs together then.  Note that by updating the gain when the      *
      * clock driver is placed in a cluster implies that the output of   *
      * LUTs can be connected to clock inputs internally.  Probably not  *
      * true, but it doesn't make much difference, since it will still   *
      * make local routing of this clock very short, and none of my      *
      * benchmarks actually generate local clocks (all come from pads).  */
 
     molecule_size = get_array_size_of_molecule(molecule);
     cb = NULL;
 
     for (iblock = 0; iblock < molecule_size; iblock++) {
         if (molecule->logical_block_ptrs[iblock] == NULL) {
             continue;
         }
         new_blk = molecule->logical_block_ptrs[iblock]->index;
 
         logical_block[new_blk].clb_index = clb_index;
 
         cur_pb = logical_block[new_blk].pb->parent_pb;
         while (cur_pb) {
             /* reset list of feasible blocks */
             cur_pb->pb_stats->num_feasible_blocks = NOT_VALID;
             cur_pb->pb_stats->num_child_blocks_in_pb++;
             if (cur_pb->parent_pb == NULL) {
                 cb = cur_pb;
             }
             cur_pb = cur_pb->parent_pb;
         }
 
         port = logical_block[new_blk].model->outputs;
         while (port) {
             for (ipin = 0; ipin < port->size; ipin++) {
                 inet = logical_block[new_blk].output_nets[port->index][ipin]; /* Output pin first. */
                 if (inet != OPEN) {
                     if (!is_clock[inet] || !global_clocks)
                         mark_and_update_partial_gain(inet, GAIN, new_blk,
                                 port->index, ipin, timing_driven,
                                 connection_driven, OUTPUT, slacks);
                     else
                         mark_and_update_partial_gain(inet, NO_GAIN, new_blk,
                                 port->index, ipin, timing_driven,
                                 connection_driven, OUTPUT, slacks);
                 }
             }
             port = port->next;
         }
         port = logical_block[new_blk].model->inputs;
         while (port) {
             if (port->is_clock) {
                 port = port->next;
                 continue;
             }
             for (ipin = 0; ipin < port->size; ipin++) { /*  VPACK_BLOCK input pins. */
 
                 inet = logical_block[new_blk].input_nets[port->index][ipin];
                 if (inet != OPEN) {
                     mark_and_update_partial_gain(inet, GAIN, new_blk,
                             port->index, ipin, timing_driven, connection_driven,
                             INPUT, slacks);
                 }
             }
             port = port->next;
         }
 
         /* Note:  The code below ONLY WORKS when nets that go to clock inputs *
          * NEVER go to the input of a VPACK_COMB.  It doesn't really make electrical *
          * sense for that to happen, and I check this in the check_clocks     *
          * function.  Don't disable that sanity check.                        */
         inet = logical_block[new_blk].clock_net; /* Clock input pin. */
         if (inet != OPEN) {
             if (global_clocks)
                 mark_and_update_partial_gain(inet, NO_GAIN, new_blk, 0, 0,
                         timing_driven, connection_driven, INPUT, slacks);
             else
                 mark_and_update_partial_gain(inet, GAIN, new_blk, 0, 0,
                         timing_driven, connection_driven, INPUT, slacks);
 
         }
 
         update_total_gain(alpha, beta, timing_driven, connection_driven,
                 global_clocks, logical_block[new_blk].pb->parent_pb);
 
         commit_lookahead_pins_used(cb);
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_connection_gain_values	(	int	inet,
		int	clustered_block,
		t_pb *	cur_pb,
		enum e_net_relation_to_clustered_block	net_relation_to_clustered_block
	)

static

Definition at line 1448 of file cluster.c.

                                                                                 {
     /*This function is called when the connectiongain values on the vpack_net*
      *inet require updating.   */
 
     int iblk, ipin;
     int clb_index;
     int num_internal_connections, num_open_connections, num_stuck_connections;
 
     num_internal_connections = num_open_connections = num_stuck_connections = 0;
 
     clb_index = logical_block[clustered_block].clb_index;
 
     /* may wish to speed things up by ignoring clock nets since they are high fanout */
 
     for (ipin = 0; ipin <= vpack_net[inet].num_sinks; ipin++) {
         iblk = vpack_net[inet].node_block[ipin];
         if (logical_block[iblk].clb_index == clb_index
                 && is_logical_blk_in_pb(iblk,
                         logical_block[clustered_block].pb)) {
             num_internal_connections++;
         } else if (logical_block[iblk].clb_index == OPEN) {
             num_open_connections++;
         } else {
             num_stuck_connections++;
         }
     }
 
     if (net_relation_to_clustered_block == OUTPUT) {
         for (ipin = 1; ipin <= vpack_net[inet].num_sinks; ipin++) {
             iblk = vpack_net[inet].node_block[ipin];
             if (logical_block[iblk].clb_index == NO_CLUSTER) {
                 /* TODO: Gain function accurate only if net has one connection to block, TODO: Should we handle case where net has multi-connection to block? Gain computation is only off by a bit in this case */
                 if(cur_pb->pb_stats->connectiongain.count(iblk) == 0) {
                     cur_pb->pb_stats->connectiongain[iblk] = 0;
                 }
                 
                 if (num_internal_connections > 1) {
                     cur_pb->pb_stats->connectiongain[iblk] -= 1
                             / (float) (vpack_net[inet].num_sinks
                                     - (num_internal_connections - 1)
                                     + 1 * num_stuck_connections);
                 }
                 cur_pb->pb_stats->connectiongain[iblk] += 1
                         / (float) (vpack_net[inet].num_sinks
                                 - num_internal_connections
                                 + 1 * num_stuck_connections);
             }
         }
     }
 
     if (net_relation_to_clustered_block == INPUT) {
         /*Calculate the connectiongain for the logical_block which is driving *
          *the vpack_net that is an input to a logical_block in the cluster */
 
         iblk = vpack_net[inet].node_block[0];
         if (logical_block[iblk].clb_index == NO_CLUSTER) {
             if(cur_pb->pb_stats->connectiongain.count(iblk) == 0) {
                 cur_pb->pb_stats->connectiongain[iblk] = 0;
             }
             if (num_internal_connections > 1) {
                 cur_pb->pb_stats->connectiongain[iblk] -= 1
                         / (float) (vpack_net[inet].num_sinks
                                 - (num_internal_connections - 1) + 1
                                 + 1 * num_stuck_connections);
             }
             cur_pb->pb_stats->connectiongain[iblk] += 1
                     / (float) (vpack_net[inet].num_sinks
                             - num_internal_connections + 1
                             + 1 * num_stuck_connections);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_timing_gain_values	(	int	inet,
		int	clustered_block,
		t_pb *	cur_pb,
		enum e_net_relation_to_clustered_block	net_relation_to_clustered_block,
		t_slack *	slacks
	)

static

Definition at line 1523 of file cluster.c.

                                                                                                   {
 
     /*This function is called when the timing_gain values on the vpack_net*
      *inet requires updating.   */
     float timinggain;
     int newblk, ifirst;
     int iblk, ipin;
 
     /* Check if this vpack_net lists its driving logical_block twice.  If so, avoid  *
      * double counting this logical_block by skipping the first (driving) pin. */
     if (net_output_feeds_driving_block_input[inet] == FALSE)
         ifirst = 0;
     else
         ifirst = 1;
 
     if (net_relation_to_clustered_block == OUTPUT
             && !vpack_net[inet].is_global) {
         for (ipin = ifirst; ipin <= vpack_net[inet].num_sinks; ipin++) {
             iblk = vpack_net[inet].node_block[ipin];
             if (logical_block[iblk].clb_index == NO_CLUSTER) {
 #ifdef PATH_COUNTING
                 /* Timing gain is a weighted sum of timing and path criticalities. */
                 timinggain =      TIMING_GAIN_PATH_WEIGHT  * slacks->path_criticality[inet][ipin] 
                            + (1 - TIMING_GAIN_PATH_WEIGHT) * slacks->timing_criticality[inet][ipin]; 
 #else
                 /* Timing gain is the timing criticality. */
                 timinggain = slacks->timing_criticality[inet][ipin]; 
 #endif
                 if(cur_pb->pb_stats->timinggain.count(iblk) == 0) {
                     cur_pb->pb_stats->timinggain[iblk] = 0;
                 }
                 if (timinggain > cur_pb->pb_stats->timinggain[iblk])
                     cur_pb->pb_stats->timinggain[iblk] = timinggain;
             }
         }
     }
 
     if (net_relation_to_clustered_block == INPUT
             && !vpack_net[inet].is_global) {
         /*Calculate the timing gain for the logical_block which is driving *
          *the vpack_net that is an input to a logical_block in the cluster */
         newblk = vpack_net[inet].node_block[0];
         if (logical_block[newblk].clb_index == NO_CLUSTER) {
             for (ipin = 1; ipin <= vpack_net[inet].num_sinks; ipin++) {
 #ifdef PATH_COUNTING
                 /* Timing gain is a weighted sum of timing and path criticalities. */
                 timinggain =      TIMING_GAIN_PATH_WEIGHT  * slacks->path_criticality[inet][ipin] 
                            + (1 - TIMING_GAIN_PATH_WEIGHT) * slacks->timing_criticality[inet][ipin]; 
 #else
                 /* Timing gain is the timing criticality. */
                 timinggain = slacks->timing_criticality[inet][ipin]; 
 #endif
                 if(cur_pb->pb_stats->timinggain.count(newblk) == 0) {
                     cur_pb->pb_stats->timinggain[newblk] = 0;
                 }
                 if (timinggain > cur_pb->pb_stats->timinggain[newblk])
                     cur_pb->pb_stats->timinggain[newblk] = timinggain;
 
             }
         }
     }
 }

Here is the caller graph for this function:

static void update_total_gain	(	float	alpha,
		float	beta,
		boolean	timing_driven,
		boolean	connection_driven,
		boolean	global_clocks,
		t_pb *	pb
	)

static

Definition at line 1684 of file cluster.c.

                                                                     {
 
     /*Updates the total  gain array to reflect the desired tradeoff between*
      *input sharing (sharinggain) and path_length minimization (timinggain)*/
 
     int i, iblk, j, k;
     t_pb * cur_pb;
     int num_input_pins, num_output_pins;
     int num_used_input_pins, num_used_output_pins;
     t_model_ports *port;
 
     cur_pb = pb;
     while (cur_pb) {
 
         for (i = 0; i < cur_pb->pb_stats->num_marked_blocks; i++) {
             iblk = cur_pb->pb_stats->marked_blocks[i];
 
             if(cur_pb->pb_stats->connectiongain.count(iblk) == 0) {
                 cur_pb->pb_stats->connectiongain[iblk] = 0;
             }
             if(cur_pb->pb_stats->sharinggain.count(iblk) == 0) {
                 cur_pb->pb_stats->connectiongain[iblk] = 0;
             }
 
             /* Todo: This was used to explore different normalization options, can be made more efficient once we decide on which one to use*/
             num_input_pins = 0;
             port = logical_block[iblk].model->inputs;
             j = 0;
             num_used_input_pins = 0;
             while (port) {
                 num_input_pins += port->size;
                 if (!port->is_clock) {
                     for (k = 0; k < port->size; k++) {
                         if (logical_block[iblk].input_nets[j][k] != OPEN) {
                             num_used_input_pins++;
                         }
                     }
                     j++;
                 }
                 port = port->next;
             }
             if (num_input_pins == 0) {
                 num_input_pins = 1;
             }
 
             num_used_output_pins = 0;
             j = 0;
             num_output_pins = 0;
             port = logical_block[iblk].model->outputs;
             while (port) {
                 num_output_pins += port->size;
                 for (k = 0; k < port->size; k++) {
                     if (logical_block[iblk].output_nets[j][k] != OPEN) {
                         num_used_output_pins++;
                     }
                 }
                 port = port->next;
                 j++;
             }
             /* end todo */
 
             /* Calculate area-only cost function */
             if (connection_driven) {
                 /*try to absorb as many connections as possible*/
                 /*cur_pb->pb_stats->gain[iblk] = ((1-beta)*(float)cur_pb->pb_stats->sharinggain[iblk] + beta*(float)cur_pb->pb_stats->connectiongain[iblk])/(num_input_pins + num_output_pins);*/
                 cur_pb->pb_stats->gain[iblk] = ((1 - beta)
                         * (float) cur_pb->pb_stats->sharinggain[iblk]
                         + beta * (float) cur_pb->pb_stats->connectiongain[iblk])
                         / (num_used_input_pins + num_used_output_pins);
             } else {
                 /*cur_pb->pb_stats->gain[iblk] = ((float)cur_pb->pb_stats->sharinggain[iblk])/(num_input_pins + num_output_pins); */
                 cur_pb->pb_stats->gain[iblk] =
                         ((float) cur_pb->pb_stats->sharinggain[iblk])
                                 / (num_used_input_pins + num_used_output_pins);
 
             }
 
             /* Add in timing driven cost into cost function */
             if (timing_driven) {
                 cur_pb->pb_stats->gain[iblk] = alpha
                         * cur_pb->pb_stats->timinggain[iblk]
                         + (1.0 - alpha) * (float) cur_pb->pb_stats->gain[iblk];
             }
         }
         cur_pb = cur_pb->parent_pb;
     }
 }

Here is the caller graph for this function:

Variable Documentation

float* block_criticality = NULL

static

Definition at line 107 of file cluster.c.

int* critindexarray = NULL

static

Definition at line 108 of file cluster.c.

struct s_molecule_link* memory_pool

static

Definition at line 94 of file cluster.c.

int* net_output_feeds_driving_block_input

static

Definition at line 103 of file cluster.c.

struct s_molecule_link* unclustered_list_head

static

Definition at line 92 of file cluster.c.

int unclustered_list_head_size

Definition at line 93 of file cluster.c.

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation