verilog_writer.h File Reference

#include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include <time.h>
#include "util.h"
#include "vpr_types.h"
#include "vpr_utils.h"
#include "globals.h"
#include "read_place.h"
#include "draw.h"
#include "stats.h"
#include "check_route.h"
#include "rr_graph.h"
#include "path_delay.h"
#include "net_delay.h"
#include "timing_place.h"
#include "read_xml_arch_file.h"
#include "ReadOptions.h"
#include "physical_types.h"
#include "string.h"
#include "stdlib.h"
#include "math.h"

Include dependency graph for verilog_writer.h:

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

Go to the source code of this file.

Data Structures
struct	found_pins
struct	found_connectivity

Typedefs
typedef struct found_pins	pb_list
typedef struct found_connectivity	conn_list

Functions
void	verilog_writer (void)
pb_list *	traverse_clb (t_pb *pb, pb_list *prim_list)
conn_list *	find_connected_primitives_downhill (int block_num, t_pb *pb, conn_list *list)
pb_list *	insert_to_linked_list (t_pb *pb_new, pb_list *list)
conn_list *	insert_to_linked_list_conn (t_pb *driver_new, t_pb *load_new, t_pb_graph_pin *driver_pin_, t_pb_graph_pin *load_pin_, float path_delay, conn_list *list)
void	traverse_linked_list (pb_list *list)
void	traverse_linked_list_conn (conn_list *list)
pb_list *	free_linked_list (pb_list *list)
conn_list *	free_linked_list_conn (conn_list *list)
void	instantiate_top_level_module (FILE *Verilog)
void	instantiate_wires (FILE *Verilog)
void	instantiate_input_interconnect (FILE *Verilog, FILE *SDF, char *clock_name)
void	instantiate_interconnect (FILE *Verilog, int block_num, t_pb *pb, FILE *SDF)
void	instantiate_primitive_modules (FILE *Verilog, char *clock_name, FILE *SDF)
char *	load_truth_table (int inputs, t_pb *pb)
char *	fix_name (char *name)
int	find_number_of_inputs (t_pb *pb)
int	find_index (char *row, int inputs)
void	interconnect_printing (FILE *fp, conn_list *downhill)
void	instantiate_SDF_header (FILE *SDF)
void	SDF_interconnect_delay_printing (FILE *SDF, conn_list *downhill)
void	sdf_LUT_delay_printing (FILE *SDF, t_pb *pb)
void	sdf_DFF_delay_printing (FILE *SDF, t_pb *pb)
void	SDF_Mult_delay_printing (FILE *SDF, t_pb *pb)
void	SDF_Adder_delay_printing (FILE *SDF, t_pb *pb)
char *	find_clock_name (void)
void	SDF_ram_single_port_delay_printing (FILE *SDF, t_pb *pb)
void	SDF_ram_dual_port_delay_printing (FILE *SDF, t_pb *pb)

Typedef Documentation

typedef struct found_connectivity conn_list

typedef struct found_pins pb_list

Function Documentation

char* find_clock_name

(

void

)

Definition at line 1035 of file verilog_writer.c.

{
  int j;
  char *clock_in_the_design=NULL;
  int clocks = 0;
  for(j=0 ; j<num_nets ; j++)/*Doing this to find the clock name in the design and storing it in clock_,*/
    {
      /* TODO fix this Hack: Currently detect if a clb_net is a clock using global and not vcc/gnd, need better way */
      if(clb_net[j].is_global == TRUE && strcmp(clb_net[j].name, "gnd") != 0 && strcmp(clb_net[j].name, "vcc") != 0)
    {
      clock_in_the_design = clb_net[j].name;
      clocks++;
    }
    }
  if (clocks > 1) {
    printf("The post-layout netlist generator presently handles single-clock designs only.  Your design contains %d clocks. \n"
       "Future VTR releases may support post-layout netlist generation for multi-clock designs.\n", clocks);
    exit(1);
  }
  return(clock_in_the_design);
}

Here is the caller graph for this function:

conn_list* find_connected_primitives_downhill	(	int	block_num,
		t_pb *	pb,
		conn_list *	list
	)

Definition at line 1096 of file verilog_writer.c.

{
  int i,j,k,q,r;
  int total_output_pins;
  int pin_number , port_number_out=-1 ,  pin_number_out , starting_block , next_block , vpck_net , pin_count;
  float delay , start_delay , end_delay;
 
  char *temp_port_name = (char *)malloc(1000 * sizeof(char));
  int total_output_ports = pb->pb_graph_node->num_output_ports; 
  int model_port_index;

  assert(temp_port_name);

  /*iterates through all output pins of the primitive "pb", and finds the other primitive and pin they connect to*/
  for(i=0 ; i < total_output_ports ; i++)
  {
      total_output_pins = pb->pb_graph_node->num_output_pins[i];
      for(j=0 ; j < total_output_pins ; j++)
      {   
      
      model_port_index =  pb->pb_graph_node->output_pins[i][j].port->model_port->index;

          pin_number = pb->pb_graph_node->output_pins[i][j].pin_count_in_cluster;  /*pin count of the output pin*/
          starting_block = pb->logical_block;  /*logical block index for the source primitive*/

      vpck_net = logical_block[starting_block].output_nets[model_port_index][j]; /*The index for the vpack_net struct corresponding to this source to sink(s) connections*/
     
      if (pb->rr_graph[pin_number].net_num != OPEN) /* If this output pin is used*/
      { /*Then we will use the logical_block netlist method for finding the connectivity and timing information*/
          if(vpck_net != OPEN)
          {

          for(k=1 ; k<vpack_net[vpck_net].num_sinks+1 ; k++)/*traversing through all the sink primitives that the source primitive connects to*/
          {
              next_block = vpack_net[vpck_net].node_block[k];/*next_blk holds the logical block index for the primitive that the source primitive connects to*/

#if 0

              // we now need to map between the port on the logical block to the port on the physical block
              t_pb_graph_pin* iPin = get_pb_graph_node_pin_from_vpack_net(vpck_net, k);
              port_number_out = iPin->port->index;

              // because of possible pin swaps, we need to find the physical on load block that
              // has the correct attached net
              for (q = 0; q <  logical_block[next_block].pb->pb_graph_node->num_input_pins[port_number_out]; q++) 
              {
            int physical_pin_pos = logical_block[next_block].pb->pb_graph_node->input_pins[port_number_out][q].pin_count_in_cluster;
            if (logical_block[next_block].pb->rr_graph[physical_pin_pos].net_num == vpck_net)
              break;
              }
              
              assert(q != logical_block[next_block].pb->pb_graph_node->num_input_pins[port_number_out]);

              pin_number_out = q;
#endif

              port_number_out = pin_number_out = -1;

              for (r = 0; r < logical_block[next_block].pb->pb_graph_node->num_input_ports; r++) {
             for (q = 0; q < logical_block[next_block].pb->pb_graph_node->num_input_pins[r]; q++) {
               int physical_pin_pos = logical_block[next_block].pb->pb_graph_node->input_pins[r][q].pin_count_in_cluster;
               if (logical_block[next_block].pb->rr_graph[physical_pin_pos].net_num == vpck_net) {
                 port_number_out = r;
                 pin_number_out = q;
                 r = logical_block[next_block].pb->pb_graph_node->num_input_ports;
                 break;
               }
             }
              }

              assert(port_number_out != -1);
              assert(pin_number_out != -1);
              
              int unswapped_pin_number =  vpack_net[vpck_net].node_block_pin[k];

              pin_count = logical_block[next_block].pb->pb_graph_node->input_pins[port_number_out][pin_number_out].pin_count_in_cluster;/*pin count for the sink pin*/
              assert(logical_block[next_block].pb->rr_graph[pin_count].tnode);
              
              start_delay = pb->rr_graph[pin_number].tnode->T_arr; /*The arrival time of the source pin*/       
              end_delay = logical_block[next_block].pb->rr_graph[pin_count].tnode->T_arr;/*The arrival time of the sink pin*/
              delay = end_delay - start_delay;   /*The difference of start and end arrival times is the delay for going from the source to sink pin*/       
              list=insert_to_linked_list_conn(pb , logical_block[next_block].pb , 
                              &pb->pb_graph_node->output_pins[i][j] , 
                              &logical_block[next_block].pb->pb_graph_node->input_pins[port_number_out][unswapped_pin_number] ,
                              delay , list);/*Insert this sink primitive in the linked list pointer to by "list"*/
              
            }
        }
        }
    }
    }
  free(temp_port_name);
  return(list);  
}

