diff --git a/vpr/src/pack/appack_context.h b/vpr/src/pack/appack_context.h index fac548d6360..a27f2a48ad3 100644 --- a/vpr/src/pack/appack_context.h +++ b/vpr/src/pack/appack_context.h @@ -53,7 +53,7 @@ struct t_appack_options { CENTROID, /**< The location of the cluster is the centroid of the molecules which have been packed into it. */ SEED /**< The location of the cluster is the location of the first molecule packed into it. */ }; - e_cl_loc_ty cluster_location_ty = e_cl_loc_ty::CENTROID; + static constexpr e_cl_loc_ty cluster_location_ty = e_cl_loc_ty::CENTROID; // =========== Candidate gain attenuation ============================== // // These terms are used to update the gain of a given candidate based on @@ -67,11 +67,11 @@ struct t_appack_options { // Distance threshold which decides when to use quadratic decay or inverted // sqrt decay. If the distance is less than this threshold, quadratic decay // is used. Inverted sqrt is used otherwise. - float dist_th = 5.0f; + static constexpr float dist_th = 5.0f; // Horizontal offset to the inverted sqrt decay. - float sqrt_offset = -1.1f; + static constexpr float sqrt_offset = -1.1f; // Scaling factor for the quadratic decay term. - float quad_fac = 0.1543f; + static constexpr float quad_fac = 0.1543f; // =========== Candidate selection distance ============================ // // When selecting candidates, what distance from the cluster will we @@ -81,7 +81,32 @@ struct t_appack_options { // types of molecules / clusters. For example, CLBs vs DSPs float max_candidate_distance = std::numeric_limits::max(); - // TODO: Investigate adding flat placement info to unrelated clustering. + // =========== Unrelated clustering ==================================== // + // After searching for candidates by connectivity and timing, the user may + // turn on unrelated clustering, which will allow molecules which are + // unrelated to the cluster being created to be attempted to be packed in. + // APPack uses flat placement information to decide which unrelated + // molecules to try. + + // APPack will search for unrelated molecules in the tile which contains + // the flat location of the cluster. It will then look farther out, tile + // by tile. This parameter is the maximum distance from the cluster's tile + // that APPack will search. Setting this to 0 would only allow APPack to + // search within the cluster's tile. Setting this to a higher number would + // allow APPack to search farther away; but may bring in molecules which + // do not "want" to be in the cluster. + static constexpr float max_unrelated_tile_distance = 1.0f; + + // Unrelated clustering occurs after all other candidate selection methods + // have failed. This parameter sets how many time we will attempt unrelated + // clustering between failures of unrelated clustering. If this is set to + // 1, and unrelated clustering failed for a cluster, it will not be attempted + // again for that cluster (note: if it succeeds, the number of attempts get + // reset). + // NOTE: A similar option exists in the candidate selector class. This was + // duplicated since it is very likely that APPack would need a + // different value for this option than the non-APPack flow. + static constexpr int max_unrelated_clustering_attempts = 2; // TODO: Investigate adding flat placement info to seed selection. }; diff --git a/vpr/src/pack/greedy_candidate_selector.cpp b/vpr/src/pack/greedy_candidate_selector.cpp index db4e575da29..0e95167a843 100644 --- a/vpr/src/pack/greedy_candidate_selector.cpp +++ b/vpr/src/pack/greedy_candidate_selector.cpp @@ -8,6 +8,7 @@ #include "greedy_candidate_selector.h" #include #include +#include #include #include "appack_context.h" #include "flat_placement_types.h" @@ -16,13 +17,12 @@ #include "attraction_groups.h" #include "cluster_legalizer.h" #include "cluster_placement.h" -#include "globals.h" #include "greedy_clusterer.h" #include "prepack.h" #include "timing_info.h" -#include "vpr_context.h" #include "vpr_types.h" #include "vtr_assert.h" +#include "vtr_ndmatrix.h" #include "vtr_vector.h" /* @@ -105,44 +105,102 @@ GreedyCandidateSelector::GreedyCandidateSelector( , timing_info_(timing_info) , appack_ctx_(appack_ctx) , rng_(0) { - // Initialize the list of molecules to pack, the clustering data, and the - // net info. - // Initialize unrelated clustering data. + // Initialize unrelated clustering data if unrelated clustering is enabled. if (allow_unrelated_clustering_) { - /* alloc and load list of molecules to pack */ - unrelated_clustering_data_.resize(max_molecule_stats.num_used_ext_inputs + 1); + initialize_unrelated_clustering_data(max_molecule_stats); + } + + /* TODO: This is memory inefficient, fix if causes problems */ + /* Store stats on nets used by packed block, useful for determining transitively connected blocks + * (eg. [A1, A2, ..]->[B1, B2, ..]->C implies cluster [A1, A2, ...] and C have a weak link) */ + clb_inter_blk_nets_.resize(atom_netlist.blocks().size()); +} + +void GreedyCandidateSelector::initialize_unrelated_clustering_data(const t_molecule_stats& max_molecule_stats) { + // Create a sorted list of molecules, sorted on decreasing molecule base + // gain. (Highest gain). + std::vector molecules_vector; + molecules_vector.assign(prepacker_.molecules().begin(), prepacker_.molecules().end()); + std::stable_sort(molecules_vector.begin(), + molecules_vector.end(), + [&](PackMoleculeId a_id, PackMoleculeId b_id) { + const t_pack_molecule& a = prepacker_.get_molecule(a_id); + const t_pack_molecule& b = prepacker_.get_molecule(b_id); + + return a.base_gain > b.base_gain; + }); + + if (appack_ctx_.appack_options.use_appack) { + /** + * For APPack, we build a spatial data structure where for each 1x1 grid + * position on the FPGA, we maintain lists of molecule candidates. + * The lists are in order of number of used external pins by the molecule. + * Within each list, the molecules are sorted by their base gain. + */ + // Get the max x, y, and layer from the flat placement. + t_flat_pl_loc max_loc({0.0f, 0.0f, 0.0f}); + for (PackMoleculeId mol_id : molecules_vector) { + t_flat_pl_loc mol_pos = get_molecule_pos(mol_id, prepacker_, appack_ctx_); + max_loc.x = std::max(max_loc.x, mol_pos.x); + max_loc.y = std::max(max_loc.y, mol_pos.y); + max_loc.layer = std::max(max_loc.layer, mol_pos.layer); + } - // Create a sorted list of molecules, sorted on decreasing molecule base - // gain. (Highest gain). - std::vector molecules_vector; - molecules_vector.assign(prepacker.molecules().begin(), prepacker.molecules().end()); - std::stable_sort(molecules_vector.begin(), - molecules_vector.end(), - [&](PackMoleculeId a_id, PackMoleculeId b_id) { - const t_pack_molecule& a = prepacker.get_molecule(a_id); - const t_pack_molecule& b = prepacker.get_molecule(b_id); + VTR_ASSERT_MSG(max_loc.layer == 0, + "APPack unrelated clustering does not support 3D " + "FPGAs yet"); + + // Initialize the data structure with empty arrays with enough space + // for each molecule. + size_t flat_grid_width = max_loc.x + 1; + size_t flat_grid_height = max_loc.y + 1; + appack_unrelated_clustering_data_ = + vtr::NdMatrix>, 2>({flat_grid_width, + flat_grid_height}); + for (size_t x = 0; x < flat_grid_width; x++) { + for (size_t y = 0; y < flat_grid_height; y++) { + // Resize to the maximum number of used external pins. This is + // to ensure that every molecule below can be inserted into a + // valid list based on their number of external pins. + appack_unrelated_clustering_data_[x][y].resize(max_molecule_stats.num_used_ext_pins + 1); + } + } + + // Fill the grid with molecule information. + // Note: These molecules are sorted based on their base gain. They are + // inserted in such a way that the highest gain molecules appear + // first in the lists below. + for (PackMoleculeId mol_id : molecules_vector) { + t_flat_pl_loc mol_pos = get_molecule_pos(mol_id, prepacker_, appack_ctx_); - return a.base_gain > b.base_gain; - }); + //Figure out how many external inputs are used by this molecule + t_molecule_stats molecule_stats = prepacker_.calc_molecule_stats(mol_id, atom_netlist_); + int ext_inps = molecule_stats.num_used_ext_inputs; + + //Insert the molecule into the unclustered lists by number of external inputs + auto& tile_uc_data = appack_unrelated_clustering_data_[mol_pos.x][mol_pos.y]; + tile_uc_data[ext_inps].push_back(mol_id); + } + } else { + // When not performing APPack, allocate and load a similar data structure + // without spatial information. + + /* alloc and load list of molecules to pack */ + unrelated_clustering_data_.resize(max_molecule_stats.num_used_ext_inputs + 1); // Push back the each molecule into the unrelated clustering data vector // for their external inputs. This creates individual sorted lists of // molecules for each number of used external inputs. for (PackMoleculeId mol_id : molecules_vector) { //Figure out how many external inputs are used by this molecule - t_molecule_stats molecule_stats = prepacker.calc_molecule_stats(mol_id, atom_netlist); + t_molecule_stats molecule_stats = prepacker_.calc_molecule_stats(mol_id, atom_netlist_); int ext_inps = molecule_stats.num_used_ext_inputs; //Insert the molecule into the unclustered lists by number of external inputs unrelated_clustering_data_[ext_inps].push_back(mol_id); } } - - /* TODO: This is memory inefficient, fix if causes problems */ - /* Store stats on nets used by packed block, useful for determining transitively connected blocks - * (eg. [A1, A2, ..]->[B1, B2, ..]->C implies cluster [A1, A2, ...] and C have a weak link) */ - clb_inter_blk_nets_.resize(atom_netlist.blocks().size()); } GreedyCandidateSelector::~GreedyCandidateSelector() { @@ -673,15 +731,23 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster( // If we are allowing unrelated clustering and no molecule has been found, // get unrelated candidate for cluster. if (allow_unrelated_clustering_ && best_molecule == PackMoleculeId::INVALID()) { - if (num_unrelated_clustering_attempts_ < max_unrelated_clustering_attempts_) { - best_molecule = get_unrelated_candidate_for_cluster(cluster_id, - cluster_legalizer); - num_unrelated_clustering_attempts_++; - VTR_LOGV(best_molecule && log_verbosity_ > 2, - "\tFound unrelated molecule to cluster\n"); + const t_appack_options& appack_options = appack_ctx_.appack_options; + if (appack_options.use_appack) { + if (num_unrelated_clustering_attempts_ < appack_options.max_unrelated_clustering_attempts) { + best_molecule = get_unrelated_candidate_for_cluster_appack(cluster_gain_stats, + cluster_id, + cluster_legalizer); + num_unrelated_clustering_attempts_++; + } } else { - num_unrelated_clustering_attempts_ = 0; + if (num_unrelated_clustering_attempts_ < max_unrelated_clustering_attempts_) { + best_molecule = get_unrelated_candidate_for_cluster(cluster_id, + cluster_legalizer); + num_unrelated_clustering_attempts_++; + } } + VTR_LOGV(best_molecule && log_verbosity_ > 2, + "\tFound unrelated molecule to cluster\n"); } else { VTR_LOGV(!best_molecule && log_verbosity_ > 2, "\tNo related molecule found and unrelated clustering disabled\n"); @@ -1154,6 +1220,115 @@ PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster( return PackMoleculeId::INVALID(); } +PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster_appack( + ClusterGainStats& cluster_gain_stats, + LegalizationClusterId cluster_id, + const ClusterLegalizer& cluster_legalizer) { + + /** + * For APPack, we want to find a close candidate with the highest number + * of available inputs which could be packed into the given cluster. + * We will search for candidates in a BFS manner, where we will search in + * the same 1x1 grid location of the cluster for a compatible candidate, and + * will then search out if none can be found. + * + * Here, a molecule is compatible if: + * - It has not been clustered already + * - The number of inputs it has available is less than or equal to the + * number of inputs available in the cluster. + * - It has not tried to be packed in this cluster before. + * - It is compatible with the cluster. + */ + + VTR_ASSERT_MSG(allow_unrelated_clustering_, + "Cannot get unrelated candidates when unrelated clustering " + "is disabled"); + + VTR_ASSERT_MSG(appack_ctx_.appack_options.use_appack, + "APPack is disabled, cannot get unrelated clusters using " + "flat placement information"); + + // The cluster will likely have more inputs available than a single molecule + // would have available (clusters have more pins). Clamp the inputs available + // to the max number of inputs a molecule could have. + size_t inputs_avail = cluster_legalizer.get_num_cluster_inputs_available(cluster_id); + VTR_ASSERT_SAFE(!appack_unrelated_clustering_data_.empty()); + size_t max_molecule_inputs_avail = appack_unrelated_clustering_data_[0][0].size() - 1; + if (inputs_avail >= max_molecule_inputs_avail) { + inputs_avail = max_molecule_inputs_avail; + } + + // Create a queue of locations to search and a map of visited grid locations. + std::queue search_queue; + vtr::NdMatrix visited({appack_unrelated_clustering_data_.dim_size(0), + appack_unrelated_clustering_data_.dim_size(1)}, + false); + // Push the position of the cluster to the queue. + search_queue.push(cluster_gain_stats.flat_cluster_position); + + while (!search_queue.empty()) { + // Pop a position to search from the queue. + const t_flat_pl_loc& node_loc = search_queue.front(); + VTR_ASSERT_SAFE(node_loc.layer == 0); + + // If this position is too far from the source, skip it. + float dist = get_manhattan_distance(node_loc, cluster_gain_stats.flat_cluster_position); + if (dist > 1) { + search_queue.pop(); + continue; + } + + // If this position has been visited, skip it. + if (visited[node_loc.x][node_loc.y]) { + search_queue.pop(); + continue; + } + visited[node_loc.x][node_loc.y] = true; + + // Explore this position from highest number of inputs available to lowest. + const auto& uc_data = appack_unrelated_clustering_data_[node_loc.x][node_loc.y]; + VTR_ASSERT_SAFE(inputs_avail < uc_data.size()); + for (int ext_inps = inputs_avail; ext_inps >= 0; ext_inps--) { + // Get the molecule by the number of external inputs. + for (PackMoleculeId mol_id : uc_data[ext_inps]) { + // If this molecule has been clustered, skip it. + if (cluster_legalizer.is_mol_clustered(mol_id)) + continue; + // If this molecule has tried to be packed before and failed + // do not try it. This also means that this molecule may be + // related to this cluster in some way. + if (cluster_gain_stats.mol_failures.find(mol_id) != cluster_gain_stats.mol_failures.end()) + continue; + // If this molecule is not compatible with the current cluster + // skip it. + if (!cluster_legalizer.is_molecule_compatible(mol_id, cluster_id)) + continue; + // Return this molecule as the unrelated candidate. + return mol_id; + } + } + + // Push the neighbors of the position to the queue. + // Note: Here, we are using the manhattan distance, so we do not push + // the diagonals. We also want to try the direct neighbors first + // since they should be closer. + if (node_loc.x >= 1.0f) + search_queue.push({node_loc.x - 1, node_loc.y, node_loc.layer}); + if (node_loc.x <= visited.dim_size(0) - 2) + search_queue.push({node_loc.x + 1, node_loc.y, node_loc.layer}); + if (node_loc.y >= 1.0f) + search_queue.push({node_loc.x, node_loc.y - 1, node_loc.layer}); + if (node_loc.y <= visited.dim_size(1) - 2) + search_queue.push({node_loc.x, node_loc.y + 1, node_loc.layer}); + + // Pop the position off the queue. + search_queue.pop(); + } + + // No molecule could be found. Return an invalid ID. + return PackMoleculeId::INVALID(); +} + void GreedyCandidateSelector::update_candidate_selector_finalize_cluster( ClusterGainStats& cluster_gain_stats, LegalizationClusterId cluster_id) { diff --git a/vpr/src/pack/greedy_candidate_selector.h b/vpr/src/pack/greedy_candidate_selector.h index 1bef31e3abf..86258b6fdbf 100644 --- a/vpr/src/pack/greedy_candidate_selector.h +++ b/vpr/src/pack/greedy_candidate_selector.h @@ -18,6 +18,7 @@ #include "greedy_clusterer.h" #include "physical_types.h" #include "prepack.h" +#include "vtr_ndmatrix.h" #include "vtr_vector.h" #include "vtr_random.h" @@ -353,6 +354,23 @@ class GreedyCandidateSelector { LegalizationClusterId cluster_id); private: + // ===================================================================== // + // Initializing Data Structures + // ===================================================================== // + + /** + * @brief Initialize data structures used for unrelated clustering. + * + * This must be called before using the get_unrelated_candidate methods. + * + * @param max_molecule_stats + * The maximum molecule statistics over all molecules in the design. + * This is used to allocate the data-structures used for unrelated + * clustering. + */ + void initialize_unrelated_clustering_data( + const t_molecule_stats& max_molecule_stats); + // ===================================================================== // // Cluster Gain Stats Updating // ===================================================================== // @@ -489,6 +507,19 @@ class GreedyCandidateSelector { LegalizationClusterId cluster_id, const ClusterLegalizer& cluster_legalizer); + /** + * @brief Finds a molecule to propose which is unrelated to the current + * cluster but may be good to pack. + * + * This uses flat placement information to choose a good candidate. + * + * This returns an invalid molecule ID if a candidate cannot be found. + */ + PackMoleculeId get_unrelated_candidate_for_cluster_appack( + ClusterGainStats& cluster_gain_stats, + LegalizationClusterId cluster_id, + const ClusterLegalizer& cluster_legalizer); + // ===================================================================== // // Internal Variables // ===================================================================== // @@ -541,6 +572,18 @@ class GreedyCandidateSelector { /// dimension is the number of external outputs of the molecule. std::vector> unrelated_clustering_data_; + /// @brief Data pre-computed to help select unrelated molecules when APPack + /// is being used. This is the same data as unrelated_clustering_data_, + /// but it is spatially distributed over the device. + /// For each grid location on the device (x, y), this provides a list of + /// molecules sorted by their gain, where the first dimension is the number + /// of external outputs of the molecule. + /// When APPack is not used, this will be uninitialized. + /// [0..flat_grid_width][0..flat_grid_height][0..max_num_used_ext_pins] + /// Here, flat_grid width/height is the maximum x and y positions given in + /// the flat placement. + vtr::NdMatrix>, 2> appack_unrelated_clustering_data_; + /// @brief The APPack state which contains the options used to configure /// APPack and the flat placement. const APPackContext& appack_ctx_; diff --git a/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/config.txt b/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/config.txt new file mode 100644 index 00000000000..a45e6a65de4 --- /dev/null +++ b/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/config.txt @@ -0,0 +1,54 @@ +############################################################################### +# Configuration file for running the MCNC benchmarks through the AP flow. +# +# The AP flow requires that each circuit contains fixed blocks and is fixed +# to a specific device size. The device sizes here were chosen to match the +# device sizes of the default VTR flow. +############################################################################### + +# Path to directory of circuits to use +circuits_dir=benchmarks/blif/wiremap6 + +# Path to directory of architectures to use +archs_dir=arch/timing + +# Add architectures to list to sweep +arch_list_add=k6_frac_N10_40nm.xml + +# Add circuits to list to sweep +circuit_list_add=apex4.pre-vpr.blif +circuit_list_add=des.pre-vpr.blif +circuit_list_add=ex1010.pre-vpr.blif +circuit_list_add=seq.pre-vpr.blif + +# Constrain the circuits to their devices +circuit_constraint_list_add=(apex4.pre-vpr.blif, device=mcnc_medium) +circuit_constraint_list_add=(seq.pre-vpr.blif, device=mcnc_medium) +circuit_constraint_list_add=(des.pre-vpr.blif, device=mcnc_large) +circuit_constraint_list_add=(ex1010.pre-vpr.blif, device=mcnc_large) + +# Constrain the IOs +circuit_constraint_list_add=(apex4.pre-vpr.blif, constraints=../../../../../mcnc/constraints/apex4_io_constraint.xml) +circuit_constraint_list_add=(seq.pre-vpr.blif, constraints=../../../../../mcnc/constraints/seq_io_constraint.xml) +circuit_constraint_list_add=(des.pre-vpr.blif, constraints=../../../../../mcnc/constraints/des_io_constraint.xml) +circuit_constraint_list_add=(ex1010.pre-vpr.blif, constraints=../../../../../mcnc/constraints/ex1010_io_constraint.xml) + +# Constrain the circuits to their channel widths +# 1.3 * minW +circuit_constraint_list_add=(apex4.pre-vpr.blif, route_chan_width=78) +circuit_constraint_list_add=(seq.pre-vpr.blif, route_chan_width=78) +circuit_constraint_list_add=(des.pre-vpr.blif, route_chan_width=44) +circuit_constraint_list_add=(ex1010.pre-vpr.blif, route_chan_width=114) + +# Parse info and how to parse +parse_file=vpr_fixed_chan_width.txt + +# How to parse QoR info +qor_parse_file=qor_ap_fixed_chan_width.txt + +# Pass requirements +pass_requirements_file=pass_requirements_ap_fixed_chan_width.txt + +# Pass the script params while writing the vpr constraints. +script_params=-starting_stage vpr -track_memory_usage --analytical_place --route --allow_unrelated_clustering on + diff --git a/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/golden_results.txt b/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/golden_results.txt new file mode 100644 index 00000000000..008dcd38a4f --- /dev/null +++ b/vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_ap/unrelated_clustering/config/golden_results.txt @@ -0,0 +1,5 @@ + arch circuit script_params vtr_flow_elapsed_time vtr_max_mem_stage vtr_max_mem error odin_synth_time max_odin_mem parmys_synth_time max_parmys_mem abc_depth abc_synth_time abc_cec_time abc_sec_time max_abc_mem ace_time max_ace_mem num_clb num_io num_memories num_mult vpr_status vpr_revision vpr_build_info vpr_compiler vpr_compiled hostname rundir max_vpr_mem num_primary_inputs num_primary_outputs num_pre_packed_nets num_pre_packed_blocks num_netlist_clocks num_post_packed_nets num_post_packed_blocks device_width device_height device_grid_tiles device_limiting_resources device_name pack_mem pack_time initial_placed_wirelength_est placed_wirelength_est total_swap accepted_swap rejected_swap aborted_swap place_mem place_time place_quench_time initial_placed_CPD_est placed_CPD_est placed_setup_TNS_est placed_setup_WNS_est placed_geomean_nonvirtual_intradomain_critical_path_delay_est place_delay_matrix_lookup_time place_quench_timing_analysis_time place_quench_sta_time place_total_timing_analysis_time place_total_sta_time ap_mem ap_time ap_full_legalizer_mem ap_full_legalizer_time routed_wirelength avg_routed_wirelength routed_wiresegment avg_routed_wiresegment total_nets_routed total_connections_routed total_heap_pushes total_heap_pops logic_block_area_total logic_block_area_used routing_area_total routing_area_per_tile crit_path_route_success_iteration num_rr_graph_nodes num_rr_graph_edges collapsed_nodes critical_path_delay geomean_nonvirtual_intradomain_critical_path_delay setup_TNS setup_WNS hold_TNS hold_WNS create_rr_graph_time create_intra_cluster_rr_graph_time adding_internal_edges route_mem crit_path_route_time crit_path_total_timing_analysis_time crit_path_total_sta_time router_lookahead_mem tile_lookahead_computation_time router_lookahead_computation_time + k6_frac_N10_40nm.xml apex4.pre-vpr.blif common 4.96 vpr 74.26 MiB -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 79 9 -1 -1 success v8.0.0-12313-g365d2b526 release VTR_ASSERT_LEVEL=3 GNU 13.2.0 on Linux-6.8.0-49-generic x86_64 2025-03-21T09:41:31 srivatsan-Precision-Tower-5810 /home/alex/vtr-verilog-to-routing 76040 9 19 897 28 0 623 107 16 16 256 -1 mcnc_medium -1 -1 10045 6450 8456 1313 4865 2278 74.3 MiB 1.89 0.01 6.56432 5.03307 -83.524 -5.03307 nan 0.05 0.00204244 0.00165662 0.0837004 0.0703705 74.3 MiB 1.89 74.3 MiB 1.43 10549 16.9598 2720 4.37299 4745 19339 673268 115030 1.05632e+07 4.25763e+06 1.26944e+06 4958.75 18 28900 206586 -1 5.35405 nan -87.6493 -5.35405 0 0 0.20 -1 -1 74.3 MiB 0.27 0.203126 0.176979 74.3 MiB -1 0.05 + k6_frac_N10_40nm.xml des.pre-vpr.blif common 2.31 vpr 75.04 MiB -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 54 256 -1 -1 success v8.0.0-12313-g365d2b526 release VTR_ASSERT_LEVEL=3 GNU 13.2.0 on Linux-6.8.0-49-generic x86_64 2025-03-21T09:41:31 srivatsan-Precision-Tower-5810 /home/alex/vtr-verilog-to-routing 76844 256 245 954 501 0 592 555 22 22 484 -1 mcnc_large -1 -1 10182 8261 32475 449 5759 26267 75.0 MiB 0.60 0.01 5.81056 4.10466 -788.701 -4.10466 nan 0.07 0.00213529 0.00190203 0.0410553 0.0373156 75.0 MiB 0.60 75.0 MiB 0.39 11038 18.6453 2976 5.02703 2516 5569 337853 71532 2.15576e+07 2.91028e+06 1.49107e+06 3080.73 16 47664 245996 -1 4.5805 nan -849.865 -4.5805 0 0 0.26 -1 -1 75.0 MiB 0.17 0.140869 0.130143 75.0 MiB -1 0.07 + k6_frac_N10_40nm.xml ex1010.pre-vpr.blif common 17.62 vpr 102.26 MiB -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 263 10 -1 -1 success v8.0.0-12313-g365d2b526 release VTR_ASSERT_LEVEL=3 GNU 13.2.0 on Linux-6.8.0-49-generic x86_64 2025-03-21T09:41:31 srivatsan-Precision-Tower-5810 /home/alex/vtr-verilog-to-routing 104716 10 10 2659 20 0 1553 283 22 22 484 -1 mcnc_large -1 -1 37750 27023 51323 13724 33007 4592 102.3 MiB 6.79 0.02 9.4798 6.49062 -63.3158 -6.49062 nan 0.15 0.00558982 0.00437045 0.377565 0.30904 102.3 MiB 6.79 102.3 MiB 4.67 40165 25.8628 10185 6.55827 10819 59199 2817453 375025 2.15576e+07 1.41741e+07 3.51389e+06 7260.09 18 64568 594370 -1 6.92885 nan -65.9061 -6.92885 0 0 0.65 -1 -1 102.3 MiB 0.93 0.743277 0.634821 102.3 MiB -1 0.15 + k6_frac_N10_40nm.xml seq.pre-vpr.blif common 4.90 vpr 75.17 MiB -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 82 41 -1 -1 success v8.0.0-12313-g365d2b526 release VTR_ASSERT_LEVEL=3 GNU 13.2.0 on Linux-6.8.0-49-generic x86_64 2025-03-21T09:41:31 srivatsan-Precision-Tower-5810 /home/alex/vtr-verilog-to-routing 76972 41 35 1006 76 0 666 158 16 16 256 -1 mcnc_medium -1 -1 11362 6922 10833 921 5072 4840 75.2 MiB 1.81 0.01 6.29523 4.75885 -139.918 -4.75885 nan 0.06 0.00245639 0.00201946 0.0743378 0.0630971 75.2 MiB 1.81 75.2 MiB 1.35 11028 16.5586 2899 4.35285 4620 20556 688864 117989 1.05632e+07 4.41931e+06 1.26944e+06 4958.75 17 28900 206586 -1 5.00979 nan -145.985 -5.00979 0 0 0.20 -1 -1 75.2 MiB 0.27 0.20235 0.177701 75.2 MiB -1 0.06