Removed global clocks from packer.

Author: yenjames

vpr/src/base/SetupVPR.cpp

@@ -573,9 +573,6 @@ void SetupPackerOpts(const t_options& Options,
         PackerOpts->doPacking = STAGE_DO;
     }
 
-    //TODO: document?
-    PackerOpts->global_clocks = true; /* DEFAULT */
-
     PackerOpts->allow_unrelated_clustering = Options.allow_unrelated_clustering;
     PackerOpts->connection_driven = Options.connection_driven_clustering;
     PackerOpts->timing_driven = Options.timing_driven_clustering;

vpr/src/base/ShowSetup.cpp

@@ -757,7 +757,6 @@ static void ShowPackerOpts(const t_packer_opts& PackerOpts) {
             VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown packer cluster_seed_type\n");
     }
     VTR_LOG("PackerOpts.connection_driven: %s", (PackerOpts.connection_driven ? "true\n" : "false\n"));
-    VTR_LOG("PackerOpts.global_clocks: %s", (PackerOpts.global_clocks ? "true\n" : "false\n"));
     VTR_LOG("PackerOpts.timing_driven: %s", (PackerOpts.timing_driven ? "true\n" : "false\n"));
     VTR_LOG("PackerOpts.target_external_pin_util: %s", vtr::join(PackerOpts.target_external_pin_util, " ").c_str());
     VTR_LOG("\n");

vpr/src/base/vpr_api.cpp

@@ -1379,8 +1379,7 @@ bool vpr_analysis_flow(const Netlist<>& net_list,
         }
 
         std::string post_routing_packing_output_file_name = vpr_setup.PackerOpts.output_file + ".post_routing";