Here is the call graph for this function:

Here is the caller graph for this function:

int find_index	(	char *	row,
		int	inputs
	)

Definition at line 700 of file verilog_writer.c.

{
  int index=0;/*initially setting index to 0*/
  int or_=0x1;
  int i,length;

  for(i=strlen(row)-1 ; i>=0 ; i--)/*traverse through the columns of this truth table row*/
    {
      if(row[i] == '1')
    {
      index |= or_;/*if this column is logic 1, then set this column in index to logic 1.*/
    }
      or_ = or_ << 1;
    }
  length = strlen(row);
  if(length<inputs)/*if the number of used inputs to the lut is less than the total inputs to the lut*/
    {
      index = index << (inputs-(strlen(row)));/*shift the index value by the difference*/
    }
  return(index);

}

Here is the caller graph for this function:

int find_number_of_inputs

(

t_pb *

pb

)

Definition at line 743 of file verilog_writer.c.

{
  int i,j,count=0;
  for(i=0 ; i<pb->pb_graph_node->num_input_ports ; i++)
    {
      for(j=0 ; j<pb->pb_graph_node->num_input_pins[i] ; j++)
        {
          count++;
        }
    }
  return(count);
}

Here is the caller graph for this function:

char* fix_name

(

char *

name

)

Definition at line 725 of file verilog_writer.c.

{
  int i;

  char *new_;
  new_=my_strdup(name);

  for(i=0 ; new_[i]!='\0' ; i++)
    {
      if(new_[i]=='^' || (int)new_[i]<48 || ((int)new_[i]>57 && (int)new_[i]<65) || ((int)new_[i]>90 && (int)new_[i]<97) || (int)new_[i]>122)
        {
          new_[i]='_';
        }
    }
  return(new_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pb_list* free_linked_list

(

pb_list *

list

)

Definition at line 1243 of file verilog_writer.c.

{
  pb_list *current;
  pb_list *temp_free;
  
  current=list;
  while(current!=NULL)
    {
      temp_free=current;
      current=current->next;
      free(temp_free);
    }
  list = NULL;
  return(list);
}

Here is the caller graph for this function:

conn_list* free_linked_list_conn

(

conn_list *

list

)

Definition at line 1259 of file verilog_writer.c.

{
  conn_list *current;
  conn_list *temp_free;
  
  current=list;
  while(current!=NULL)
    {
      temp_free=current;
      current=current->next;
      free(temp_free);
    }
  list = NULL;
  return(list);
}

Here is the caller graph for this function:

pb_list* insert_to_linked_list	(	t_pb *	pb_new,
		pb_list *	list
	)

Definition at line 1191 of file verilog_writer.c.

{
  pb_list *new_list = (pb_list *)malloc(1 * sizeof(pb_list));
  assert(new_list);
  new_list->pb = pb_new;
  new_list->next = list;
  list = new_list;
  return(list);
}

Here is the caller graph for this function:

conn_list* insert_to_linked_list_conn	(	t_pb *	driver_new,
		t_pb *	load_new,
		t_pb_graph_pin *	driver_pin_,
		t_pb_graph_pin *	load_pin_,
		float	path_delay,
		conn_list *	list
	)

Definition at line 1201 of file verilog_writer.c.

{
  conn_list *new_list = (conn_list *)malloc(1 * sizeof(conn_list));
  assert(new_list);
  new_list->driver_pb = driver_new;
  new_list->load_pb = load_new;
  new_list->driver_pin = driver_pin_;
  new_list->load_pin = load_pin_;
  new_list->driver_to_load_delay = path_delay;
  new_list->next = list;
  list = new_list;
  return(list);
}

Here is the caller graph for this function:

void instantiate_input_interconnect	(	FILE *	Verilog,
		FILE *	SDF,
		char *	clock_name
	)

Definition at line 200 of file verilog_writer.c.

{
  int blocks;
  pb_list *current;
  pb_list *primitive_list = NULL;
  conn_list *downhill = NULL;

  for(blocks=0 ; blocks<num_blocks ; blocks++)
    {
      if(strcmp(block[blocks].pb->pb_graph_node->pb_type->name,"io"))/*if this is an io block*/
        {
      continue;
    }
      primitive_list = traverse_clb(block[blocks].pb , primitive_list);/*find all the primitives in that block*/
      for(current=primitive_list ; current!=NULL ; current=current->next)/*traversing through all the found primitives*/
    {
      if(strcmp(logical_block[current->pb->logical_block].model->name,"input"))/*if that primitive is an inpad*/
        {
          continue;
        }
      if(clock_name && !strcmp(current->pb->name,clock_name))/*If this is the clock signal, then don't instantiate an interconnect for it*/
        {
          continue;
        }
      downhill = find_connected_primitives_downhill(blocks , current->pb , downhill );/*find all the other primitives that it connects to*/
      
      /*traverse_linked_list_conn(downhill);*/
      interconnect_printing(verilog , downhill);/*Print the interconnects modules that connect the inputs to the rest of the design*/
      SDF_interconnect_delay_printing(SDF , downhill);/*Print the Delays of the interconnect module to the SDF file*/
      downhill = free_linked_list_conn(downhill);
      break;
    }
      primitive_list = free_linked_list(primitive_list);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void instantiate_interconnect	(	FILE *	Verilog,
		int	block_num,
		t_pb *	pb,
		FILE *	SDF
	)

Definition at line 580 of file verilog_writer.c.

{
  conn_list *downhill_connections = NULL;

  downhill_connections = find_connected_primitives_downhill(block_num , pb , downhill_connections);/*find all the other luts that the lut corresponding to "pb", connects to*/

  interconnect_printing(verilog , downhill_connections);
  SDF_interconnect_delay_printing(SDF , downhill_connections);
  downhill_connections = free_linked_list_conn(downhill_connections);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void instantiate_primitive_modules	(	FILE *	Verilog,
		char *	clock_name,
		FILE *	SDF
	)

multipliers and adders are handled quite similarly

Definition at line 237 of file verilog_writer.c.

{
  int i,j,k,h;
  pb_list *primitives = NULL;
  pb_list *current;

  int place_comma=0;
  char *truth_table = NULL;
  int inputs_to_lut;
  char *fixed_name = NULL;
  int power;
  for(i=0 ; i<num_blocks ; i++)
    {
      primitives = traverse_clb(block[i].pb , primitives);/*find all the primitives inside block i*/
      for(current=primitives ; current!=NULL ; current=current->next)/*traverse through all the found primitives*/
    {

      fixed_name = fix_name(current->pb->name);

      if(!strcmp(logical_block[current->pb->logical_block].model->name,"names"))/*if this primitive is a lut*/
        {
          inputs_to_lut = find_number_of_inputs(current->pb);
          assert((inputs_to_lut >= 3) && (inputs_to_lut <= 7));/*currently the primitives.v file only contains the verilog description for 4LUTs and 6LUTs*/
          truth_table=load_truth_table(inputs_to_lut,current->pb);/*load_truth_table will find the truth table corresponding to this lut, and store it in "truth_table"*/

          /*instantiating the 6 input lut module and passing the truth table as parameter*/

          power = 1 <<  inputs_to_lut;
          fprintf(fp , "\nLUT_%d #(%d'b%s) lut_%s(", inputs_to_lut , power , truth_table , fixed_name);

          free(truth_table);

          j=0;
          for(k=0 ; k<current->pb->pb_graph_node->num_input_ports ; k++)/*traverse through all the input pins of the lut*/
        {
          for(h=0 ; h<current->pb->pb_graph_node->num_input_pins[k] ; h++)
            {
              if(current->pb->rr_graph[current->pb->pb_graph_node->input_pins[k][h].pin_count_in_cluster].net_num != OPEN)/*check if that pin is used*/
            {
              if(place_comma)/*need this flag check to properly place the commas*/
                {
                  fprintf(fp , " , %s_input_%d_%d" , fixed_name , k , j); // j was h
                }
              else
                {
                  fprintf(fp , "%s_input_%d_%d" , fixed_name , k , j); // j was h
                  place_comma=1;
                }
              j++;
            }
            }
        }
          while(j<inputs_to_lut)/*if (after writing all the inputs to the lut module) there are still some                                                                               
                      inputs unused (i.e.  not all the inputs to the lut are used) place a logic zero instead*/
        {
          if(place_comma && j)
            {
              j++;
              fprintf(fp , " , 1'b0");
            }
          else
            {
              j++;
              fprintf(fp , "1'b0");
              place_comma=1;
            }
        }

          place_comma=0;
          fprintf(fp , " , %s_output_0_0 );\n\n",fixed_name);/*finaly write the output of the module*/

          instantiate_interconnect(fp,i,current->pb,SDF);/*this function will instantiate the routing                                                                                    
                                                                          interconnect from the output of this lut to                                                                         
                                                                          the inputs of other luts that it connects to*/
          sdf_LUT_delay_printing(SDF , current->pb);/*This function will instantiate the internal delays of the lut to the SDF file*/
        }
      else if(!strcmp(logical_block[current->pb->logical_block].model->name,"latch"))/*If this primitive is a Flip Flop*/
        {
          char *fixed_clock_name;
          fixed_clock_name = fix_name(clock_name);
          fprintf(fp , "\nD_Flip_Flop DFF_%s(%s_output_0_0 , %s_input_0_0 , 1'b1 , 1'b1 , %s_output_0_0 );\n",fixed_name,fixed_clock_name,fixed_name,fixed_name);
          instantiate_interconnect(fp , i , current->pb , SDF);
          sdf_DFF_delay_printing(SDF , current->pb);
          free(fixed_clock_name);
        }
      else if(!strcmp(logical_block[current->pb->logical_block].model->name,"multiply") || 
          !strcmp(logical_block[current->pb->logical_block].model->name,"adder")) /*If this primitive is a multiplier or an adder */
        {
          /** multipliers and adders are handled quite similarly **/

          int mult = !strcmp(logical_block[current->pb->logical_block].model->name,"multiply");
          int num_inputs = logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[0];/*what is the data width*/
          int i_port , i_pin ;        
          place_comma = 0;
          if (mult)
        fprintf(fp , "\nmult #(%d)%s(" , num_inputs , fixed_name); 
          else
        fprintf(fp , "\nripple_adder #(%d)%s(" , num_inputs , fixed_name); 
    
          /*Traversing through all the input ports of this multiplier*/
          for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_ports ; i_port++)
        {
          if(i_port == 0)/*This if-else statement will make sure that the signals are concatinated in verilog*/
            {
              fprintf(fp , "{");
            }
          else{
            fprintf(fp , ",{");
          }
          place_comma = 0;
          /*Traversing through all the input pins of this input port*/
          for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
            {
              /*If this input pin is used*/
              if(current->pb->rr_graph[current->pb->pb_graph_node->input_pins[i_port][i_pin].pin_count_in_cluster].net_num != OPEN)
            {
              if(place_comma)/*need this flag check to properly place the commas*/
                {
                  fprintf(fp , " , %s_input_%d_%d" , fixed_name , i_port , i_pin);
                }
              else
                {
                  fprintf(fp , "%s_input_%d_%d" , fixed_name , i_port , i_pin);
                  place_comma=1;
                }
            
            }
              else{/*If this pin was not used, then instantiate logic zero*/
            if(place_comma)
              {
                fprintf(fp , ", 1'b0");
              }
            else{
              fprintf(fp , " 1'b0");
              place_comma = 1;
            }
              }
            }
          fprintf(fp , "}");/*End concatination*/
        }
          /*Traversing through all the output ports of this multiplier*/
          for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_ports ; i_port++)
        {
          fprintf(fp , ",{");/*Since there is only a single output port for multipliers we only need to concatinate once*/
          place_comma = 0;
          /*Traversing through all the output pins of this output port*/
          for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
            {
              if(place_comma)
            {
              fprintf(fp , ", %s_output_%d_%d" , fixed_name , i_port , i_pin);
            }
              else{
            fprintf(fp , " %s_output_%d_%d" , fixed_name , i_port , i_pin);
            place_comma = 1;
              }
            }
          fprintf(fp , "}");/*End concatination*/
        }
          fprintf(fp , ");\n\n");
          instantiate_interconnect(fp , i , current->pb , SDF);
          if (mult)
        SDF_Mult_delay_printing(SDF, current->pb);
          else
        SDF_Adder_delay_printing(SDF, current->pb);
        }
      else if(!strcmp(logical_block[current->pb->logical_block].model->name,"single_port_ram")){/*If this primitive is a single port RAM block*/
        
        char *fixed_clock_name;
        int i_port,i_pin;
        int data_width,addr_width;
        
        data_width = logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[1];/*the data_width (word width) is the number of inputs in the data port*/
        addr_width = logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[0];/*the addr_width (address width) is the number of inputs in the addr port*/

        fprintf(fp , "\nsingle_port_ram #(%d,%d)%s(" , addr_width , data_width , fixed_name);/*Passing the address width and data width as a verilog parameter*/
        /*Traversign through all the input ports of this single_port_ram*/
        for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_ports ; i_port++)
          {
        if(i_port == 0)/*This if-else statement will make sure that the signals are concatinated in verilog*/
          {
            fprintf(fp , "{");
          }
        else{
          fprintf(fp , ",{");
        }
        place_comma = 0;
        /*Traversing through all the input pins of this input port*/
        for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
          {
            /*If this input pin is used*/
            if(current->pb->rr_graph[current->pb->pb_graph_node->input_pins[i_port][i_pin].pin_count_in_cluster].net_num != OPEN)
              {
            if(place_comma)/*need this flag check to properly place the commas*/
              {
                fprintf(fp , " , %s_input_%d_%d" , fixed_name , i_port , i_pin);
              }
            else
              {
                fprintf(fp , "%s_input_%d_%d" , fixed_name , i_port , i_pin);
                place_comma=1;
              }
              }
            else{/*If this input pin is not used then instantiate a logic zero*/
              if(place_comma)
            {
              fprintf(fp , ", 1'b0");
            }
              else{
            fprintf(fp , " 1'b0");
            place_comma = 1;
              }
            }
          }
        fprintf(fp , "}");/*End concatination*/
          }
        /*Traversign through all the output ports of this single_port_ram*/
        for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_ports ; i_port++)
          {
        fprintf(fp , ",{");/*Since there is only a single output port for single_port_rams we only need to concatinate once*/
        place_comma = 0;
        /*Traverse through all the output pins of this output port*/
        for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
          {
            if(place_comma)
              {
            fprintf(fp , ", %s_output_%d_%d" , fixed_name , i_port , i_pin);
              }
            else{
              fprintf(fp , " %s_output_%d_%d" , fixed_name , i_port , i_pin);
              place_comma = 1;
            }
          }
        fprintf(fp , "}");/*End concatination*/
          }
        fixed_clock_name = fix_name(clock_name);/*Must also instantiate the clock signal to the RAM block*/
        fprintf(fp , ", %s_output_0_0" , fixed_clock_name);
        fprintf(fp , ");\n\n");
        free(fixed_clock_name);
        instantiate_interconnect(fp , i , current->pb , SDF);
        SDF_ram_single_port_delay_printing(SDF , current->pb);
      }
      else if(!strcmp(logical_block[current->pb->logical_block].model->name,"dual_port_ram")){/*If this primitive is a dual_port_ram*/
        
        int data1_width,data2_width,addr1_width,addr2_width,i_port,i_pin;
        char *fixed_clock_name;

        /*The Input ports of dual port rams are in this order:
         0-addr1
         1-addr2
         2-data1
         3-data2
         4-we1
         5-we2

        The verilog primitives module only accepts instatiation in this order else the simulation will give error or give incorrect simulation results*/

        data1_width = current->pb->pb_graph_node->num_input_pins[2];/*the data_width (word width) for the first port, is the number of inputs in the first data port*/
        addr1_width = current->pb->pb_graph_node->num_input_pins[0];/*the addr_width (address width) for the first port, is the number of inputs in the first addr port*/
        data2_width = current->pb->pb_graph_node->num_input_pins[3];/*the data_width (word width) for the second port, is the number of inputs in the second data port*/
        addr2_width = current->pb->pb_graph_node->num_input_pins[1];/*the addr_width (address width) for the second port is the number of inputs in the second addr port*/
        
        fprintf(fp , "\ndual_port_ram #(%d,%d,%d,%d)%s(" , addr1_width , data1_width , addr2_width , data2_width , fixed_name);/*passing the addr_wdith and data_wdith for both ports as verilog parameter*/
       
        for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_ports ; i_port++)
              {
                if(i_port == 0)
                  {
                    fprintf(fp , "{");
                  }
                else{
                  fprintf(fp , ",{");
                }
                place_comma = 0;
        /*Traversign through all the input pins of this input port*/
                for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_input_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
                  {
            /*If this pin is used*/
                    if(current->pb->rr_graph[current->pb->pb_graph_node->input_pins[i_port][i_pin].pin_count_in_cluster].net_num != OPEN)
                      {
                        if(place_comma)/*need this flag check to properly place the commas*/
                          {
                            fprintf(fp , " , %s_input_%d_%d" , fixed_name , i_port , i_pin);
                          }
                        else
                          {
                            fprintf(fp , "%s_input_%d_%d" , fixed_name , i_port , i_pin);
                            place_comma=1;
                          }
                      }
                    else{/*If this pin is not used, then instantiate logic zero instead*/
                      if(place_comma)
                        {
                          fprintf(fp , ", 1'b0");
                        }
                      else{
                        fprintf(fp , " 1'b0");
                        place_comma = 1;
                      }
                    }
                  }
                fprintf(fp , "}");/*End concatination*/
              }
        /*Traversign through all the output ports of this dual_port_ram*/
        for(i_port=0 ; i_port<logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_ports ; i_port++)
              {
                fprintf(fp , ",{");
                place_comma = 0;
        /*Traverse through all the output pins of this output port*/
                for(i_pin=logical_block[current->pb->logical_block].pb->pb_graph_node->num_output_pins[i_port]-1 ; i_pin>=0 ; i_pin--)
                  {
                    if(place_comma)
                      {
                        fprintf(fp , ", %s_output_%d_%d" , fixed_name , i_port , i_pin);
                      }
                    else{
                      fprintf(fp , " %s_output_%d_%d" , fixed_name , i_port , i_pin);
                      place_comma = 1;
                    }
                  }
                fprintf(fp , "}");
              }
            fixed_clock_name = fix_name(clock_name);/*Must also instantiate the clock */
            fprintf(fp , ", %s_output_0_0" , fixed_clock_name);
            fprintf(fp , ");\n\n");
            free(fixed_clock_name);
            instantiate_interconnect(fp , i , current->pb , SDF);
            SDF_ram_dual_port_delay_printing(SDF , current->pb);

      }
      else if(strcmp(logical_block[current->pb->logical_block].model->name,"input") && strcmp(logical_block[current->pb->logical_block].model->name,"output"))
        /*If this primitive is anything else, but an input or an output*/
        {
          printf("Failed to generate post-synthesized verilog and sdf files. Primitive %s is unknown.\n\nAcceptable primitives are: LUTs, Flip Flops, IOs, Adders, Rams, and Multiplier blocks.\n\nTo generate the post synthesized verilog and SDF files successfully, you must append the verilog code for the %s to the primitives.v file, and contact the VPR developers team on the website: http://code.google.com/p/vtr-verilog-to-routing/ to update the VPR source code to handle the new primitive. \n",logical_block[current->pb->logical_block].model->name , logical_block[current->pb->logical_block].model->name);
          exit(1);
        }
      free(fixed_name);
    }
      primitives = free_linked_list(primitives);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void instantiate_SDF_header

(

FILE *

SDF

)

Definition at line 141 of file verilog_writer.c.

{
  fprintf(SDF , "(DELAYFILE\n\t(SDFVERSION \"2.1\")\n\t(DIVIDER /)\n\t(TIMESCALE 1 ps)\n\n ");
}

Here is the caller graph for this function:

void instantiate_top_level_module

(

FILE *

Verilog

)

Definition at line 97 of file verilog_writer.c.

{
  int i,place_comma;
  pb_list *temp=NULL;
  pb_list *current;
  char *fixed_name = NULL;
 

  fprintf(verilog , "module %s(\n" , blif_circuit_name);
  place_comma=0;
  for(i=0 ; i<num_blocks ; i++)/*go through all the blocks in the design*/
    {
      if(!strcmp(block[i].pb->pb_graph_node->pb_type->name,"io"))/*if this block is an i/o block*/
        {
          temp = traverse_clb(block[i].pb , temp);/*find all the primitives in this block*/
          for(current=temp ; current!=NULL ; current=current->next)/*traverse through all the primitives in this block*/
            {
              if(place_comma){       /*need this for correct placement of commas and verilog syntax correctness*/
                fprintf(verilog ,"\t,");
              }
              else{
                fprintf(verilog ,"\t");
                place_comma=1;
              }
              fixed_name = fix_name(current->pb->name);/*need to do this, because some names contain characters that cause syntax errors in verilog (e.g. '~' , '^',)*/
              if(!strcmp(logical_block[current->pb->logical_block].model->name,"input")){/*if this primitive is an input pin, declare as input*/

                fprintf(verilog , "input %s\n",fixed_name);/*declaring the inputs*/
    
         
              }
              else if(!strcmp(logical_block[current->pb->logical_block].model->name,"output")){

                fprintf(verilog , "output %s\n",fixed_name);/*declaring the outputs*/
          }
              free(fixed_name);
            }
        }
      temp = free_linked_list(temp);
    }
  fprintf(verilog , ");\n\n");

}

Here is the call graph for this function:

Here is the caller graph for this function:

void instantiate_wires

(

FILE *

Verilog

)

Definition at line 147 of file verilog_writer.c.

{
  int i,j,k;
  pb_list *primitive_list=NULL;
  pb_list *current;
  char *fixed_name = NULL;

  for(i=0; i<num_blocks ; i++)/*go through all the blocks in the design*/
    {
      primitive_list = traverse_clb(block[i].pb , primitive_list);/*find all the primitives in this block*/

      for(current=primitive_list ; current!=NULL ; current=current->next)/*traverse through all the primitives in this block*/
        {
          fixed_name = fix_name(current->pb->name);/*need to do this, because some names contain characters that cause syntax errors in verilog (e.g. '~' , '^',)*/
          for(j=0 ; j<current->pb->pb_graph_node->num_output_ports ; j++)/*go through all the found primitives and instantiate their output wires*/
            {
              for(k=0 ; k<current->pb->pb_graph_node->num_output_pins[j] ; k++)
                {
                 
                    
                      fprintf(verilog , "wire %s_output_%d_%d;\n" , fixed_name , j , k);

                      if(!strcmp(logical_block[current->pb->logical_block].model->name,"input"))/*if that pin is an inpad pin then have to connect the                                        
                                                                                                  inputs to the module to this wire*/
            {
                          fprintf(verilog , "assign %s_output_%d_%d = %s;\n\n",fixed_name , j , k , fixed_name);
                        }

                    
                }
            }
          for(j=0 ; j<current->pb->pb_graph_node->num_input_ports ; j++)/*instantiating the input wire modules for each primitive*/
            {
              for(k=0 ; k<current->pb->pb_graph_node->num_input_pins[j] ; k++)
                {          
          fprintf(verilog , "wire %s_input_%d_%d;\n" , fixed_name , j , k);
          if(!strcmp(logical_block[current->pb->logical_block].model->name,"output"))/*if that pin is an outpad then have to connect the input to the outputs 
                                                   of the top level module*/
            {
              fprintf(verilog , "assign %s = %s_input_%d_%d;\n\n",fixed_name , fixed_name , j , k);
            }     
                }
            }
          free(fixed_name);
        }
      primitive_list = free_linked_list(primitive_list);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void interconnect_printing	(	FILE *	fp,
		conn_list *	downhill
	)

Definition at line 757 of file verilog_writer.c.

{
  char *fixed_name1;
  char *fixed_name2;
  conn_list *connections;
  int port_number_out=-1,port_number_in=-1,i;  

    for(connections=downhill ; connections!=NULL ; connections=connections->next)/*traverse through all the connected primitives and instantiate a routing interconect module*/
    {
      fixed_name1 = fix_name(connections->driver_pb->name);
      fixed_name2 = fix_name(connections->load_pb->name);

      for(i=0 ; i<connections->load_pin->parent_node->num_input_ports ; i++)
    {
      if(!strcmp(connections->load_pin->parent_node->input_pins[i][0].port->name,connections->load_pin->port->name))
        {
          port_number_out = i;
        }
    }
      for(i=0 ; i<connections->driver_pin->parent_node->num_output_ports ; i++)
        {
          if(!strcmp(connections->driver_pin->parent_node->output_pins[i][0].port->name,connections->driver_pin->port->name))
            {
              port_number_in = i;
            }
        }     
      assert(port_number_out >= 0 && port_number_in >= 0);

      fprintf(fp , "interconnect routing_segment_%s_output_%d_%d_to_%s_input_%d_%d( %s_output_%d_%d , %s_input_%d_%d );\n",
              fixed_name1 , port_number_in/*connections->driver_pin->port->port_index_by_type*/ , connections->driver_pin->pin_number,
              fixed_name2 , port_number_out , connections->load_pin->pin_number,
              fixed_name1 , port_number_in/*connections->driver_pin->port->port_index_by_type*/ , connections->driver_pin->pin_number,
              fixed_name2 , port_number_out , connections->load_pin->pin_number);
      
      free(fixed_name1);
      free(fixed_name2);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* load_truth_table	(	int	inputs,
		t_pb *	pb
	)

Definition at line 595 of file verilog_writer.c.

{
  int number_of_dont_cares=0;
  int tries,shift,which_row,i,j;
  int possibles = 1 << inputs;
  char *tt_row_blif;
  char *possible_row = (char *)malloc(inputs+1 * sizeof(char));
  char *tt = (char *)malloc((possibles+1) * sizeof(char));
  struct s_linked_vptr *current;
  int number_of_used_inputs_to_lut;
  char set_to;
  assert(possible_row);
  assert(tt);
 
  if (logical_block[pb->logical_block].truth_table) { // ??? janders ???? how can you have a LUT without a truth table???
    tt_row_blif =  (char *)logical_block[pb->logical_block].truth_table->data_vptr;
  }
  else { // must be producing a GROUND
    for (i = 0; i < possibles; i++)
      tt[i] = '0';
    tt[possibles] = '\0';
    free(possible_row);
    return tt;
  }
  set_to = tt_row_blif[strlen(tt_row_blif)-1];

  /*filling the truth table with the state that is opposite to the output state in the blif truth table*/
  if(set_to =='1')
    {
      for(i=0 ; i<possibles ; i++)
        {
          tt[i]='0';
        }
    }
  else{
    for(i=0 ; i<possibles ; i++)
      {
        tt[i]='1';
      }
  }
  tt[possibles] = '\0';/*null terminating the tt string*/
  /*The code bellow will populate the tt[] array with the truth table of the LUT with "pb"
    
    The truth table is stored as a linked list in the VPR. Each node in the linked list stores one line of the truth table. This line is in the exact same format as in the blif file. Each line of the truth table is read by traversing through each node of the linked list. The code bellow then parses each line of the truth table. That line might not have all the inputs to the lut specified, or there could be don't cares in that line of the truth table. at the end we need the output value of the LUT for every possible combination of inputs, which is not given in the blif truth table.

  The code bellow first counts the number of don't cares in that line of the truth table. It also creates a temporary string "possible_row". and there are n=2^(number of don't cares) possibilities in a particular line of the truth table So in a separate loop we find the nth possibility of the truth table*/

  for(current=logical_block[pb->logical_block].truth_table ; current!=NULL ; current=current->next)/*traversing through all the lines of the blif truth table*/
    {

      tt_row_blif=(char *)current->data_vptr;/*tt_row_blif stores the current truth table line*/


      /*counting number of don't cares in this line of the blif truth table*/
      number_of_used_inputs_to_lut = strlen(tt_row_blif)-2;/*used*/
      if(number_of_used_inputs_to_lut == 0)/*If this is a constant generator, then the truth table only contains the constant value that it generates.*/
        {
          for(i=0 ; i<possibles ; i++)
            {
              tt[i] = tt_row_blif[1];
            }
        }
      else{
        for(i=0; i<inputs ; i++)
          {
            if(tt_row_blif[i] == '-')
              {
                number_of_dont_cares++;
              }
          }
        tries = 1 << number_of_dont_cares;/*how many possibilities are there for this line of the blif truth table*/

        for(i=0 ; i<(tries) ; i++)/*traverse through all the possibilities for this line of the blif truth table*/
          {
            shift=number_of_dont_cares-1;
            for(j=0 ; j<number_of_used_inputs_to_lut ; j++)/*going through all the columns of the blif truth table*/
              {
                if(tt_row_blif[j]=='-')/*if this column represents a don't care*/
                  {
                    /*creating a temporary truth table row by taking different values of the possiblity 'i' depending on the shift value*/
                    if(((i>>shift) & 0x1) == 1)
                      {
                        possible_row[j] = '1';
                      }
                    else{
                      possible_row[j] = '0';
                    }
                    shift--;/*reduce the shift value by one*/
                  }
                else
                  {
                    possible_row[j]=tt_row_blif[j];
                  }
              }
            possible_row[j]=0x0;/*null terminate the temporary truth table row*/
            which_row = find_index(possible_row,inputs);/*find index returns the index of the 64bit truth table that this temporary truth table row corresponds to*/
            tt[possibles-1-which_row] = set_to;
          }
      }
      number_of_dont_cares = 0;
    }
  free(possible_row);
  return(tt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SDF_Adder_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 940 of file verilog_writer.c.

{
  int i, j, k;
  int total_input_ports = pb->pb_graph_node->num_input_ports;
  int pin_count;
  char *fixed_name;
  int record = 0;
  
  fixed_name = fix_name(pb->name);

  for (i = 0; i < total_input_ports; i++) {

    for (j = 0; j < pb->pb_graph_node->num_input_pins[i]; j++) {

      pin_count = pb->pb_graph_node->input_pins[i][j].pin_count_in_cluster;
      
      t_tnode* tNodeInput = pb->rr_graph[pin_count].tnode; // source pin of timing arc

      if (!tNodeInput)
    continue; // no timing information on pin
      
      for (k = 0; k < tNodeInput->num_edges; k++) {   

    t_tnode tNodeOutput = tnode[tNodeInput->out_edges[k].to_node]; // dest pin of timing arc
    int del = tNodeInput->out_edges[k].Tdel * 1.0E12 + 0.5;

    if (!record) { // print the SDF record header
      fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"ripple_adder\")\n\t(INSTANCE inst/%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" ,  fixed_name);
      record = 1;
    }

    fprintf(SDF , "\t\t\t(IOPATH %s %s (%d:%d:%d)(%d:%d:%d))\n" , tNodeInput->pb_graph_pin->port->name, 
        tNodeOutput.pb_graph_pin->port->name,
        del , del , del , del , del , del);

      }
      j =  pb->pb_graph_node->num_input_pins[i]; // skip to the next port -- JANDERS to fix
      // what we really want to do here is find the max delay between any pin of the input port, to any pin of the output port
    }
  }

  if (record)
    fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sdf_DFF_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 889 of file verilog_writer.c.

{
  char *fixed_name;
  float internal_delay;
  int del,pin_count;

  fixed_name = fix_name(pb->name);
  fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"D_Flip_Flop\")\n\t(INSTANCE inst/DFF_%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" , fixed_name);

  pin_count = pb->pb_graph_node->output_pins[0][0].pin_count_in_cluster; // the Q output of the FF (which has only a single output port and pin)
  assert(pb->rr_graph[pin_count].tnode);
  internal_delay = pb->rr_graph[pin_count].tnode->T_arr * 1.0E12 + 0.5;
  del = (int)internal_delay;

  fprintf(SDF , "\t\t\t(IOPATH (posedge clock) Q (%d:%d:%d)(%d:%d:%d))\n" , del , del , del , del , del , del);
  fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SDF_interconnect_delay_printing	(	FILE *	SDF,
		conn_list *	downhill
	)

Definition at line 797 of file verilog_writer.c.

{
  conn_list *connections;
  char *fixed_name1;
  char *fixed_name2;
  float internal_delay;
  int del;
  int port_number_out=-1,port_number_in=-1,i;  

   for(connections=downhill ; connections!=NULL ; connections=connections->next)/*traverse through all the connected primitives and instantiate a routing interconect module*/
    {
      fixed_name1 = fix_name(connections->driver_pb->name);
      fixed_name2 = fix_name(connections->load_pb->name);

      for(i=0 ; i<connections->load_pin->parent_node->num_input_ports ; i++)
    {
      if(!strcmp(connections->load_pin->parent_node->input_pins[i][0].port->name,connections->load_pin->port->name))
        {
          port_number_out = i;
        }
    }
      for(i=0 ; i<connections->driver_pin->parent_node->num_output_ports ; i++)
        {
          if(!strcmp(connections->driver_pin->parent_node->output_pins[i][0].port->name,connections->driver_pin->port->name))
            {
              port_number_in = i;
            }
        }     
      internal_delay = connections->driver_to_load_delay;
      internal_delay = internal_delay * 1000000000000.00; /*converting the delay from seconds to picoseconds*/
      internal_delay = internal_delay + 0.5;              /*Rounding the delay to the nearset picosecond*/
      del = (int)internal_delay;

      fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"interconnect\")\n\t(INSTANCE inst/routing_segment_%s_output_%d_%d_to_%s_input_%d_%d)\n" ,
          fixed_name1 , port_number_in/*connections->driver_pin->port->port_index_by_type*/ , connections->driver_pin->pin_number,
              fixed_name2 , port_number_out , connections->load_pin->pin_number);
      fprintf(SDF , "\t\t(DELAY\n\t\t(ABSOLUTE\n\t\t\t(IOPATH datain dataout (%d:%d:%d)(%d:%d:%d))\n\t\t)\n\t\t)\n\t)\n" ,
              del , del , del , del , del , del);

      free(fixed_name1);
      free(fixed_name2);

    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sdf_LUT_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 843 of file verilog_writer.c.

{
  char *fixed_name;
  int j,pin_count;
  float internal_delay;
  int del;
  int logical_block_index = pb->logical_block;
  int record = 0;

  fixed_name = fix_name(pb->name);

  for(j=0 ; j < pb->pb_graph_node->num_input_pins[0] ; j++)/*Assuming that LUTs have a single input port*/
  {
     if (logical_block[logical_block_index].input_nets[0][j] != OPEN) 
      {
      
      int q;
      pin_count = OPEN;
      for (q = 0; q < pb->pb_graph_node->num_input_pins[0]; q++)
      {
        pin_count = pb->pb_graph_node->input_pins[0][q].pin_count_in_cluster;
        if (logical_block[logical_block_index].pb->rr_graph[pin_count].net_num == logical_block[logical_block_index].input_nets[0][j])
          break;
      }
      
      assert(q != pb->pb_graph_node->num_input_pins[0]);

          internal_delay = pb->rr_graph[pin_count].tnode->out_edges->Tdel;
          internal_delay = internal_delay * 1000000000000.00;/*converting the delay from seconds to picoseconds*/
          internal_delay = internal_delay + 0.5;             /*Rounding the delay to the nearset picosecond*/
          del = (int)internal_delay;

      if (!record) { // print the SDF record header
        fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"LUT_%d\")\n\t(INSTANCE inst/lut_%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" , find_number_of_inputs(pb) , fixed_name);
        record = 1;
      }

          fprintf(SDF , "\t\t\t(IOPATH inter%d/datain inter%d/dataout (%d:%d:%d)(%d:%d:%d))\n" , j , j , del , del , del , del , del , del);
        }
    }
  if (record) 
    fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SDF_Mult_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 908 of file verilog_writer.c.

{
  char *fixed_name;
  int pin_count;
  float internal_delay;
  int del;

  fixed_name = fix_name(pb->name);
  fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"mult\")\n\t(INSTANCE inst/%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" ,  fixed_name);


  pin_count = pb->pb_graph_node->input_pins[0][0].pin_count_in_cluster;
  assert(pb->rr_graph[pin_count].tnode);
  internal_delay = pb->rr_graph[pin_count].tnode->out_edges->Tdel;
  internal_delay = internal_delay * 1000000000000.00;/*converting the delay from seconds to picoseconds*/
  internal_delay = internal_delay + 0.5;             /*Rounding the delay to the nearset picosecond*/
  del = (int)internal_delay;
  fprintf(SDF , "\t\t\t(IOPATH delay/A delay/B (%d:%d:%d)(%d:%d:%d))\n" , del , del , del , del , del , del);
  
  pin_count = pb->pb_graph_node->input_pins[1][0].pin_count_in_cluster;
  assert(pb->rr_graph[pin_count].tnode);
  internal_delay = pb->rr_graph[pin_count].tnode->out_edges->Tdel;
  internal_delay = internal_delay * 1.0E12;/*converting the delay from seconds to picoseconds*/
  internal_delay = internal_delay + 0.5;             /*Rounding the delay to the nearset picosecond*/
  del = (int)internal_delay;
  fprintf(SDF , "\t\t\t(IOPATH delay2/A delay2/B (%d:%d:%d)(%d:%d:%d))\n" , del , del , del , del , del , del);
  
  fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SDF_ram_dual_port_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 1011 of file verilog_writer.c.

{
  //  int num_inputs;
  char *fixed_name;
  int pin_count;
  float internal_delay;
  int del;

  //  num_inputs = pb->pb_graph_node->num_input_pins[0];
  fixed_name = fix_name(pb->name);
  fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"dual_port_ram\")\n\t(INSTANCE inst/%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" ,  fixed_name);

  pin_count = pb->pb_graph_node->output_pins[0][0].pin_count_in_cluster; // an output pin of the RAM
  assert(pb->rr_graph[pin_count].tnode);
  internal_delay = pb->rr_graph[pin_count].tnode->T_arr * 1.0E12 + 0.5;
  del = (int)internal_delay;

  fprintf(SDF , "\t\t\t(IOPATH (posedge clock) out1 (%d:%d:%d)(%d:%d:%d))" , del , del , del , del , del , del);
  fprintf(SDF , "\t\t\t(IOPATH (posedge clock) out2 (%d:%d:%d)(%d:%d:%d))" , del , del , del , del , del , del);

  fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SDF_ram_single_port_delay_printing	(	FILE *	SDF,
		t_pb *	pb
	)

Definition at line 987 of file verilog_writer.c.

{
  //  int num_inputs;
  char *fixed_name;
  int pin_count;
  float internal_delay;
  int del;

  //  num_inputs = pb->pb_graph_node->num_input_pins[0];
  fixed_name = fix_name(pb->name);
  fprintf(SDF , "\t(CELL\n\t(CELLTYPE \"single_port_ram\")\n\t(INSTANCE inst/%s)\n\t\t(DELAY\n\t\t(ABSOLUTE\n" ,  fixed_name);

  pin_count = pb->pb_graph_node->output_pins[0][0].pin_count_in_cluster; // an output pin of the RAM
  assert(pb->rr_graph[pin_count].tnode);
  internal_delay = pb->rr_graph[pin_count].tnode->T_arr * 1.0E12 + 0.5;
  del = (int)internal_delay;

  fprintf(SDF , "\t\t\t(IOPATH (posedge clock) out (%d:%d:%d)(%d:%d:%d))" , del , del , del , del , del , del);

  fprintf(SDF , "\t\t)\n\t\t)\n\t)\n");
  free(fixed_name);

}

Here is the call graph for this function:

Here is the caller graph for this function:

pb_list* traverse_clb	(	t_pb *	pb,
		pb_list *	prim_list
	)

Definition at line 1063 of file verilog_writer.c.

{
  int i,j;
  const t_pb_type *pb_type;
  if(pb == NULL || pb->name == NULL) {  /*Reached a pb with no content*/
    return(prim_list);
  }
  
  pb_type = pb->pb_graph_node->pb_type;

  if(pb->child_pbs == NULL) {/*reached a primitive*/
    prim_list = insert_to_linked_list(pb , prim_list);   /*add the primitive to the linked list*/
  }

  if(pb_type->num_modes > 0) {                                              /*Traversing through the children of the pb*/
    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++) {
    prim_list = traverse_clb(&(pb->child_pbs[i][j]) , prim_list);
      }
    }  
  }

  return(prim_list);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void traverse_linked_list

(

pb_list *

list

)

Definition at line 1233 of file verilog_writer.c.

{
  pb_list *current;
  
  for(current=list ; current!=NULL ; current=current->next)
    {
      printf("type: %s , name: %s \n", logical_block[current->pb->logical_block].model->name , current->pb->name);
    }
}

void traverse_linked_list_conn

(

conn_list *

list

)

Definition at line 1216 of file verilog_writer.c.

{
  conn_list *current;
  
  for(current=list ; current != NULL ; current=current->next)
    {
      printf("    driver=> type: %s , name: %s , output: [%d][%d] , load=> type: %s , name: %s input: [%d][%d]\npath delay: %e\n\n",current->driver_pb->pb_graph_node->pb_type->name , 
         current->driver_pb->name,
         current->driver_pin->port->index , current->driver_pin->pin_number ,
         current->load_pb->pb_graph_node->pb_type->name,
         current->load_pb->name,
         current->load_pin->port->index , current->load_pin->pin_number,
         current->driver_to_load_delay );
    }
}

void verilog_writer

(

void

)

Definition at line 64 of file verilog_writer.c.

{
  FILE *verilog;
  FILE *SDF;
  char * verilog_file_name = (char *)malloc((strlen(blif_circuit_name) + strlen("_post_synthesis.v") + 1) *sizeof(char));/*creating the Verilog file name*/
  char * sdf_file_name = (char *)malloc((strlen(blif_circuit_name) + strlen("_post_synthesis.sdf") + 1) *sizeof(char));/*creating the SDF file name*/
  char *clock_name;/*Will need to store the clock name of the design if any exist*/ 
  assert(verilog_file_name);
  assert(sdf_file_name);
  printf("\nWriting the post-synthesized circuit Verilog and SDF.....\n...");

  sprintf(verilog_file_name, "%s%s", blif_circuit_name, "_post_synthesis.v");
  sprintf(sdf_file_name, "%s%s", blif_circuit_name, "_post_synthesis.sdf");

  /*Openning the post synthesized netlist files*/
  verilog = fopen(verilog_file_name , "w");
  SDF = fopen(sdf_file_name , "w");

  clock_name = find_clock_name();
  instantiate_top_level_module(verilog);
  instantiate_SDF_header(SDF);
  instantiate_wires(verilog);
  instantiate_input_interconnect(verilog , SDF , clock_name);
  instantiate_primitive_modules(verilog,clock_name,SDF);

  fprintf(verilog , "\nendmodule\n");
  fprintf(SDF , ")\n");
  fclose(verilog);
  fclose(SDF);
  printf("Done\n\n");
}

Here is the call graph for this function:

Here is the caller graph for this function: