SRC/SetupVPR.h File Reference

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

Go to the source code of this file.

Functions
boolean	IsTimingEnabled (IN t_options Options)
void	SetupVPR (IN t_options Options, IN boolean TimingEnabled, OUT t_arch *Arch, OUT enum e_operation *Operation, OUT struct s_placer_opts *PlacerOpts, OUT struct s_annealing_sched *AnnealSched, OUT struct s_router_opts *RouterOpts, OUT struct s_det_routing_arch *RoutingArch, OUT t_segment_inf **Segments, OUT t_timing_inf *Timing, OUT t_subblock_data *Subblocks, OUT boolean *ShowGraphics, OUT int *GraphPause)
void	CheckSetup (IN enum e_operation Operation, IN struct s_placer_opts PlacerOpts, IN struct s_annealing_sched AnnealSched, IN struct s_router_opts RouterOpts, IN struct s_det_routing_arch RoutingArch, IN t_segment_inf *Segments, IN t_timing_inf Timing, IN t_subblock_data Subblocks, IN t_chan_width_dist Chans)
void	CheckArch (IN t_arch Arch, IN boolean TimingEnabled)
void	CheckOptions (IN t_options Options, IN boolean TimingEnabled)
void	ShowSetup (IN t_options Options, IN t_arch Arch, IN boolean TimingEnabled, IN enum e_operation Operation, IN struct s_placer_opts PlacerOpts, IN struct s_annealing_sched AnnealSched, IN struct s_router_opts RouterOpts, IN struct s_det_routing_arch RoutingArch, IN t_segment_inf *Segments, IN t_timing_inf Timing, IN t_subblock_data Subblocks)

---

Function Documentation

void CheckArch	(	IN t_arch	Arch,
		IN boolean	TimingEnabled
	)

Definition at line 19 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	(	IN t_options	Options,
		IN boolean	TimingEnabled
	)

Definition at line 13 of file CheckOptions.c.

