vpr_api.h File Reference

#include "physical_types.h"
#include "vpr_types.h"
#include "ReadOptions.h"
#include "OptionTokens.h"
#include "globals.h"
#include "util.h"
#include "read_xml_arch_file.h"
#include "vpr_utils.h"

Include dependency graph for vpr_api.h:

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

Go to the source code of this file.

Functions
void	vpr_init (INP int argc, INP char **argv, OUTP t_options *options, OUTP t_vpr_setup *vpr_setup, OUTP t_arch *arch)
void	vpr_pack (INP t_vpr_setup vpr_setup, INP t_arch arch)
void	vpr_init_pre_place_and_route (INP t_vpr_setup vpr_setup, INP t_arch Arch)
void	vpr_place_and_route (INP t_vpr_setup vpr_setup, INP t_arch arch)
void	vpr_power_estimation (t_vpr_setup vpr_setup, t_arch Arch)
void	vpr_free_vpr_data_structures (INOUTP t_arch Arch, INOUTP t_options options, INOUTP t_vpr_setup vpr_setup)
void	vpr_free_all (INOUTP t_arch Arch, INOUTP t_options options, INOUTP t_vpr_setup vpr_setup)
void	vpr_print_title (void)
void	vpr_print_usage (void)
void	vpr_read_options (INP int argc, INP char **argv, OUTP t_options *options)
void	vpr_setup_vpr (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, t_power_opts *PowerOpts)
void	vpr_check_options (INP t_options Options, INP boolean TimingEnabled)
void	vpr_check_arch (INP t_arch Arch, INP boolean TimingEnabled)
void	vpr_check_setup (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	vpr_read_and_process_blif (INP char *blif_file, INP boolean sweep_hanging_nets_and_inputs, INP t_model *user_models, INP t_model *library_models, boolean read_activity_file, char *activity_file)
void	vpr_show_setup (INP t_options options, INP t_vpr_setup vpr_setup)
void	vpr_alloc_and_load_output_file_names (const char *default_name)
void	vpr_set_output_file_name (enum e_output_files ename, const char *name, const char *default_name)
char *	vpr_get_output_file_name (enum e_output_files ename)
t_trace *	vpr_resync_post_route_netlist_to_TI_CLAY_v1_architecture (INP const t_arch *arch)

Function Documentation

void vpr_alloc_and_load_output_file_names

(

const char *

default_name

)

Definition at line 852 of file vpr_api.c.

                                                                    {
    alloc_and_load_output_file_names(default_name);
}

Here is the call graph for this function:

void vpr_check_arch	(	INP t_arch	Arch,
		INP boolean	TimingEnabled
	)

Definition at line 825 of file vpr_api.c.

                                                                {
    CheckArch(Arch, TimingEnabled);
}

Here is the call graph for this function:

void vpr_check_options	(	INP t_options	Options,
		INP boolean	TimingEnabled
	)

Definition at line 822 of file vpr_api.c.

                                                                         {
    CheckOptions(Options, TimingEnabled);
}

Here is the call graph for this function:

void vpr_check_setup	(	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 829 of file vpr_api.c.

                                                              {
    CheckSetup(Operation, PlacerOpts, AnnealSched, RouterOpts, RoutingArch,
            Segments, Timing, Chans);
}

Here is the call graph for this function:

void vpr_free_all	(	INOUTP t_arch	Arch,
		INOUTP t_options	options,
		INOUTP t_vpr_setup	vpr_setup
	)

Definition at line 781 of file vpr_api.c.

                                      {
    free_rr_graph();
    if (vpr_setup.RouterOpts.doRouting) {
        free_route_structs();
    }
    free_trace_structs();
    vpr_free_vpr_data_structures(Arch, options, vpr_setup);
    if (has_printhandler_pre_vpr == FALSE) {
        PrintHandlerDelete();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_free_vpr_data_structures	(	INOUTP t_arch	Arch,
		INOUTP t_options	options,
		INOUTP t_vpr_setup	vpr_setup
	)

Definition at line 764 of file vpr_api.c.

                                      {

    if (vpr_setup.Timing.SDCFile != NULL) {
        free(vpr_setup.Timing.SDCFile);
        vpr_setup.Timing.SDCFile = NULL;
    }

    free_options(&options);
    free_circuit();
    free_arch(&Arch);
    free_echo_file_info();
    free_output_file_names();
    free_timing_stats();
    free_sdc_related_structs();
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* vpr_get_output_file_name

(

enum e_output_files

ename

)

Definition at line 859 of file vpr_api.c.

                                                          {
    return getOutputFileName(ename);
}

Here is the call graph for this function:

void vpr_init	(	INP int	argc,
		INP char **	argv,
		OUTP t_options *	options,
		OUTP t_vpr_setup *	vpr_setup,
		OUTP t_arch *	arch
	)

General API for VPR

VPR is a CAD tool used to conduct FPGA architecture exploration. It takes, as input, a technology-mapped netlist and a description of the FPGA architecture being investigated. VPR then generates a packed, placed, and routed FPGA (in .net, .place, and .route files respectively) that implements the input netlist

Software tools interfacing to VPR should generally call just the functions defined here For advanced/power users, you can call functions defined elsewhere in VPR or modify the data structures directly at your discretion but be aware that doing so can break the correctness of this tool

General Usage:

1. vpr_init
2. vpr_pack
3. vpr_init_pre_place_and_route
4. vpr_place_and_route
5. vpr_free_all

If you are a new developer, key files to begin understanding this code base are:

1. libarchfpga/physical_types.h - Data structures that define the properties of the FPGA architecture
2. vpr_types.h - Very major file that defines the core data structures used in VPR. This includes detailed architecture information, user netlist data structures, and data structures that describe the mapping between those two.
3. globals.h - Defines the global variables used by VPR.

Author: Jason Luu June 21, 2012

Definition at line 161 of file vpr_api.c.

                                                        {
    char* pszLogFileName = "vpr_stdout.log";
    unsigned char enableTimeStamps = 1;
    unsigned long maxWarningCount = 100000;
    unsigned long maxErrorCount = 1000;

    if (PrintHandlerExists() == 1) {
        has_printhandler_pre_vpr = TRUE;
    } else {
        has_printhandler_pre_vpr = FALSE;
    }
    if (has_printhandler_pre_vpr == FALSE) {
        PrintHandlerNew(pszLogFileName);
        PrintHandlerInit(enableTimeStamps, maxWarningCount, maxErrorCount);
    }

    /* Print title message */
    vpr_print_title();

    /* Print usage message if no args */
    if (argc < 3) {
        vpr_print_usage();
        exit(1);
    }

    memset(options, 0, sizeof(t_options));
    memset(vpr_setup, 0, sizeof(t_vpr_setup));
    memset(arch, 0, sizeof(t_arch));

    /* Read in user options */
    ReadOptions(argc, argv, options);
    /* Timing option priorities */
    vpr_setup->TimingEnabled = IsTimingEnabled(options);
    /* Determine whether echo is on or off */
    setEchoEnabled(IsEchoEnabled(options));
    SetPostSynthesisOption(IsPostSynthesisEnabled(options));
    vpr_setup->constant_net_delay = options->constant_net_delay;

    /* Read in arch and circuit */
    SetupVPR(options, vpr_setup->TimingEnabled, TRUE, &vpr_setup->FileNameOpts,
            arch, &vpr_setup->Operation, &vpr_setup->user_models,
            &vpr_setup->library_models, &vpr_setup->PackerOpts,
            &vpr_setup->PlacerOpts, &vpr_setup->AnnealSched,
            &vpr_setup->RouterOpts, &vpr_setup->RoutingArch,
            &vpr_setup->Segments, &vpr_setup->Timing, &vpr_setup->ShowGraphics,
            &vpr_setup->GraphPause, &vpr_setup->PowerOpts);

    /* Check inputs are reasonable */
    CheckOptions(*options, vpr_setup->TimingEnabled);
    CheckArch(*arch, vpr_setup->TimingEnabled);

    /* Verify settings don't conflict or otherwise not make sense */
    CheckSetup(vpr_setup->Operation, vpr_setup->PlacerOpts,
            vpr_setup->AnnealSched, vpr_setup->RouterOpts,
            vpr_setup->RoutingArch, vpr_setup->Segments, vpr_setup->Timing,
            arch->Chans);

    /* flush any messages to user still in stdout that hasn't gotten displayed */
    fflush(stdout);

    /* Read blif file and sweep unused components */
    read_and_process_blif(vpr_setup->PackerOpts.blif_file_name,
            vpr_setup->PackerOpts.sweep_hanging_nets_and_inputs,
            vpr_setup->user_models, vpr_setup->library_models,
            vpr_setup->PowerOpts.do_power, vpr_setup->FileNameOpts.ActFile);
    fflush(stdout);

    ShowSetup(*options, *vpr_setup);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_init_pre_place_and_route	(	INP t_vpr_setup	vpr_setup,
		INP t_arch	Arch
	)

Definition at line 236 of file vpr_api.c.

                                                                              {
    int *num_instances_type, *num_blocks_type;
    int i;
    int current, high, low;
    boolean fit;

    /* Read in netlist file for placement and routing */
    if (vpr_setup.FileNameOpts.NetFile) {
        read_netlist(vpr_setup.FileNameOpts.NetFile, &Arch, &num_blocks, &block,
                &num_nets, &clb_net);
        /* This is done so that all blocks have subblocks and can be treated the same */
        check_netlist();
    }

    /* Output the current settings to console. */
    printClusteredNetlistStats();

    if (vpr_setup.Operation == TIMING_ANALYSIS_ONLY) {
        do_constant_net_delay_timing_analysis(vpr_setup.Timing,
                vpr_setup.constant_net_delay);
    } else {
        current = nint((float)sqrt((float)num_blocks)); /* current is the value of the smaller side of the FPGA */
        low = 1;
        high = -1;

        num_instances_type = (int*) my_calloc(num_types, sizeof(int));
        num_blocks_type = (int*) my_calloc(num_types, sizeof(int));

        for (i = 0; i < num_blocks; i++) {
            num_blocks_type[block[i].type->index]++;
        }

        if (Arch.clb_grid.IsAuto) {
            /* Auto-size FPGA, perform a binary search */
            while (high == -1 || low < high) {
                /* Generate grid */
                if (Arch.clb_grid.Aspect >= 1.0) {
                    ny = current;
                    nx = nint(current * Arch.clb_grid.Aspect);
                } else {
                    nx = current;
                    ny = nint(current / Arch.clb_grid.Aspect);
                }
#if DEBUG
                vpr_printf(TIO_MESSAGE_INFO,
                        "Auto-sizing FPGA at x = %d y = %d\n", nx, ny);
#endif
                alloc_and_load_grid(num_instances_type);
                freeGrid();

                /* Test if netlist fits in grid */
                fit = TRUE;
                for (i = 0; i < num_types; i++) {
                    if (num_blocks_type[i] > num_instances_type[i]) {
                        fit = FALSE;
                        break;
                    }
                }

                /* get next value */
                if (!fit) {
                    /* increase size of max */
                    if (high == -1) {
                        current = current * 2;
                        if (current > MAX_SHORT) {
                            vpr_printf(TIO_MESSAGE_ERROR,
                                    "FPGA required is too large for current architecture settings.\n");
                            exit(1);
                        }
                    } else {
                        if (low == current)
                            current++;
                        low = current;
                        current = low + ((high - low) / 2);
                    }
                } else {
                    high = current;
                    current = low + ((high - low) / 2);
                }
            }
            /* Generate grid */
            if (Arch.clb_grid.Aspect >= 1.0) {
                ny = current;
                nx = nint(current * Arch.clb_grid.Aspect);
            } else {
                nx = current;
                ny = nint(current / Arch.clb_grid.Aspect);
            }
            alloc_and_load_grid(num_instances_type);
            vpr_printf(TIO_MESSAGE_INFO, "FPGA auto-sized to x = %d y = %d\n",
                    nx, ny);
        } else {
            nx = Arch.clb_grid.W;
            ny = Arch.clb_grid.H;
            alloc_and_load_grid(num_instances_type);
        }

        vpr_printf(TIO_MESSAGE_INFO,
                "The circuit will be mapped into a %d x %d array of clbs.\n",
                nx, ny);

        /* Test if netlist fits in grid */
        fit = TRUE;
        for (i = 0; i < num_types; i++) {
            if (num_blocks_type[i] > num_instances_type[i]) {
                fit = FALSE;
                break;
            }
        }
        if (!fit) {
            vpr_printf(TIO_MESSAGE_ERROR,
                    "Not enough physical locations for type %s, number of blocks is %d but number of locations is %d.\n",
                    type_descriptors[i].name, num_blocks_type[i],
                    num_instances_type[i]);
            exit(1);
        }

        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "Resource usage...\n");
        for (i = 0; i < num_types; i++) {
            vpr_printf(TIO_MESSAGE_INFO,
                    "\tNetlist      %d\tblocks of type: %s\n",
                    num_blocks_type[i], type_descriptors[i].name);
            vpr_printf(TIO_MESSAGE_INFO,
                    "\tArchitecture %d\tblocks of type: %s\n",
                    num_instances_type[i], type_descriptors[i].name);
        }
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        chan_width_x = (int *) my_malloc((ny + 1) * sizeof(int));
        chan_width_y = (int *) my_malloc((nx + 1) * sizeof(int));

        free(num_blocks_type);
        free(num_instances_type);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_pack	(	INP t_vpr_setup	vpr_setup,
		INP t_arch	arch
	)

Definition at line 372 of file vpr_api.c.

                                                          {
    clock_t begin, end;
    float inter_cluster_delay = UNDEFINED, Tdel_opin_switch, Tdel_wire_switch,
            Tdel_wtoi_switch, R_opin_switch, R_wire_switch, R_wtoi_switch,
            Cout_opin_switch, Cout_wire_switch, Cout_wtoi_switch,
            opin_switch_del, wire_switch_del, wtoi_switch_del, Rmetal, Cmetal,
            first_wire_seg_delay, second_wire_seg_delay;
    begin = clock();
    vpr_printf(TIO_MESSAGE_INFO, "Initialize packing.\n");

    /* If needed, estimate inter-cluster delay. Assume the average routing hop goes out of 
     a block through an opin switch to a length-4 wire, then through a wire switch to another
     length-4 wire, then through a wire-to-ipin-switch into another block. */

    if (vpr_setup.PackerOpts.timing_driven
            && vpr_setup.PackerOpts.auto_compute_inter_cluster_net_delay) {
        opin_switch_del = get_switch_info(arch.Segments[0].opin_switch,
                Tdel_opin_switch, R_opin_switch, Cout_opin_switch);
        wire_switch_del = get_switch_info(arch.Segments[0].wire_switch,
                Tdel_wire_switch, R_wire_switch, Cout_wire_switch);
        wtoi_switch_del = get_switch_info(
                vpr_setup.RoutingArch.wire_to_ipin_switch, Tdel_wtoi_switch,
                R_wtoi_switch, Cout_wtoi_switch); /* wire-to-ipin switch */
        Rmetal = arch.Segments[0].Rmetal;
        Cmetal = arch.Segments[0].Cmetal;

        /* The delay of a wire with its driving switch is the switch delay plus the 
         product of the equivalent resistance and capacitance experienced by the wire. */

#define WIRE_SEGMENT_LENGTH 4
        first_wire_seg_delay = opin_switch_del
                + (R_opin_switch + Rmetal * WIRE_SEGMENT_LENGTH / 2)
                        * (Cout_opin_switch + Cmetal * WIRE_SEGMENT_LENGTH);
        second_wire_seg_delay = wire_switch_del
                + (R_wire_switch + Rmetal * WIRE_SEGMENT_LENGTH / 2)
                        * (Cout_wire_switch + Cmetal * WIRE_SEGMENT_LENGTH);
        inter_cluster_delay = 4
                * (first_wire_seg_delay + second_wire_seg_delay
                        + wtoi_switch_del); /* multiply by 4 to get a more conservative estimate */
    }

    try_pack(&vpr_setup.PackerOpts, &arch, vpr_setup.user_models,
            vpr_setup.library_models, vpr_setup.Timing, inter_cluster_delay);
    end = clock();
#ifdef CLOCKS_PER_SEC
    vpr_printf(TIO_MESSAGE_INFO, "Packing took %g seconds.\n",
            (float) (end - begin) / CLOCKS_PER_SEC);
    vpr_printf(TIO_MESSAGE_INFO, "Packing completed.\n");
#else
    vpr_printf(TIO_MESSAGE_INFO, "Packing took %g seconds.\n", (float)(end - begin) / CLK_PER_SEC);
#endif
    fflush(stdout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_place_and_route	(	INP t_vpr_setup	vpr_setup,
		INP t_arch	arch
	)

Definition at line 426 of file vpr_api.c.

                                                                     {
    /* Startup X graphics */
    set_graphics_state(vpr_setup.ShowGraphics, vpr_setup.GraphPause,
            vpr_setup.RouterOpts.route_type);
    if (vpr_setup.ShowGraphics) {
        init_graphics("VPR:  Versatile Place and Route for FPGAs", WHITE);
        alloc_draw_structs();
    }

    /* Do placement and routing */
    place_and_route(vpr_setup.Operation, vpr_setup.PlacerOpts,
            vpr_setup.FileNameOpts.PlaceFile, vpr_setup.FileNameOpts.NetFile,
            vpr_setup.FileNameOpts.ArchFile, vpr_setup.FileNameOpts.RouteFile,
            vpr_setup.AnnealSched, vpr_setup.RouterOpts, vpr_setup.RoutingArch,
            vpr_setup.Segments, vpr_setup.Timing, arch.Chans, arch.models,
            arch.Directs, arch.num_directs);

    fflush(stdout);

    /* Close down X Display */
    if (vpr_setup.ShowGraphics)
        close_graphics();
        free_draw_structs();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_power_estimation	(	t_vpr_setup	vpr_setup,
		t_arch	Arch
	)

Definition at line 1424 of file vpr_api.c.

                                                              {
    e_power_ret_code power_ret_code;
    boolean power_error;

    /* Ensure we are only using 1 clock */
    assert(count_netlist_clocks() == 1);

    /* Get the critical path of this clock */
    g_solution_inf.T_crit = get_critical_path_delay() / 1e9;
    assert(g_solution_inf.T_crit > 0.);

    vpr_printf(TIO_MESSAGE_INFO, "\n\nPower Estimation:\n");
    vpr_printf(TIO_MESSAGE_INFO, "-----------------\n");

    vpr_printf(TIO_MESSAGE_INFO, "Initializing power module\n");

    /* Initialize the power module */
    power_error = power_init(vpr_setup.FileNameOpts.PowerFile,
            vpr_setup.FileNameOpts.CmosTechFile, &Arch, &vpr_setup.RoutingArch);
    if (power_error) {
        vpr_printf(TIO_MESSAGE_ERROR, "Power initialization failed.\n");
    }

    if (!power_error) {
        float power_runtime_s;

        vpr_printf(TIO_MESSAGE_INFO, "Running power estimation\n");

        /* Run power estimation */
        power_ret_code = power_total(&power_runtime_s, vpr_setup, &Arch,
                &vpr_setup.RoutingArch);

        /* Check for errors/warnings */
        if (power_ret_code == POWER_RET_CODE_ERRORS) {
            vpr_printf(TIO_MESSAGE_ERROR,
                    "Power estimation failed. See power output for error details.\n");
        } else if (power_ret_code == POWER_RET_CODE_WARNINGS) {
            vpr_printf(TIO_MESSAGE_WARNING,
                    "Power estimation completed with warnings. See power output for more details.\n");
        } else if (power_ret_code == POWER_RET_CODE_SUCCESS) {
        }
        vpr_printf(TIO_MESSAGE_INFO, "Power estimation took %g seconds\n",
                power_runtime_s);
    }

    /* Uninitialize power module */
    if (!power_error) {
        vpr_printf(TIO_MESSAGE_INFO, "Uninitializing power module\n");
        power_error = power_uninit();
        if (power_error) {
            vpr_printf(TIO_MESSAGE_ERROR, "Power uninitialization failed.\n");
        } else {

        }
    }
    vpr_printf(TIO_MESSAGE_INFO, "\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_print_title

(

void

)

Definition at line 70 of file vpr_api.c.

                           {
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO, "VPR FPGA Placement and Routing.\n");
    vpr_printf(TIO_MESSAGE_INFO, "Version: Version " VPR_VERSION "\n");
    vpr_printf(TIO_MESSAGE_INFO, "Compiled: " __DATE__ ".\n");
    vpr_printf(TIO_MESSAGE_INFO, "University of Toronto\n");
    vpr_printf(TIO_MESSAGE_INFO, "vpr@eecg.utoronto.ca\n");
    vpr_printf(TIO_MESSAGE_INFO, "This is free open source code under MIT license.\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
}

Here is the caller graph for this function:

void vpr_print_usage

(

void

)

Definition at line 82 of file vpr_api.c.

                           {
    vpr_printf(TIO_MESSAGE_INFO,
            "Usage:  vpr fpga_architecture.xml circuit_name [Options ...]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "General Options:  [--nodisp] [--auto <int>] [--pack]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--place] [--route] [--timing_analyze_only_with_net_delay <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--fast] [--full_stats] [--timing_analysis on | off] [--outfile_prefix <string>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--blif_file <string>][--net_file <string>][--place_file <string>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--route_file <string>][--sdc_file <string>][--echo_file on | off]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO, "Packer Options:\n");
    /*    vpr_printf(TIO_MESSAGE_INFO, "\t[-global_clocks on|off]\n");
     vpr_printf(TIO_MESSAGE_INFO, "\t[-hill_climbing on|off]\n");
     vpr_printf(TIO_MESSAGE_INFO, "\t[-sweep_hanging_nets_and_inputs on|off]\n"); */
    vpr_printf(TIO_MESSAGE_INFO, "\t[--timing_driven_clustering on|off]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--cluster_seed_type timing|max_inputs] [--alpha_clustering <float>] [--beta_clustering <float>]\n");
    /*    vpr_printf(TIO_MESSAGE_INFO, "\t[-recompute_timing_after <int>] [-cluster_block_delay <float>]\n"); */
    vpr_printf(TIO_MESSAGE_INFO, "\t[--allow_unrelated_clustering on|off]\n");
    /*    vpr_printf(TIO_MESSAGE_INFO, "\t[-allow_early_exit on|off]\n"); 
     vpr_printf(TIO_MESSAGE_INFO, "\t[-intra_cluster_net_delay <float>] \n");
     vpr_printf(TIO_MESSAGE_INFO, "\t[-inter_cluster_net_delay <float>] \n"); */
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--connection_driven_clustering on|off] \n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO, "Placer Options:\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--place_algorithm bounding_box | net_timing_driven | path_timing_driven]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--init_t <float>] [--exit_t <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--alpha_t <float>] [--inner_num <float>] [--seed <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--place_cost_exp <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--place_chan_width <int>] \n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--fix_pins random | <file.pads>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--enable_timing_computations on | off]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--block_dist <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "Placement Options Valid Only for Timing-Driven Placement:\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--timing_tradeoff <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--recompute_crit_iter <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--inner_loop_recompute_divider <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--td_place_exp_first <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--td_place_exp_last <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "Router Options:  [-max_router_iterations <int>] [-bb_factor <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--initial_pres_fac <float>] [--pres_fac_mult <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--acc_fac <float>] [--first_iter_pres_fac <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--bend_cost <float>] [--route_type global | detailed]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--verify_binary_search] [--route_chan_width <int>]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--router_algorithm breadth_first | timing_driven]\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--base_cost_type intrinsic_delay | delay_normalized | demand_only]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "Routing options valid only for timing-driven routing:\n");
    vpr_printf(TIO_MESSAGE_INFO,
            "\t[--astar_fac <float>] [--max_criticality <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\t[--criticality_exp <float>]\n");
    vpr_printf(TIO_MESSAGE_INFO, "\n");
}

Here is the caller graph for this function:

void vpr_read_and_process_blif	(	INP char *	blif_file,
		INP boolean	sweep_hanging_nets_and_inputs,
		INP t_model *	user_models,
		INP t_model *	library_models,
		boolean	read_activity_file,
		char *	activity_file
	)

Definition at line 839 of file vpr_api.c.

                              {
    read_and_process_blif(blif_file, sweep_hanging_nets_and_inputs, user_models,
            library_models, read_activity_file, activity_file);
}

Here is the call graph for this function:

void vpr_read_options	(	INP int	argc,
		INP char **	argv,
		OUTP t_options *	options
	)

Definition at line 799 of file vpr_api.c.

                                                                               {
    ReadOptions(argc, argv, options);
}

Here is the call graph for this function:

t_trace* vpr_resync_post_route_netlist_to_TI_CLAY_v1_architecture

(

INP const t_arch *

arch

)

Definition at line 865 of file vpr_api.c.

                                {
    t_trace *trace;

    /* Map post-routed traces to clb_nets and block */
    resync_post_route_netlist();

    /* Resolve logically equivalent inputs */
    clay_logical_equivalence_handling(arch);

    /* Finalize traceback */
    trace = alloc_and_load_final_routing_trace();
    if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_COMPLETE_NET_TRACE)) {
        print_complete_net_trace(trace,
                getEchoFileName(E_ECHO_COMPLETE_NET_TRACE));
    }
    return trace;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vpr_set_output_file_name	(	enum e_output_files	ename,
		const char *	name,
		const char *	default_name
	)

Definition at line 855 of file vpr_api.c.

                                  {
    setOutputFileName(ename, name, default_name);
}

Here is the call graph for this function:

void vpr_setup_vpr	(	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,
		t_power_opts *	PowerOpts
	)

Definition at line 804 of file vpr_api.c.

                                  {
    SetupVPR(Options, TimingEnabled, readArchFile, FileNameOpts, Arch,
            Operation, user_models, library_models, PackerOpts, PlacerOpts,
            AnnealSched, RouterOpts, RoutingArch, Segments, Timing,
            ShowGraphics, GraphPause, PowerOpts);
}

Here is the call graph for this function:

void vpr_show_setup	(	INP t_options	options,
		INP t_vpr_setup	vpr_setup
	)

Definition at line 847 of file vpr_api.c.

                                                                      {
    ShowSetup(options, vpr_setup);
}

Here is the call graph for this function: