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

Functions
void	SetupVPR (INP t_options Options, INP boolean TimingEnabled, INP boolean readArchFile, OUTP struct s_file_name_opts FileNameOpts, INOUTP t_arch Arch, OUTP enum e_operation Operation, OUTP t_model user_models, OUTP t_model library_models, OUTP struct s_packer_opts PackerOpts, OUTP struct s_placer_opts PlacerOpts, OUTP struct s_annealing_sched AnnealSched, OUTP struct s_router_opts RouterOpts, OUTP struct s_det_routing_arch RoutingArch, OUTP t_segment_inf Segments, OUTP t_timing_inf Timing, OUTP boolean ShowGraphics, OUTP int GraphPause, OUTP t_power_opts *power_opts)

void	CheckSetup (INP enum e_operation Operation, INP struct s_placer_opts PlacerOpts, INP struct s_annealing_sched AnnealSched, INP struct s_router_opts RouterOpts, INP struct s_det_routing_arch RoutingArch, INP t_segment_inf *Segments, INP t_timing_inf Timing, INP t_chan_width_dist Chans)

void	CheckArch (INP t_arch Arch, INP boolean TimingEnabled)

void	CheckOptions (INP t_options Options, INP boolean TimingEnabled)

void	ShowSetup (INP t_options options, INP t_vpr_setup vpr_setup)

void	printClusteredNetlistStats (void)

Function Documentation

void CheckArch	(	INP t_arch	Arch,
		INP boolean	TimingEnabled
	)

Definition at line 17 of file CheckArch.c.

                                                            {
     CheckSwitches(Arch, TimingEnabled);
     CheckSegments(Arch);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CheckOptions	(	INP t_options	Options,
		INP boolean	TimingEnabled
	)

Definition at line 12 of file CheckOptions.c.

                                                                     {
     boolean TimingPlacer;
     boolean TimingRouter;
     boolean default_flow;
 
     const struct s_TokenPair *Cur;
     enum e_OptionBaseToken Yes;
 
     default_flow = (boolean) (Options.Count[OT_ROUTE] == 0
             && Options.Count[OT_PLACE] == 0 && Options.Count[OT_PACK] == 0
             && Options.Count[OT_TIMING_ANALYZE_ONLY_WITH_NET_DELAY] == 0);
 
     /* Check that all filenames were given */
     if ((NULL == Options.CircuitName) || (NULL == Options.ArchFile)) {
         vpr_printf(TIO_MESSAGE_ERROR, "Not enough args. Need at least 'vpr <archfile> <circuit_name>'.\n");
         exit(1);
     }
 
     /* Check that options aren't over specified */
     Cur = OptionBaseTokenList;
     while (Cur->Str) {
         if (Options.Count[Cur->Enum] > 1) {
             vpr_printf(TIO_MESSAGE_ERROR, "Parameter '%s' was specified more than once on command line.\n", Cur->Str);
             exit(1);
         }
         ++Cur;
     }
 
     /* Todo: Add in checks for packer   */
 
     /* Check for conflicting parameters and determine if placer and 
      * router are on. */
 
     if (Options.Count[OT_TIMING_ANALYZE_ONLY_WITH_NET_DELAY]
             && (Options.Count[OT_PACK] || Options.Count[OT_PLACE]
                     || Options.Count[OT_ROUTE])) {
         vpr_printf(TIO_MESSAGE_ERROR, "'cluster'/'route'/'place', and 'timing_analysis_only_with_net_delay' are mutually exclusive flags..\n");
         exit(1);
     }
 
     /* If placing and timing is enabled, default to a timing placer */
     TimingPlacer = (boolean)((Options.Count[OT_PLACE] || default_flow) && TimingEnabled);
     if (Options.Count[OT_PLACE_ALGORITHM] > 0) {
         if ((PATH_TIMING_DRIVEN_PLACE != Options.PlaceAlgorithm)
                 && (NET_TIMING_DRIVEN_PLACE != Options.PlaceAlgorithm)) {
             /* Turn off the timing placer if they request a different placer */
             TimingPlacer = FALSE;
         }
     }
 
     /* If routing and timing is enabled, default to a timing router */
     TimingRouter = (boolean)((Options.Count[OT_ROUTE] || default_flow) && TimingEnabled);
     if (Options.Count[OT_ROUTER_ALGORITHM] > 0) {
         if (TIMING_DRIVEN != Options.RouterAlgorithm) {
             /* Turn off the timing router if they request a different router */
             TimingRouter = FALSE;
         }
     }
 
     Yes = OT_BASE_UNKNOWN;
     if (Options.Count[OT_SEED] > 0) {
         Yes = OT_SEED;
     }
     if (Options.Count[OT_INNER_NUM] > 0) {
         Yes = OT_INNER_NUM;
     }
     if (Options.Count[OT_INIT_T] > 0) {
         Yes = OT_INIT_T;
     }
     if (Options.Count[OT_ALPHA_T] > 0) {
         Yes = OT_ALPHA_T;
     }
     if (Options.Count[OT_EXIT_T] > 0) {
         Yes = OT_EXIT_T;
     }
     if (Options.Count[OT_FIX_PINS] > 0) {
         Yes = OT_FIX_PINS;
     }
     if (Options.Count[OT_PLACE_ALGORITHM] > 0) {
         Yes = OT_PLACE_ALGORITHM;
     }
     if (Options.Count[OT_PLACE_COST_EXP] > 0) {
         Yes = OT_PLACE_COST_EXP;
     }
     if (Options.Count[OT_PLACE_CHAN_WIDTH] > 0) {
         Yes = OT_PLACE_CHAN_WIDTH;
     }
     if (Options.Count[OT_ENABLE_TIMING_COMPUTATIONS] > 0) {
         Yes = OT_ENABLE_TIMING_COMPUTATIONS;
     }
     if (Options.Count[OT_BLOCK_DIST] > 0) {
         Yes = OT_BLOCK_DIST;
     }
     /* Make sure if place is off none of those options were given */
     if ((Options.Count[OT_PLACE] == 0) && !default_flow
             && (Yes < OT_BASE_UNKNOWN)) {
         Cur = OptionBaseTokenList;
         while (Cur->Str) {
             if (Yes == Cur->Enum) {
                 vpr_printf(TIO_MESSAGE_ERROR, "Option '%s' is not allowed when placement is not run.\n", Cur->Str);
                 exit(1);
             }
             ++Cur;
         }
     }
 
     Yes = OT_BASE_UNKNOWN;
     if (Options.Count[OT_TIMING_TRADEOFF] > 0) {
         Yes = OT_TIMING_TRADEOFF;
     }
     if (Options.Count[OT_RECOMPUTE_CRIT_ITER] > 0) {
         Yes = OT_RECOMPUTE_CRIT_ITER;
     }
     if (Options.Count[OT_INNER_LOOP_RECOMPUTE_DIVIDER] > 0) {
         Yes = OT_INNER_LOOP_RECOMPUTE_DIVIDER;
     }
     if (Options.Count[OT_TD_PLACE_EXP_FIRST] > 0) {
         Yes = OT_TD_PLACE_EXP_FIRST;
     }
     if (Options.Count[OT_TD_PLACE_EXP_LAST] > 0) {
         Yes = OT_TD_PLACE_EXP_LAST;
     }
     /* Make sure if place is off none of those options were given */
     if ((FALSE == TimingPlacer) && (Yes < OT_BASE_UNKNOWN)) {
         Cur = OptionBaseTokenList;
         while (Cur->Str) {
             if (Yes == Cur->Enum) {
                 vpr_printf(TIO_MESSAGE_ERROR, "Option '%s' is not allowed when timing placement is not used.\n", Cur->Str);
                 exit(1);
             }
             ++Cur;
         }
     }
 
     Yes = OT_BASE_UNKNOWN;
     if (Options.Count[OT_ROUTE_TYPE] > 0) {
         Yes = OT_ROUTE_TYPE;
     }
     if (Options.Count[OT_ROUTE_CHAN_WIDTH] > 0) {
         Yes = OT_ROUTE_CHAN_WIDTH;
     }
     if (Options.Count[OT_ROUTER_ALGORITHM] > 0) {
         Yes = OT_ROUTER_ALGORITHM;
     }
     if (Options.Count[OT_MAX_ROUTER_ITERATIONS] > 0) {
         Yes = OT_MAX_ROUTER_ITERATIONS;
     }
     if (Options.Count[OT_INITIAL_PRES_FAC] > 0) {
         Yes = OT_INITIAL_PRES_FAC;
     }
     if (Options.Count[OT_FIRST_ITER_PRES_FAC] > 0) {
         Yes = OT_FIRST_ITER_PRES_FAC;
     }
     if (Options.Count[OT_PRES_FAC_MULT] > 0) {
         Yes = OT_PRES_FAC_MULT;
     }
     if (Options.Count[OT_ACC_FAC] > 0) {
         Yes = OT_ACC_FAC;
     }
     if (Options.Count[OT_BB_FACTOR] > 0) {
         Yes = OT_BB_FACTOR;
     }
     if (Options.Count[OT_BASE_COST_TYPE] > 0) {
         Yes = OT_BASE_COST_TYPE;
     }
     if (Options.Count[OT_BEND_COST] > 0) {
         Yes = OT_BEND_COST;
     }
     if (Options.Count[OT_BASE_COST_TYPE] > 0) {
         Yes = OT_BASE_COST_TYPE;
     }
     if (Options.Count[OT_ASTAR_FAC] > 0) {
         Yes = OT_ASTAR_FAC;
     }
     Yes = OT_BASE_UNKNOWN;
     if (Options.Count[OT_MAX_CRITICALITY] > 0) {
         Yes = OT_MAX_CRITICALITY;
     }
     if (Options.Count[OT_CRITICALITY_EXP] > 0) {
         Yes = OT_CRITICALITY_EXP;
     }
     /* Make sure if timing router is off none of those options were given */
     if ((FALSE == TimingRouter) && (Yes < OT_BASE_UNKNOWN)) {
         Cur = OptionBaseTokenList;
         while (Cur->Str) {
             if (Yes == Cur->Enum) {
                 vpr_printf(TIO_MESSAGE_ERROR, "Option '%s' is not allowed when timing router is not used.\n", Cur->Str);
                 exit(1);
             }
             ++Cur;
         }
     }
 }

Here is the caller graph for this function:

void CheckSetup	(	INP enum e_operation	Operation,
		INP struct s_placer_opts	PlacerOpts,
		INP struct s_annealing_sched	AnnealSched,
		INP struct s_router_opts	RouterOpts,
		INP struct s_det_routing_arch	RoutingArch,
		INP t_segment_inf *	Segments,
		INP t_timing_inf	Timing,
		INP t_chan_width_dist	Chans
	)

Definition at line 9 of file CheckSetup.c.

                                                               {
     int i;
     int Tmp;
 
     if ((GLOBAL == RouterOpts.route_type)
             && (TIMING_DRIVEN == RouterOpts.router_algorithm)) {
 
         vpr_printf(TIO_MESSAGE_ERROR, "The global router does not support timing-drvien routing.\n");
         exit(1);
     }
 
     if ((GLOBAL == RouterOpts.route_type)
             && (BOUNDING_BOX_PLACE != PlacerOpts.place_algorithm)) {
 
         /* Works, but very weird.  Can't optimize timing well, since you're
          * not doing proper architecture delay modelling. */
         vpr_printf(TIO_MESSAGE_WARNING, "Using global routing with timing-driven placement. "
                    "This is allowed, but strange, and circuit speed will suffer.\n");
     }
 
     if ((FALSE == Timing.timing_analysis_enabled)
             && ((PlacerOpts.place_algorithm == NET_TIMING_DRIVEN_PLACE)
                     || (PlacerOpts.place_algorithm == PATH_TIMING_DRIVEN_PLACE))) {
 
         /* May work, not tested */
         vpr_printf(TIO_MESSAGE_ERROR, "Timing analysis must be enabled for timing-driven placement.\n");
         exit(1);
     }
 
     if (!PlacerOpts.doPlacement && (USER == PlacerOpts.pad_loc_type)) {
         vpr_printf(TIO_MESSAGE_ERROR, "A pad location file requires that placement is enabled.\n");
         exit(1);
     }
 
     if (RouterOpts.doRouting) {
         if ((TIMING_DRIVEN == RouterOpts.router_algorithm)
                 && (FALSE == Timing.timing_analysis_enabled)) {
             vpr_printf(TIO_MESSAGE_ERROR, "Cannot perform timing-driven routing when timing analysis is disabled.\n");
             exit(1);
         }
 
         if ((FALSE == Timing.timing_analysis_enabled)
                 && (DEMAND_ONLY != RouterOpts.base_cost_type)) {
             vpr_printf(TIO_MESSAGE_ERROR, "base_cost_type must be demand_only when timing analysis is disabled.\n");
             exit(1);
         }
     }
 
     if ((TIMING_ANALYSIS_ONLY == Operation)
             && (FALSE == Timing.timing_analysis_enabled)) {
         vpr_printf(TIO_MESSAGE_ERROR, "-timing_analyze_only_with_net_delay option requires that timing analysis not be disabled.\n");
         exit(1);
     }
 
     if (DETAILED == RouterOpts.route_type) {
         if ((Chans.chan_x_dist.type != UNIFORM)
                 || (Chans.chan_y_dist.type != UNIFORM)
                 || (Chans.chan_x_dist.peak != Chans.chan_y_dist.peak)
                 || (Chans.chan_x_dist.peak != Chans.chan_width_io)) {
             vpr_printf(TIO_MESSAGE_ERROR, "Detailed routing currently only supported on FPGAs with all channels of equal width.\n");
             exit(1);
         }
     }
 
     for (i = 0; i < RoutingArch.num_segment; ++i) {
         Tmp = Segments[i].opin_switch;
         if (FALSE == switch_inf[Tmp].buffered) {
             vpr_printf(TIO_MESSAGE_ERROR, "opin_switch (#%d) of segment type #%d is not buffered.\n", Tmp, i);
             exit(1);
         }
     }
 
     if (UNI_DIRECTIONAL == RoutingArch.directionality) {
         if ((RouterOpts.fixed_channel_width != NO_FIXED_CHANNEL_WIDTH)
                 && (RouterOpts.fixed_channel_width % 2 > 0)) {
             vpr_printf(TIO_MESSAGE_ERROR, "Routing channel width must be even for unidirectional.\n");
             exit(1);
         }
         if ((PlacerOpts.place_chan_width != NO_FIXED_CHANNEL_WIDTH)
                 && (PlacerOpts.place_chan_width % 2 > 0)) {
             vpr_printf(TIO_MESSAGE_ERROR, "Place channel width must be even for unidirectional.\n");
             exit(1);
         }
     }
 }

Here is the caller graph for this function:

void printClusteredNetlistStats ( void )

Definition at line 50 of file ShowSetup.c.

                                   {
     int i, j, L_num_p_inputs, L_num_p_outputs;
     int *num_blocks_type;
     num_blocks_type = (int*) my_calloc(num_types, sizeof(int));
 
     vpr_printf(TIO_MESSAGE_INFO, "\n");
     vpr_printf(TIO_MESSAGE_INFO, "Netlist num_nets: %d\n", num_nets);
     vpr_printf(TIO_MESSAGE_INFO, "Netlist num_blocks: %d\n", num_blocks);
 
     for (i = 0; i < num_types; i++) {
         num_blocks_type[i] = 0;
     }
     /* Count I/O input and output pads */
     L_num_p_inputs = 0;
     L_num_p_outputs = 0;
 
     for (i = 0; i < num_blocks; i++) {
         num_blocks_type[block[i].type->index]++;
         if (block[i].type == IO_TYPE) {
             for (j = 0; j < IO_TYPE->num_pins; j++) {
                 if (block[i].nets[j] != OPEN) {
                     if (IO_TYPE->class_inf[IO_TYPE->pin_class[j]].type
                             == DRIVER) {
                         L_num_p_inputs++;
                     } else {
                         assert(
                                 IO_TYPE-> class_inf[IO_TYPE-> pin_class[j]]. type == RECEIVER);
                         L_num_p_outputs++;
                     }
                 }
             }
         }
     }
 
     for (i = 0; i < num_types; i++) {
         if (IO_TYPE != &type_descriptors[i]) {
             vpr_printf(TIO_MESSAGE_INFO, "Netlist %s blocks: %d.\n", type_descriptors[i].name, num_blocks_type[i]);
         }
     }
 
     /* Print out each block separately instead */
     vpr_printf(TIO_MESSAGE_INFO, "Netlist inputs pins: %d\n", L_num_p_inputs);
     vpr_printf(TIO_MESSAGE_INFO, "Netlist output pins: %d\n", L_num_p_outputs);
     vpr_printf(TIO_MESSAGE_INFO, "\n");
     free(num_blocks_type);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SetupVPR	(	INP t_options *	Options,
		INP boolean	TimingEnabled,
		INP boolean	readArchFile,
		OUTP struct s_file_name_opts *	FileNameOpts,
		INOUTP t_arch *	Arch,
		OUTP enum e_operation *	Operation,
		OUTP t_model **	user_models,
		OUTP t_model **	library_models,
		OUTP struct s_packer_opts *	PackerOpts,
		OUTP struct s_placer_opts *	PlacerOpts,
		OUTP struct s_annealing_sched *	AnnealSched,
		OUTP struct s_router_opts *	RouterOpts,
		OUTP struct s_det_routing_arch *	RoutingArch,
		OUTP t_segment_inf **	Segments,
		OUTP t_timing_inf *	Timing,
		OUTP boolean *	ShowGraphics,
		OUTP int *	GraphPause,
		OUTP t_power_opts *	power_opts
	)

void ShowSetup	(	INP t_options	options,
		INP t_vpr_setup	vpr_setup
	)

Definition at line 22 of file ShowSetup.c.

                                                                  {
     vpr_printf(TIO_MESSAGE_INFO, "Timing analysis: %s\n", (vpr_setup.TimingEnabled? "ON" : "OFF"));
 
     vpr_printf(TIO_MESSAGE_INFO, "Circuit netlist file: %s\n", vpr_setup.FileNameOpts.NetFile);
     vpr_printf(TIO_MESSAGE_INFO, "Circuit placement file: %s\n", vpr_setup.FileNameOpts.PlaceFile);
     vpr_printf(TIO_MESSAGE_INFO, "Circuit routing file: %s\n", vpr_setup.FileNameOpts.RouteFile);
     vpr_printf(TIO_MESSAGE_INFO, "Circuit SDC file: %s\n", vpr_setup.Timing.SDCFile);
 
     ShowOperation(vpr_setup.Operation);
     vpr_printf(TIO_MESSAGE_INFO, "Packer: %s\n", (vpr_setup.PackerOpts.doPacking ? "ENABLED" : "DISABLED"));
     vpr_printf(TIO_MESSAGE_INFO, "Placer: %s\n", (vpr_setup.PlacerOpts.doPlacement ? "ENABLED" : "DISABLED"));
     vpr_printf(TIO_MESSAGE_INFO, "Router: %s\n", (vpr_setup.RouterOpts.doRouting ? "ENABLED" : "DISABLED"));
 
     if (vpr_setup.PackerOpts.doPacking) {
         ShowPackerOpts(vpr_setup.PackerOpts);
     }
     if (vpr_setup.PlacerOpts.doPlacement) {
         ShowPlacerOpts(options, vpr_setup.PlacerOpts, vpr_setup.AnnealSched);
     }
     if (vpr_setup.RouterOpts.doRouting) {
         ShowRouterOpts(vpr_setup.RouterOpts);
     }
 
     if (DETAILED == vpr_setup.RouterOpts.route_type)
         ShowRoutingArch(vpr_setup.RoutingArch);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Function Documentation