{
    int i;
    boolean Placer;
    boolean TimingPlacer;
    boolean Router;
    boolean TimingRouter;
    const struct s_TokenPair *Cur;
    enum e_OptionBaseToken Yes;

    /* Check that all filenames were given */
    if((NULL == Options.NetFile) ||
       (NULL == Options.ArchFile) ||
       (NULL == Options.PlaceFile) || (NULL == Options.RouteFile))
        {
            printf(ERRTAG "Not enough args. Need at least 'vpr "
                   "<netfile> <archfile> <placefile> <routefile>'\n");
            exit(1);
        }

    /* Check that options aren't over specified */
    Cur = OptionBaseTokenList;
    while(Cur->Str)
        {
            if(Options.Count[Cur->Enum] > 1)
                {
                    printf(ERRTAG "Parameter '%s' was specified more than "
                           "once on command line.\n", Cur->Str);
                    exit(1);
                }
            ++Cur;
        }

    /* Check for conflicting parameters and determine if placer and 
     * router are on. */
    i = 0;
    Placer = TRUE;              /* On by default */
    Router = TRUE;              /* On by default */
    if(Options.Count[OT_ROUTE_ONLY])
        {
            ++i;
            Placer = FALSE;
        }
    if(Options.Count[OT_PLACE_ONLY])
        {
            ++i;
            Router = FALSE;
        }
    if(Options.Count[OT_TIMING_ANALYZE_ONLY_WITH_NET_DELAY])
        {
            ++i;
            Placer = FALSE;
            Router = FALSE;
        }
    if(i > 1)
        {
            printf(ERRTAG "'route_only', 'place_only', 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 = (Placer && 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 = (Router && 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_TYPE] > 0)
        {
            Yes = OT_PLACE_COST_TYPE;
        }
    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_NUM_REGIONS] > 0)
        {
            Yes = OT_NUM_REGIONS;
        }
    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((FALSE == Placer) && (Yes < OT_BASE_UNKNOWN))
        {
            Cur = OptionBaseTokenList;
            while(Cur->Str)
                {
                    if(Yes == Cur->Enum)
                        {
                            printf(ERRTAG
                                   "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)
                        {
                            printf(ERRTAG
                                   "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;
        }
    /* Make sure if router is off none of those options were given */
    if((FALSE == Router) && (Yes < OT_BASE_UNKNOWN))
        {
            Cur = OptionBaseTokenList;
            while(Cur->Str)
                {
                    if(Yes == Cur->Enum)
                        {
                            printf(ERRTAG
                                   "Option '%s' is not allowed when router is "
                                   "not used.\n", Cur->Str);
                            exit(1);
                        }
                    ++Cur;
                }
        }

    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)
                        {
                            printf(ERRTAG
                                   "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	(	IN enum e_operation	Operation,
		IN struct s_placer_opts	PlacerOpts,
		IN struct s_annealing_sched	AnnealSched,
		IN struct s_router_opts	RouterOpts,
		IN struct s_det_routing_arch	RoutingArch,
		IN t_segment_inf *	Segments,
		IN t_timing_inf	Timing,
		IN t_subblock_data	Subblocks,
		IN t_chan_width_dist	Chans
	)

Definition at line 11 of file CheckSetup.c.

{
    int i;
    int Tmp;

    if((NONLINEAR_CONG == PlacerOpts.place_cost_type) &&
       (Operation != PLACE_AND_ROUTE) &&
       (PLACE_ALWAYS == PlacerOpts.place_freq))
        {
            printf(ERRTAG "Replacing using the nonlinear congestion option "
                   "for each channel width makes sense only for full "
                   "place and route.\n");
            exit(1);
        }

    if((NONLINEAR_CONG == PlacerOpts.place_cost_type) &&
       (BOUNDING_BOX_PLACE != PlacerOpts.place_algorithm))
        {

            /* Note that this may work together, but I have not tested it */
            printf(ERRTAG
                   "Cannot use non-linear placement only supported with "
                   "bounding box placement\n");
            exit(1);
        }

    if((GLOBAL == RouterOpts.route_type) &&
       (TIMING_DRIVEN == RouterOpts.router_algorithm))
        {

            printf(ERRTAG "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. */
            printf(WARNTAG
                   "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 */
            printf(ERRTAG
                   "Timing analysis must be enabled for timing-driven placement\n");
            exit(1);
        }

    if((ROUTE_ONLY == Operation) && (USER == PlacerOpts.pad_loc_type))
        {
            printf(ERRTAG "You cannot specify both a full placement file and "
                   "a pad location file.\n");
            exit(1);
        }

    if((ROUTE_ONLY == Operation) || (PLACE_AND_ROUTE == Operation))
        {
            if((TIMING_DRIVEN == RouterOpts.router_algorithm) &&
               (FALSE == Timing.timing_analysis_enabled))
                {
                    printf(ERRTAG
                           "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))
                {
                    printf(ERRTAG
                           "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))
        {
            printf(ERRTAG
                   "-timing_analyze_only_with_net_delay option requires "
                   "that timing analysis not be disabled.\n");
            exit(1);
        }

    if((NONLINEAR_CONG == PlacerOpts.place_cost_type) &&
       ((PlacerOpts.num_regions > nx) || (PlacerOpts.num_regions > ny)))
        {
            printf(ERRTAG "Cannot use more regions than clbs in "
                   "placement cost function.\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))
                {
                    printf(ERRTAG "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)
                {
                    printf(ERRTAG "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))
                {
                    printf(ERRTAG
                           "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))
                {
                    printf(ERRTAG
                           "Place channel width must be even for unidirectional\n");
                    exit(1);
                }
        }
}

Here is the caller graph for this function:

boolean IsTimingEnabled

(

IN t_options

Options

)

Definition at line 1016 of file SetupVPR.c.

{
    /* First priority to the '--timing_analysis' flag */
    if(Options.Count[OT_TIMING_ANALYSIS])
        {
            return Options.TimingAnalysis;
        }
    return TRUE;
}

Here is the caller graph for this function:

void SetupVPR	(	IN t_options	Options,
		IN boolean	TimingEnabled,
		OUT t_arch *	Arch,
		OUT enum e_operation *	Operation,
		OUT struct s_placer_opts *	PlacerOpts,
		OUT struct s_annealing_sched *	AnnealSched,
		OUT struct s_router_opts *	RouterOpts,
		OUT struct s_det_routing_arch *	RoutingArch,
		OUT t_segment_inf **	Segments,
		OUT t_timing_inf *	Timing,
		OUT t_subblock_data *	Subblocks,
		OUT boolean *	ShowGraphics,
		OUT int *	GraphPause
	)

Definition at line 49 of file SetupVPR.c.

{

    SetupOperation(Options, Operation);
    SetupPlacerOpts(Options, TimingEnabled, PlacerOpts);
    SetupAnnealSched(Options, AnnealSched);
    SetupRouterOpts(Options, TimingEnabled, RouterOpts);

    XmlReadArch(Options.ArchFile, TimingEnabled, Arch,
                &type_descriptors, &num_types);

    *Segments = Arch->Segments;
    RoutingArch->num_segment = Arch->num_segments;

    SetupSwitches(*Arch, RoutingArch, Arch->Switches, Arch->num_switches);
    SetupRoutingArch(*Arch, RoutingArch);
    SetupTiming(Options, *Arch, TimingEnabled, *Operation,
                *PlacerOpts, *RouterOpts, Timing);

    /* init global variables */
    OutFilePrefix = Options.OutFilePrefix;
    grid_logic_tile_area = Arch->grid_logic_tile_area;
    ipin_mux_trans_size = Arch->ipin_mux_trans_size;

    /* Set seed for pseudo-random placement, default seed to 1 */
    PlacerOpts->seed = 1;
    if(Options.Count[OT_SEED])
        {
            PlacerOpts->seed = Options.Seed;
        }
    my_srandom(PlacerOpts->seed);

    *GraphPause = 1;            /* DEFAULT */
    if(Options.Count[OT_AUTO])
        {
            *GraphPause = Options.GraphPause;
        }
#ifdef NO_GRAPHICS
    *ShowGraphics = FALSE;      /* DEFAULT */
#else /* NO_GRAPHICS */
    *ShowGraphics = TRUE;       /* DEFAULT */
    if(Options.Count[OT_NODISP])
        {
            *ShowGraphics = FALSE;
        }
#endif /* NO_GRAPHICS */

#ifdef CREATE_ECHO_FILES
    EchoArch("arch.echo", type_descriptors, num_types);
#endif

    if(Options.NetFile)
        {
            read_netlist(Options.NetFile, num_types, type_descriptors,
                         IO_TYPE, 0, 1, Subblocks, &num_blocks, &block,
                         &num_nets, &net);
            /* This is done so that all blocks have subblocks and can be treated the same */
            load_subblock_info_to_type(Subblocks, IO_TYPE);
            check_netlist(Subblocks);
        }

    InitArch(*Arch);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowSetup	(	IN t_options	Options,
		IN t_arch	Arch,
		IN boolean	TimingEnabled,
		IN enum e_operation	Operation,
		IN struct s_placer_opts	PlacerOpts,
		IN struct s_annealing_sched	AnnealSched,
		IN struct s_router_opts	RouterOpts,
		IN struct s_det_routing_arch	RoutingArch,
		IN t_segment_inf *	Segments,
		IN t_timing_inf	Timing,
		IN t_subblock_data	Subblocks
	)

Definition at line 24 of file ShowSetup.c.

{
    int i, j, num_p_inputs, num_p_outputs;

    printf("Timing analysis: %s\n", (TimingEnabled ? "ON" : "OFF"));
    printf("\n");

    ShowOperation(Operation);
    ShowPlacerOpts(Options, PlacerOpts, AnnealSched);
    if((ROUTE_ONLY == Operation) || (PLACE_AND_ROUTE == Operation))
        {
            ShowRouterOpts(RouterOpts);
        }
    else
        {
            printf("Router: DISABLED\n\n");
        }

    if(DETAILED == RouterOpts.route_type)
        ShowRoutingArch(RoutingArch);

    printf("The circuit will be mapped into a %d x %d array of clbs.\n",
           nx, ny);
    printf("\n");
    printf("Netlist num_nets:  %d\n", num_nets);
    printf("Netlist num_blocks:  %d\n", num_blocks);

    /* Count I/O input and output pads */
    num_p_inputs = 0;
    num_p_outputs = 0;
    for(i = 0; i < num_blocks; i++)
        {
            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)
                                        {
                                            num_p_inputs++;
                                        }
                                    else
                                        {
                                            assert(IO_TYPE->
                                                   class_inf[IO_TYPE->
                                                             pin_class[j]].
                                                   type == RECEIVER);
                                            num_p_outputs++;
                                        }
                                }
                        }
                }
        }

/* Print out each block separately instead */
    printf("Netlist inputs pins:  %d\n", num_p_inputs);
    printf("Netlist output pins:  %d\n", num_p_outputs);
    printf("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function: