Coarsening: fixed vertex support

N-Maas · N-Maas · commit 76f8eda21241 · 2025-06-11T13:48:46.000+02:00
diff --git a/mt-kahypar/partition/coarsening/deterministic_multilevel_coarsener.cpp b/mt-kahypar/partition/coarsening/deterministic_multilevel_coarsener.cpp
@@ -29,6 +29,7 @@
 #include <tbb/parallel_sort.h>
 
 #include "mt-kahypar/definitions.h"
+#include "mt-kahypar/partition/coarsening/policies/rating_fixed_vertex_acceptance_policy.h"
 #include "mt-kahypar/utils/hash.h"
 
 namespace mt_kahypar {
@@ -54,6 +55,9 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
     clusters[u] = u;
   });
 
+  ds::FixedVertexSupport<Hypergraph> fixed_vertices = hg.copyOfFixedVertexSupport();
+  fixed_vertices.setMaxBlockWeight(_context.partition.max_part_weights);
+
   const bool isPrefixDoublingPass = _context.coarsening.det_prefix_doubling;
   if (isPrefixDoublingPass) {
     permutation.shuffle(utils::IntegerRange<HypernodeID>{0, num_nodes}, _context.shared_memory.static_balancing_work_packages, config.prng); // need shuffle for prefix-doubling
@@ -75,7 +79,11 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
       }
       last = std::min<size_t>(num_nodes_before_pass, first + dist);
 
-      clusterNodesInRange(clusters, num_nodes, first, last);
+      if (hg.hasFixedVertices()) {
+        clusterNodesInRange<true>(clusters, num_nodes, first, last, fixed_vertices);
+      } else {
+        clusterNodesInRange<false>(clusters, num_nodes, first, last, fixed_vertices);
+      }
     }
   } else {
     permutation.random_grouping(num_nodes, _context.shared_memory.static_balancing_work_packages, config.prng());
@@ -84,7 +92,11 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
         sub_round, config.num_buckets, config.num_buckets_per_sub_round);
       size_t first = permutation.bucket_bounds[first_bucket], last = permutation.bucket_bounds[last_bucket];
 
-      clusterNodesInRange(clusters, num_nodes, first, last);
+      if (hg.hasFixedVertices()) {
+        clusterNodesInRange<true>(clusters, num_nodes, first, last, fixed_vertices);
+      } else {
+        clusterNodesInRange<false>(clusters, num_nodes, first, last, fixed_vertices);
+      }
     }
   }
 
@@ -100,18 +112,23 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
 }
 
 template<typename TypeTraits>
-void DeterministicMultilevelCoarsener<TypeTraits>::clusterNodesInRange(vec<HypernodeID>& clusters, HypernodeID& num_nodes, size_t first, size_t last) {
+template<bool has_fixed_vertices>
+void DeterministicMultilevelCoarsener<TypeTraits>::clusterNodesInRange(vec<HypernodeID>& clusters,
+                                                                       HypernodeID& num_nodes,
+                                                                       size_t first,
+                                                                       size_t last,
+                                                                       ds::FixedVertexSupport<Hypergraph>& fixed_vertices) {
   const Hypergraph& hg = Base::currentHypergraph();
 
   // each vertex finds a cluster it wants to join
   tbb::parallel_for(first, last, [&](size_t pos) {
     const HypernodeID u = permutation.at(pos);
     if (cluster_weight[u] == hg.nodeWeight(u) && hg.nodeIsEnabled(u)) {
       if (useLargeRatingMapForRatingOfHypernode(hg, u)) {
-        calculatePreferredTargetCluster(u, clusters, default_rating_maps.local());
+        calculatePreferredTargetCluster<has_fixed_vertices>(u, clusters, default_rating_maps.local(), fixed_vertices);
       } else {
         // note: the cache efficient rating map is still deterministic since its size (and thus the iteration order) never changes
-        calculatePreferredTargetCluster(u, clusters, cache_efficient_rating_maps.local());
+        calculatePreferredTargetCluster<has_fixed_vertices>(u, clusters, cache_efficient_rating_maps.local(), fixed_vertices);
       }
     }
   });
@@ -132,8 +149,14 @@ void DeterministicMultilevelCoarsener<TypeTraits>::clusterNodesInRange(vec<Hyper
         } else if (_context.coarsening.det_fix_cluster_weights) {
           cluster_weights_to_fix.push_back_buffered(u);
         }
-        clusters[u] = target;
-        cluster_weight[target] = opportunistic_cluster_weight[target];
+        bool accept_fixed_vertex_contraction = true;
+        if constexpr (has_fixed_vertices) {
+          accept_fixed_vertex_contraction = fixed_vertices.contract(target, u);
+        }
+        if (accept_fixed_vertex_contraction) {
+          clusters[u] = target;
+          cluster_weight[target] = opportunistic_cluster_weight[target];
+        }
       } else {
         if (_context.coarsening.det_fix_cluster_weights && opportunistic_cluster_weight[u] != hg.nodeWeight(u)) {
           // node u could still not move
@@ -147,7 +170,7 @@ void DeterministicMultilevelCoarsener<TypeTraits>::clusterNodesInRange(vec<Hyper
   num_nodes -= num_contracted_nodes.combine(std::plus<>());
   nodes_in_too_heavy_clusters.finalize();
   if (nodes_in_too_heavy_clusters.size() > 0) {
-    num_nodes -= approveVerticesInTooHeavyClusters(clusters);
+    num_nodes -= approveVerticesInTooHeavyClusters<has_fixed_vertices>(clusters, fixed_vertices);
     nodes_in_too_heavy_clusters.clear();
   }
 
@@ -183,8 +206,11 @@ void DeterministicMultilevelCoarsener<TypeTraits>::clusterNodesInRange(vec<Hyper
 }
 
 template<typename TypeTraits>
-template<typename RatingMap>
-void DeterministicMultilevelCoarsener<TypeTraits>::calculatePreferredTargetCluster(HypernodeID u, const vec<HypernodeID>& clusters, RatingMap& tmp_ratings) {
+template<bool has_fixed_vertices, typename RatingMap>
+void DeterministicMultilevelCoarsener<TypeTraits>::calculatePreferredTargetCluster(HypernodeID u,
+                                                                                   const vec<HypernodeID>& clusters,
+                                                                                   RatingMap& tmp_ratings,
+                                                                                   const ds::FixedVertexSupport<Hypergraph>& fixed_vertices) {
   const Hypergraph& hg = Base::currentHypergraph();
   tmp_ratings.clear();
 
@@ -223,8 +249,14 @@ void DeterministicMultilevelCoarsener<TypeTraits>::calculatePreferredTargetClust
   for (const auto& entry : tmp_ratings) {
     HypernodeID target_cluster = entry.key;
     double target_score = entry.value;
+    bool accept_fixed_vertex_contraction = true;
+    if constexpr ( has_fixed_vertices ) {
+      accept_fixed_vertex_contraction = FixedVertexAcceptancePolicy::acceptContraction(hg, fixed_vertices, _context, target_cluster,u);
+    }
+
     if (target_score >= best_score && target_cluster != u && hg.communityID(target_cluster) == comm_u
-        && cluster_weight[target_cluster] + weight_u <= _context.coarsening.max_allowed_node_weight) {
+        && cluster_weight[target_cluster] + weight_u <= _context.coarsening.max_allowed_node_weight
+        && accept_fixed_vertex_contraction) {
       if (target_score > best_score) {
         best_targets.clear();
         best_score = target_score;
@@ -268,7 +300,8 @@ void DeterministicMultilevelCoarsener<TypeTraits>::calculatePreferredTargetClust
 }
 
 template<typename TypeTraits>
-size_t DeterministicMultilevelCoarsener<TypeTraits>::approveVerticesInTooHeavyClusters(vec<HypernodeID>& clusters) {
+template<bool has_fixed_vertices>
+size_t DeterministicMultilevelCoarsener<TypeTraits>::approveVerticesInTooHeavyClusters(vec<HypernodeID>& clusters, ds::FixedVertexSupport<Hypergraph>& fixed_vertices) {
   const Hypergraph& hg = Base::currentHypergraph();
   tbb::enumerable_thread_specific<size_t> num_contracted_nodes { 0 };
 
@@ -295,6 +328,9 @@ size_t DeterministicMultilevelCoarsener<TypeTraits>::approveVerticesInTooHeavyCl
         if (target_weight + hg.nodeWeight(v) > _context.coarsening.max_allowed_node_weight) {
           break;
         }
+        if (has_fixed_vertices && !fixed_vertices.contract(target, v)) {
+          continue;
+        }
         clusters[v] = target;
         target_weight += hg.nodeWeight(v);
         if (opportunistic_cluster_weight[v] == hg.nodeWeight(v)) {
diff --git a/mt-kahypar/partition/coarsening/deterministic_multilevel_coarsener.h b/mt-kahypar/partition/coarsening/deterministic_multilevel_coarsener.h
@@ -34,6 +34,7 @@
 #include "mt-kahypar/utils/reproducible_random.h"
 #include "mt-kahypar/datastructures/sparse_map.h"
 #include "mt-kahypar/datastructures/buffered_vector.h"
+#include "mt-kahypar/datastructures/fixed_vertex_support.h"
 #include "mt-kahypar/utils/utilities.h"
 #include "mt-kahypar/utils/progress_bar.h"
 #include "mt-kahypar/utils/cast.h"
@@ -125,12 +126,21 @@ class DeterministicMultilevelCoarsener :  public ICoarsener,
                     (hg.initialNumNodes() - hg.numRemovedHypernodes()) / _context.coarsening.maximum_shrink_factor) );
   }
 
-  void clusterNodesInRange(vec<HypernodeID>& clusters, HypernodeID& num_nodes, size_t first, size_t last);
-
-  template<typename RatingMap>
-  void calculatePreferredTargetCluster(HypernodeID u, const vec<HypernodeID>& clusters, RatingMap& tmp_ratings);
-
-  size_t approveVerticesInTooHeavyClusters(vec<HypernodeID>& clusters);
+  template<bool has_fixed_vertices>
+  void clusterNodesInRange(vec<HypernodeID>& clusters,
+                           HypernodeID& num_nodes,
+                           size_t first,
+                           size_t last,
+                           ds::FixedVertexSupport<Hypergraph>& fixed_vertices);
+
+  template<bool has_fixed_vertices, typename RatingMap>
+  void calculatePreferredTargetCluster(HypernodeID u,
+                                       const vec<HypernodeID>& clusters,
+                                       RatingMap& tmp_ratings,
+                                       const ds::FixedVertexSupport<Hypergraph>& fixed_vertices);
+
+  template<bool has_fixed_vertices>
+  size_t approveVerticesInTooHeavyClusters(vec<HypernodeID>& clusters, ds::FixedVertexSupport<Hypergraph>& fixed_vertices);
 
   HypernodeID currentNumberOfNodesImpl() const override {
     return Base::currentNumNodes();
