path_length.c

fpga设计评估软件

	}
	else
	  fprintf(debuglogfile,"          ");
      }
    }
    fprintf(debuglogfile,"\n");
  }

  fclose(debuglogfile);

}
#endif



/*****************************************/
#ifdef CRITICAL_LENGTH_STATS
static void print_stats(int num_blocks_clustered, int num_clusters,
                 float farthest_distance,
                 int num_critical_conn, float avg_dist_to_sinks,
		 float avg_point_to_point_dist) {

  static int previous_cluster = -1;
  int cluster_num;
  cluster_num = num_clusters - 1;

  if (cluster_num != previous_cluster) {
    previous_cluster = cluster_num;
    fprintf (length_f, "\n");
  }

  fprintf (length_f, "%7d %7d  %7.2f %7d %8.5f %8.5f\n", 
	   cluster_num, num_blocks_clustered,
	   farthest_distance, num_critical_conn, avg_dist_to_sinks, 
	   avg_point_to_point_dist);

}
#endif
/******************** Globally Accessable Function Definitions *******************/
/*****************************************/
int get_net_pin_number(int blk, int blkpin) {
  /*returns the pin number in the net structure that the pin on this block */
  /*corresponds to */

  return(block_timing[blk].net_pin_index[blkpin]);

}

/*****************************************/
float get_net_pin_forward_criticality(int netnum, int pinnum) {
  /*returns the criticality for a particular branch of a net*/

  return(net_timing[netnum].net_forward_criticality[pinnum]);

}
/*****************************************/
float get_net_pin_backward_criticality(int netnum, int pinnum) {
  /*returns the criticality for a particular block*/

   return(net_timing[netnum].net_backward_criticality[pinnum]);
}
/*****************************************/
boolean report_critical_path(float block_delay, float inter_cluster_net_delay, 
			  float intra_cluster_net_delay, int farthest_block,
			  int cluster_size, boolean print_data) {
  /*finds the most critical path (longest path) and reports the length, and *
   *which blocks and nets are used by the path. */

  /*If all blocks on critical path have been clustered this function returns TRUE*
   *otherwise it returns FALSE.*/

  /*do not delete this function, as it is required to know when the critical path has been*/
  /*minimized as much as it possibly can -- this allows us to go into pin-sharing mode and*/
  /*save execution time */


  int pinidx; 
  int currentblock;
  int nextblock;
  int startidx, endidx;
  int inputnet, inputnetpin;
  int critnet;
  int numclusters, num_clusterable_blocks_on_path;
  int total_num_blocks_on_path, num_ext_nets_on_path;
  float mostcrit, netcrit;
  int cluster_of_nextblock;
  boolean all_clustered;
  boolean first_pass;

  all_clustered=TRUE;
  first_pass = TRUE;

#ifdef CRITICAL_PATH_STATS
  if (print_data) {
    fprintf(critical_report_f,"Using the following values, the most critical "
	    "path is determined\n");

    fprintf(critical_report_f,"block_delay=             %5.2f\n",block_delay);
    fprintf(critical_report_f,"inter_cluster_net_delay= %5.2f\n",inter_cluster_net_delay);
    fprintf(critical_report_f,"intra_cluter_net_delay=  %5.2f\n\n",intra_cluster_net_delay);

    fprintf(critical_report_f,"Critical path is reported from output to input\n\n");
  }
#endif

  if (get_cluster_of_block(farthest_block) == NEVER_CLUSTER){
    numclusters=0;
  }
  else{
    numclusters=1;
  }

  num_ext_nets_on_path=0;
  currentblock=farthest_block;
  num_clusterable_blocks_on_path=0;
  total_num_blocks_on_path=0;

  while (1) {
#ifdef CRITICAL_PATH_STATS
    if (print_data) {
      fprintf(critical_report_f,"Block #%5d \tName:%14s \tArrival Time=%7.2f "
	      "\tCluster=%5d\n",
	      currentblock,block[currentblock].name,
	      block_timing[currentblock].delay_from_source,
	      get_cluster_of_block(currentblock));
    }
#endif

    if (get_cluster_of_block(currentblock) == NO_CLUSTER)
      all_clustered=FALSE;

    total_num_blocks_on_path++;

    if (get_cluster_of_block(currentblock) != NEVER_CLUSTER)
      num_clusterable_blocks_on_path++;

    if (block_is_in_initial_source_q[currentblock] && !first_pass) {
      /*we have found the source of this critical path, we are done*/
      break;
    }
 
    first_pass = FALSE;

    if (block[currentblock].type == OUTPAD){
      startidx=0;
      endidx=0;
    }
    else {
      startidx=1;
      endidx=lut_size;
    }
    mostcrit=0.0;

    nextblock = NO_CLUSTER; 
    critnet = NO_CLUSTER;

    for (pinidx=startidx; pinidx<=endidx; pinidx++) {
      inputnet=block[currentblock].nets[pinidx];

      if (inputnet != OPEN) {
	inputnetpin=block_timing[currentblock].net_pin_index[pinidx];
	netcrit=net_timing[inputnet].net_forward_criticality[inputnetpin];
	if (netcrit > mostcrit) {
	  mostcrit=netcrit;
	  nextblock=net[inputnet].pins[0];
	  critnet=inputnet;
	}
      }
    }

    if (nextblock != NO_CLUSTER)
      cluster_of_nextblock=get_cluster_of_block(nextblock);
    else 
      cluster_of_nextblock = NO_CLUSTER;

    if (cluster_of_nextblock == NO_CLUSTER ||
	get_cluster_of_block(currentblock) != cluster_of_nextblock){
      if (cluster_of_nextblock != NEVER_CLUSTER){
	numclusters++;
      }
      num_ext_nets_on_path++;
    }
    
#ifdef CRITICAL_PATH_STATS
    if (print_data) {
      fprintf(critical_report_f,"Net   #%5d \tName:%14s \tCriticality =%9.5f\n", critnet, 
	      net[critnet].name, mostcrit);
    }
#endif
    currentblock=nextblock;
  }

#ifdef CRITICAL_PATH_STATS
  if (print_data) {
    fprintf(critical_report_f, "\n\n%d clusterable blocks packed into %d Clusters of size %d\n", 
	    num_clusterable_blocks_on_path, numclusters, cluster_size);
    fprintf(critical_report_f, "Total Number of Blocks on Crit Path= %d\n",
	    total_num_blocks_on_path);
    fprintf(critical_report_f, "Number of external nets on Crit Path=%d\n",
	    num_ext_nets_on_path);
  }
  fflush(critical_report_f);

  if (print_data)
    fprintf(critical_report_f,"\n\n");
#endif

  return all_clustered;

}