-        write_packing_results_to_xml(vpr_setup.PackerOpts.global_clocks,
-                                     Arch.architecture_id,
+        write_packing_results_to_xml(Arch.architecture_id,
                                      post_routing_packing_output_file_name.c_str());
     } else {
         VTR_LOG_WARN("Synchronization between packing and routing results is not applied due to illegal circuit implementation\n");

vpr/src/base/vpr_types.h

@@ -710,8 +710,6 @@ enum e_stage_action {
  *          Path to technology mapped user circuit in BLIF format.
  *   @param output_file
  *          Path to packed user circuit in net format.
- *   @param global_clocks
- *          ALWAYS TRUE. (Default: True)
  *   @param timing_driven
  *          Whether or not to do timing driven clustering. (Default: on)
  *   @param timing_gain_weight
@@ -781,7 +779,6 @@ struct t_packer_opts {
     std::string circuit_file_name;
     std::string sdc_file_name;
     std::string output_file;
-    bool global_clocks;
     bool timing_driven;
     enum e_cluster_seed cluster_seed_type;
     float timing_gain_weight;

vpr/src/pack/cluster_util.cpp

@@ -74,7 +74,6 @@ void check_and_output_clustering(ClusterLegalizer& cluster_legalizer,
     }
 
     output_clustering(&cluster_legalizer,
-                      packer_opts.global_clocks,
                       is_clock,
                       arch->architecture_id,
                       packer_opts.output_file.c_str(),

vpr/src/pack/greedy_candidate_selector.cpp

@@ -296,7 +296,7 @@ void GreedyCandidateSelector::update_cluster_gain_stats_candidate_success(
             AtomNetId net_id = atom_netlist_.pin_net(pin_id);
 
             e_gain_update gain_flag = e_gain_update::NO_GAIN;
-            if (!is_clock_.count(net_id) || !packer_opts_.global_clocks)
+            if (!is_clock_.count(net_id))
                 gain_flag = e_gain_update::GAIN;
 
             mark_and_update_partial_gain(cluster_gain_stats,
@@ -324,13 +324,9 @@ void GreedyCandidateSelector::update_cluster_gain_stats_candidate_success(
         for (AtomPinId pin_id : atom_netlist_.block_clock_pins(blk_id)) {
             AtomNetId net_id = atom_netlist_.pin_net(pin_id);
 
-            e_gain_update gain_flag = e_gain_update::GAIN;
-            if (packer_opts_.global_clocks)
-                gain_flag = e_gain_update::NO_GAIN;
-
             mark_and_update_partial_gain(cluster_gain_stats,
                                          net_id,
-                                         gain_flag,
+                                         e_gain_update::NO_GAIN,
                                          blk_id,
                                          cluster_legalizer,
                                          high_fanout_net_threshold,

vpr/src/pack/output_clustering.cpp

@@ -640,7 +640,7 @@ static void clustering_xml_blocks_from_netlist(pugi::xml_node& block_node,
 /* This routine dumps out the output netlist in a format suitable for  *
  * input to vpr. This routine also dumps out the internal structure of *
  * the cluster, in essentially a graph based format.                   */
-void output_clustering(ClusterLegalizer* cluster_legalizer_ptr, bool global_clocks, const std::unordered_set<AtomNetId>& is_clock, const std::string& architecture_id, const char* out_fname, bool skip_clustering, bool from_legalizer) {
+void output_clustering(ClusterLegalizer* cluster_legalizer_ptr, const std::unordered_set<AtomNetId>& is_clock, const std::string& architecture_id, const char* out_fname, bool skip_clustering, bool from_legalizer) {
     const DeviceContext& device_ctx = g_vpr_ctx.device();
     const AtomNetlist& atom_nlist = g_vpr_ctx.atom().netlist();
 
@@ -689,17 +689,15 @@ void output_clustering(ClusterLegalizer* cluster_legalizer_ptr, bool global_cloc
     block_node.append_child("inputs").text().set(vtr::join(inputs.begin(), inputs.end(), " ").c_str());
     block_node.append_child("outputs").text().set(vtr::join(outputs.begin(), outputs.end(), " ").c_str());
 
-    if (global_clocks) {
-        std::vector<std::string> clocks;
-        for (auto net_id : atom_nlist.nets()) {
-            if (is_clock.count(net_id)) {
-                clocks.push_back(atom_nlist.net_name(net_id));
-            }
+    std::vector<std::string> clocks;
+    for (auto net_id : atom_nlist.nets()) {
+        if (is_clock.count(net_id)) {
+            clocks.push_back(atom_nlist.net_name(net_id));
         }
-
-        block_node.append_child("clocks").text().set(vtr::join(clocks.begin(), clocks.end(), " ").c_str());
     }
 
+    block_node.append_child("clocks").text().set(vtr::join(clocks.begin(), clocks.end(), " ").c_str());
+
     if (skip_clustering == false) {
         if (from_legalizer) {
             VTR_ASSERT(cluster_legalizer_ptr != nullptr);
@@ -724,15 +722,13 @@ void output_clustering(ClusterLegalizer* cluster_legalizer_ptr, bool global_cloc
  * As such, this function is expected to be a standard API
  * which can be called anytime and anywhere after packing is finished.
  ********************************************************************/
-void write_packing_results_to_xml(const bool& global_clocks,
-                                  const std::string& architecture_id,
+void write_packing_results_to_xml(const std::string& architecture_id,
                                   const char* out_fname) {
     std::unordered_set<AtomNetId> is_clock = alloc_and_load_is_clock();
 
     // Since the cluster legalizer is not being used to output the clustering
     // (from_legalizer is false), passing in nullptr.
     output_clustering(nullptr,
-                      global_clocks,
                       is_clock,
                       architecture_id,
                       out_fname,

vpr/src/pack/output_clustering.h

@@ -17,15 +17,13 @@ class ClusterLegalizer;
 /// clustered netlist. If from_legalizer is false, the clustered netlist currently
 /// in the global scope will be used.
 void output_clustering(ClusterLegalizer* cluster_legalizer_ptr,
-                       bool global_clocks,
                        const std::unordered_set<AtomNetId>& is_clock,
                        const std::string& architecture_id,
                        const char* out_fname,
                        bool skip_clustering,
                        bool from_legalizer);
 
-void write_packing_results_to_xml(const bool& global_clocks,
-                                  const std::string& architecture_id,
+void write_packing_results_to_xml(const std::string& architecture_id,
                                   const char* out_fname);
 
 #endif