static int check_for_duplicate_block_names (void) {
/* Checks that all blocks have duplicate names. Returns the number of *
* duplicate names. */
int error, iblk;
struct s_hash **block_hash_table, *h_ptr;
struct s_hash_iterator hash_iterator;
error = 0;
block_hash_table = alloc_hash_table ();
for (iblk=0;iblk<num_blocks;iblk++)
h_ptr = insert_in_hash_table (block_hash_table, block[iblk].name, iblk);
hash_iterator = start_hash_table_iterator ();
h_ptr = get_next_hash (block_hash_table, &hash_iterator);
while (h_ptr != NULL) {
if (h_ptr->count != 1) {
printf ("Error: %d blocks are named %s. Block names must be unique."
"\n", h_ptr->count, h_ptr->name);
error++;
}
h_ptr = get_next_hash (block_hash_table, &hash_iterator);
}
free_hash_table (block_hash_table);
return (error);
}
/**
* Allocates memory for models and loads the name of the packing pattern so that it can be identified and loaded with
* more complete information later
*/
static t_pack_patterns *alloc_and_init_pattern_list_from_hash(INP int ncount,
INOUTP struct s_hash **nhash) {
t_pack_patterns *nlist;
struct s_hash_iterator hash_iter;
struct s_hash *curr_pattern;
nlist = (t_pack_patterns*)my_calloc(ncount, sizeof(t_pack_patterns));
hash_iter = start_hash_table_iterator();
curr_pattern = get_next_hash(nhash, &hash_iter);
while (curr_pattern != NULL) {
assert(nlist[curr_pattern->index].name == NULL);
nlist[curr_pattern->index].name = my_strdup(curr_pattern->name);
nlist[curr_pattern->index].root_block = NULL;
nlist[curr_pattern->index].index = curr_pattern->index;
curr_pattern = get_next_hash(nhash, &hash_iter);
}
return nlist;
}
static void init_parse(int doall) {
/* Allocates and initializes the data structures needed for the parse. */
int i, j, len, nindex, pin_count;
int *tmp_ptr;
struct s_hash_iterator hash_iterator;
struct s_hash *h_ptr;
if (!doall) { /* Initialization before first (counting) pass */
num_nets = 0;
hash_table = alloc_hash_table ();
#define INITIAL_BLOCK_STORAGE 2000
temp_block_storage = INITIAL_BLOCK_STORAGE;
num_subblocks_per_block = my_malloc (INITIAL_BLOCK_STORAGE *
sizeof(int));
ch_subblock_bytes_avail = 0;
ch_subblock_next_avail_mem = NULL;
ch_subblock_head_ptr = NULL;
}
/* Allocate memory for second (load) pass */
else {
net = (struct s_net *) my_malloc (num_nets*sizeof(struct s_net));
block = (struct s_block *) my_malloc (num_blocks*
sizeof(struct s_block));
is_global = (boolean *) my_calloc (num_nets, sizeof(boolean));
num_driver = (int *) my_malloc (num_nets * sizeof(int));
temp_num_pins = (int *) my_malloc (num_nets * sizeof(int));
for (i=0;i<num_nets;i++) {
num_driver[i] = 0;
net[i].num_pins = 0;
}
/* Allocate block pin connection storage. Some is wasted for io blocks. *
* Method used below "chunks" the malloc of a bunch of small things to *
* reduce the memory housekeeping overhead of malloc. */
tmp_ptr = (int *) my_malloc (pins_per_clb * num_blocks * sizeof(int));
for (i=0;i<num_blocks;i++)
block[i].nets = tmp_ptr + i * pins_per_clb;
/* I use my_chunk_malloc for some storage locations below. my_chunk_malloc *
* avoids the 12 byte or so overhead incurred by malloc, but since I call it *
* with a NULL head_ptr, it will not keep around enough information to ever *
* free these data arrays. If you ever have compatibility problems on a *
* non-SPARC architecture, just change all the my_chunk_malloc calls to *
* my_malloc calls. */
hash_iterator = start_hash_table_iterator ();
h_ptr = get_next_hash (hash_table, &hash_iterator);
while (h_ptr != NULL) {
nindex = h_ptr->index;
pin_count = h_ptr->count;
net[nindex].blocks = (int *) my_chunk_malloc(pin_count *
sizeof(int), NULL, &chunk_bytes_avail, &chunk_next_avail_mem);
net[nindex].blk_pin = (int *) my_chunk_malloc (pin_count *
sizeof(int), NULL, &chunk_bytes_avail, &chunk_next_avail_mem);
/* For avoiding assigning values beyond end of pins array. */
temp_num_pins[nindex] = pin_count;
len = strlen (h_ptr->name);
net[nindex].name = (char *) my_chunk_malloc ((len + 1) *
sizeof(char), NULL, &chunk_bytes_avail, &chunk_next_avail_mem);
strcpy (net[nindex].name, h_ptr->name);
h_ptr = get_next_hash (hash_table, &hash_iterator);
}
/* Allocate storage for subblock info. (what's in each logic block) */
num_subblocks_per_block = (int *) my_realloc (num_subblocks_per_block,
num_blocks * sizeof (int));
subblock_inf = (t_subblock **) my_malloc (num_blocks *
sizeof(t_subblock *));
for (i=0;i<num_blocks;i++) {
if (num_subblocks_per_block[i] == 0)
subblock_inf[i] = NULL;
else {
subblock_inf[i] = (t_subblock *) my_chunk_malloc (
num_subblocks_per_block[i] * sizeof (t_subblock),
&ch_subblock_head_ptr, &ch_subblock_bytes_avail,
&ch_subblock_next_avail_mem);
for (j=0;j<num_subblocks_per_block[i];j++)
subblock_inf[i][j].inputs = (int *) my_chunk_malloc
(subblock_lut_size * sizeof(int), &ch_subblock_head_ptr,
&ch_subblock_bytes_avail, &ch_subblock_next_avail_mem);
}
}
}
/* Initializations for both passes. */
linenum = 0;
num_p_inputs = 0;
num_p_outputs = 0;
num_clbs = 0;
num_blocks = 0;
num_globals = 0;
}