/*****************************************/
void calculate_timing_information(float block_delay, float inter_cluster_net_delay, 
				  float intra_cluster_net_delay,
				  int num_clusters,
				  int num_blocks_clustered,
				  int *farthest_block_discovered){
  /*This should be called whenever it is desired to have the timing and delay *
   *values updated */

  float max_arrival_time;
  long biggest_num_max_inputs;
  long biggest_num_max_outputs;
  long sum_biggest_max;
  float farthest_distance;
  float avg_dist_of_sinks, avg_point_to_point_dist;
  int num_critical_connections;

  reset_blocks_to_initial_state();

  /*first find distances from sources*/

  distance_from_sources(&max_arrival_time, block_delay, inter_cluster_net_delay, 
			intra_cluster_net_delay, 
			farthest_block_discovered, 
			&biggest_num_max_inputs,
			&farthest_distance,
			&avg_dist_of_sinks,
			&avg_point_to_point_dist);

  /*now find distances from sinks*/

  assign_required_arrival_times_to_max(max_arrival_time);

  update_required_arrival_times(block_delay, inter_cluster_net_delay, 
				intra_cluster_net_delay, &biggest_num_max_outputs);
  
  sum_biggest_max = biggest_num_max_inputs+biggest_num_max_outputs;

  calculate_slack_and_criticality(inter_cluster_net_delay, intra_cluster_net_delay, 
				  max_arrival_time, sum_biggest_max, 
				  &num_critical_connections);

  sort_blocks_by_criticality();

#ifdef CRITICAL_LENGTH_STATS
  print_stats(num_blocks_clustered, num_clusters,
	      farthest_distance, num_critical_connections, avg_dist_of_sinks, 
	      avg_point_to_point_dist);
#endif

#ifdef DEBUG_PATH_LENGTH
  /*output debugging information*/
  output_structures();

#endif
}
/******************************/
int get_most_critical_unclustered_block(void) {
  /*calculate_timing_information must be called before this, or this function*
   *will return garbage */

  /*indexofcrit is a global variable that is reset to 0 each time a          *
   *timing analysis is done (reset in  sort_blocks_by_criticality)           */
 
  int critidx, blkidx;

  for (critidx=indexofcrit; critidx<num_blocks; critidx++) {
    blkidx=critindexarray[critidx];
    if (get_cluster_of_block(blkidx) == NO_CLUSTER) {
      indexofcrit=critidx+1;
      return(blkidx);
    }
  }

  /*if it makes it to here , there are no more blocks available*/
  return(NO_CLUSTER);
}
/******************************/
void alloc_and_init_path_length(int lut_sz, boolean *is_clk){
  /*this only needs to be called once*/

  lut_size=lut_sz;
  is_clock=is_clk;
  
#ifdef CRITICAL_PATH_STATS
  critical_report_f = my_fopen("vpack_critical_path.echo","w",0);
#endif

#ifdef CRITICAL_LENGTH_STATS
  length_f = my_fopen("vpack_critical_length.echo","w",0);

  fprintf(length_f, "%7s %7s %7s %7s %8s %8s\n",
	  "", "Num","","Num","Avg", "Avg");
  fprintf(length_f, "%7s %7s %7s %7s %8s %8s\n",
	  "Cluster","Blocks","Crit","Crit", "Dist","Pt to Pt");
  fprintf(length_f, "%7s %7s %7s %7s %8s %8s\n",
	  "Num","Packed","Dist","Conn","Sinks","Dist");
  fprintf(length_f, "%7s %7s %7s %7s %8s %8s\n",
	  "-------","-------","-------","-------",
	  "--------","--------");
#endif

  alloc_and_init_structures();
  get_sources_and_sinks();
  set_block_input_output_counts();
}
/******************************/

void free_path_length_memory(void){
  /*this should only be called when the internal structures are no longer required*/

  int iblk, inet;

  free(block_has_distance_q);
  free(block_has_req_arr_time_q);
  free(block_in_remaining);
  free(block_out_remaining);
  free(block_in_count);
  free(block_out_count);
  free(block_is_in_distance_q);
  free(block_is_in_initial_source_q);
  free(block_is_in_initial_sink_q);
  free(block_is_in_req_arr_time_q);
  free(criticality);
  free(critindexarray);

  for (iblk=0; iblk<num_blocks;iblk++)
    free(block_timing[iblk].net_pin_index);
  free(block_timing);

  for (inet=0;inet<num_nets;inet++) {
    free(net_timing[inet].net_pin_arrival_time);
    free(net_timing[inet].net_slack);
    free(net_timing[inet].net_forward_criticality);
    free(net_timing[inet].net_backward_criticality);
  }
  free(net_timing);

#ifdef CRITICAL_PATH_STATS
  fclose(critical_report_f);
#endif

#ifdef CRITICAL_LENGTH_STATS
  fclose(length_f);
#endif
}