feat: warn about min block weights in FM and Flow refinement, add not…

README.MD

@@ -196,7 +196,7 @@ Alternatively, one can specify the maximum weight for each block explicitly thro
 * `-b <w0> ... <wk-1>`: Same as `-B`, but specifies the maximum weights as fractions of the total node weight, i.e., the weight of the i-th block should be bounded by `wi * total node weight`.
 
 > [!TIP]
-> KaMinPar recently added support for balanced minimum block weights. 
+> KaMinPar recently added support for balanced minimum block weights (**currently only supported by LP refinement**, i.e., `-P default`).
 > These can be configured analogously to the maximum block weights via the following options:
 >
 > * `--min-epsilon=<e.g., 0.03 for 3%>`: mirrors `-e`

kaminpar-shm/presets.cc

@@ -462,10 +462,10 @@ Context create_eco_context() {
 
   ctx.refinement.algorithms = {
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER, // FM does not support min block weights
       RefinementAlgorithm::LABEL_PROPAGATION,
       RefinementAlgorithm::KWAY_FM,
-      RefinementAlgorithm::OVERLOAD_BALANCER,
+      // RefinementAlgorithm::OVERLOAD_BALANCER,
       RefinementAlgorithm::UNDERLOAD_BALANCER,
   };
 
@@ -477,13 +477,13 @@ Context create_strong_context() {
 
   ctx.refinement.algorithms = {
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER, // Flows and FM do not support min block weights
       RefinementAlgorithm::LABEL_PROPAGATION,
       RefinementAlgorithm::KWAY_FM,
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER,
       RefinementAlgorithm::TWOWAY_FLOW,
-      RefinementAlgorithm::OVERLOAD_BALANCER,
+      // RefinementAlgorithm::OVERLOAD_BALANCER,
       RefinementAlgorithm::UNDERLOAD_BALANCER,
   };
 
@@ -523,11 +523,11 @@ Context create_largek_eco_context() {
 
   ctx.refinement.algorithms = {
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER, // FM does not support min block weights
       RefinementAlgorithm::LABEL_PROPAGATION,
       RefinementAlgorithm::KWAY_FM,
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER,
   };
 
   ctx.refinement.kway_fm.gain_cache_strategy = GainCacheStrategy::COMPACT_HASHING_LARGE_K;
@@ -540,14 +540,14 @@ Context create_largek_strong_context() {
 
   ctx.refinement.algorithms = {
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER, // Flows and FM do not support min block weights
       RefinementAlgorithm::LABEL_PROPAGATION,
       RefinementAlgorithm::KWAY_FM,
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER,
       RefinementAlgorithm::TWOWAY_FLOW,
       RefinementAlgorithm::OVERLOAD_BALANCER,
-      RefinementAlgorithm::UNDERLOAD_BALANCER,
+      // RefinementAlgorithm::UNDERLOAD_BALANCER,
   };
 
   ctx.refinement.kway_fm.gain_cache_strategy = GainCacheStrategy::COMPACT_HASHING_LARGE_K;

kaminpar-shm/refinement/flow/twoway_flow_refiner.cc

@@ -29,6 +29,11 @@ void TwowayFlowRefiner::initialize([[maybe_unused]] const PartitionedGraph &p_gr
 bool TwowayFlowRefiner::refine(
     PartitionedGraph &p_graph, [[maybe_unused]] const PartitionContext &p_ctx
 ) {
+  if (p_ctx.has_min_block_weights()) {
+    LOG_WARNING
+        << "Two-way flow refinement does not support min block weights. They will be ignored.";
+  }
+
   return reified(
       p_graph,
       [&](const auto &csr_graph) {

kaminpar-shm/refinement/fm/fm_refiner.cc

@@ -184,13 +184,11 @@ template <typename Graph, typename GainCache> class LocalizedFMRefiner {
             // Thus, users of the _applied_moves vector may only depend on the order of moves that
             // found an improvement.
             if (_record_applied_moves) {
-              _applied_moves.push_back(
-                  fm::AppliedMove{
-                      .node = moved_node,
-                      .from = moved_from,
-                      .improvement = false,
-                  }
-              );
+              _applied_moves.push_back(fm::AppliedMove{
+                  .node = moved_node,
+                  .from = moved_from,
+                  .improvement = false,
+              });
             }
 
             _shared.gain_cache.move(moved_node, moved_from, moved_to);
@@ -200,13 +198,11 @@ template <typename Graph, typename GainCache> class LocalizedFMRefiner {
           });
 
           if (_record_applied_moves) {
-            _applied_moves.push_back(
-                fm::AppliedMove{
-                    .node = node,
-                    .from = block_from,
-                    .improvement = true,
-                }
-            );
+            _applied_moves.push_back(fm::AppliedMove{
+                .node = node,
+                .from = block_from,
+                .improvement = true,
+            });
           }
 
           // Flush local delta
@@ -656,6 +652,10 @@ void FMRefiner::initialize(const PartitionedGraph &p_graph) {
 }
 
 bool FMRefiner::refine(PartitionedGraph &p_graph, const PartitionContext &p_ctx) {
+  if (p_ctx.has_min_block_weights()) {
+    LOG_WARNING << "FM refinement does not support min block weights. They will be ignored.";
+  }
+
   return _core->refine(p_graph, p_ctx);
 }