mpl: create and use method for connecting clusters

Signed-off-by: Arthur Koucher <[email protected]>

Author: AcKoucher

src/mpl/src/clusterEngine.cpp

@@ -1027,46 +1027,57 @@ void ClusteringEngine::buildDataFlowConnections()
     }
 
     const int driver_id = itr->second;
+    Cluster* driver_cluster = tree_->maps.id_to_cluster.at(driver_id);
 
     for (int hops = 0; hops < max_num_of_hops_; hops++) {
       std::set<int> sink_clusters = computeSinks(insts[hops]);
       const float conn_weight = computeConnWeight(hops);
       for (auto& sink : sink_clusters) {
-        tree_->maps.id_to_cluster[driver_id]->addConnection(sink, conn_weight);
-        tree_->maps.id_to_cluster[sink]->addConnection(driver_id, conn_weight);
+        Cluster* sink_cluster = tree_->maps.id_to_cluster.at(sink);
+        connect(driver_cluster, sink_cluster, conn_weight);
       }
     }
   }
 
   // macros to ffs
   for (const auto& [iterm, insts] : data_connections_.macro_pins_and_regs) {
     const int driver_id = tree_->maps.inst_to_cluster_id.at(iterm->getInst());
+    Cluster* driver_cluster = tree_->maps.id_to_cluster.at(driver_id);
 
     for (int hops = 0; hops < max_num_of_hops_; hops++) {
       std::set<int> sink_clusters = computeSinks(insts[hops]);
       const float conn_weight = computeConnWeight(hops);
       for (auto& sink : sink_clusters) {
-        tree_->maps.id_to_cluster[driver_id]->addConnection(sink, conn_weight);
-        tree_->maps.id_to_cluster[sink]->addConnection(driver_id, conn_weight);
+        Cluster* sink_cluster = tree_->maps.id_to_cluster.at(sink);
+        connect(driver_cluster, sink_cluster, conn_weight);
       }
     }
   }
 
   // macros to macros
   for (const auto& [iterm, insts] : data_connections_.macro_pins_and_macros) {
     const int driver_id = tree_->maps.inst_to_cluster_id.at(iterm->getInst());
+    Cluster* driver_cluster = tree_->maps.id_to_cluster.at(driver_id);
 
     for (int hops = 0; hops < max_num_of_hops_; hops++) {
       std::set<int> sink_clusters = computeSinks(insts[hops]);
       const float conn_weight = computeConnWeight(hops);
       for (auto& sink : sink_clusters) {
-        tree_->maps.id_to_cluster[driver_id]->addConnection(sink, conn_weight);
-        tree_->maps.id_to_cluster[sink]->addConnection(driver_id, conn_weight);
+        Cluster* sink_cluster = tree_->maps.id_to_cluster.at(sink);
+        connect(driver_cluster, sink_cluster, conn_weight);
       }
     }
   }
 }
 
+void ClusteringEngine::connect(Cluster* a,
+                               Cluster* b,
+                               const float connection_weight) const
+{
+  a->addConnection(b, connection_weight);
+  b->addConnection(a, connection_weight);
+}
+
 float ClusteringEngine::computeConnWeight(const int hops)
 {
   const float base_remoteness_factor = 2.0;
@@ -1863,7 +1874,7 @@ bool ClusteringEngine::attemptMerge(Cluster* receiver, Cluster* incomer)
       for (const auto& [cluster_id, connection_weight] : incomer_connections) {
         Cluster* cluster = tree_->maps.id_to_cluster.at(cluster_id);
         cluster->removeConnection(incomer_id);
-        cluster->addConnection(receiver->getId(), connection_weight);
+        cluster->addConnection(receiver, connection_weight);
       }
     }
 
@@ -1928,13 +1939,12 @@ void ClusteringEngine::buildNetListConnections()
     if (driver_cluster_id != -1 && !load_clusters_ids.empty()
         && load_clusters_ids.size() < tree_->large_net_threshold) {
       const float weight = net_has_io_pin ? tree_->virtual_weight : 1.0;
+      Cluster* driver_cluster = tree_->maps.id_to_cluster.at(driver_cluster_id);
 
       for (const int load_cluster_id : load_clusters_ids) {
-        if (load_cluster_id != driver_cluster_id) { /* undirected connection */
-          tree_->maps.id_to_cluster[driver_cluster_id]->addConnection(
-              load_cluster_id, weight);
-          tree_->maps.id_to_cluster[load_cluster_id]->addConnection(
-              driver_cluster_id, weight);
+        if (load_cluster_id != driver_cluster_id) {
+          Cluster* load_cluster = tree_->maps.id_to_cluster.at(load_cluster_id);
+          connect(driver_cluster, load_cluster, weight);
         }
       }
     }

src/mpl/src/clusterEngine.h

@@ -241,6 +241,7 @@ class ClusteringEngine
   void clearConnections();
   void buildNetListConnections();
   void buildDataFlowConnections();
+  void connect(Cluster* a, Cluster* b, float connection_weight) const;
 
   // Methods for data flow
   void createDataFlow();

src/mpl/src/object.cpp

@@ -568,13 +568,9 @@ void Cluster::initConnection()
   connections_map_.clear();
 }
 
-void Cluster::addConnection(int cluster_id, float weight)
+void Cluster::addConnection(Cluster* cluster, const float connection_weight)
 {
-  if (connections_map_.find(cluster_id) == connections_map_.end()) {
-    connections_map_[cluster_id] = weight;
-  } else {
-    connections_map_[cluster_id] += weight;
-  }
+  connections_map_[cluster->getId()] += connection_weight;
 }
 
 void Cluster::removeConnection(int cluster_id)

src/mpl/src/object.h

@@ -209,7 +209,7 @@ class Cluster
 
   // Connection signature support
   void initConnection();
-  void addConnection(int cluster_id, float weight);
+  void addConnection(Cluster* cluster, float connection_weight);
   void removeConnection(int cluster_id);
   const ConnectionsMap& getConnectionsMap() const;
   bool isSameConnSignature(const Cluster& cluster, float net_threshold);