empty blocks: use removed degree zero nodes correctly (#225)

- allow empty blocks if it is known they can be fixed
  using degree zero nodes in postprocessing
- prioritize fixing empty blocks in preprocessing
- correctly handle individual part weights edge case:
  a removed node might be heavier than a block with
  very small weight

Author: N-Maas

mt-kahypar/partition/metrics.cpp

@@ -207,6 +207,7 @@ BalanceMetrics imbalance_impl(const PartitionedHypergraph& hypergraph,
   ASSERT(context.partition.perfect_balance_part_weights.size() == (size_t)context.partition.k);
 
   size_t num_empty_parts = 0;
+  HypernodeWeight min_empty_part_weight = std::numeric_limits<HypernodeWeight>::max();
   double max_balance = 0.0;
   bool violates_balance = false;
   for (PartitionID i = 0; i < context.partition.k; ++i) {
@@ -219,11 +220,16 @@ BalanceMetrics imbalance_impl(const PartitionedHypergraph& hypergraph,
     }
     if (part_weight == 0) {
       num_empty_parts++;
+      min_empty_part_weight = std::min(min_empty_part_weight, part_weight);
     }
   }
+
   bool too_many_empty_parts = num_empty_parts > hypergraph.numRemovedHypernodes();
+  // use conservative estimate
+  bool too_small_empty_parts = num_empty_parts > 0
+    && min_empty_part_weight < hypergraph.maxWeightOfRemovedDegreeZeroNode();
   return BalanceMetrics{max_balance - 1.0, violates_balance,
-    !context.partition.allow_empty_blocks && too_many_empty_parts};
+    !context.partition.allow_empty_blocks && (too_many_empty_parts || too_small_empty_parts)};
 }
 
 template<typename PartitionedHypergraph>

mt-kahypar/partition/preprocessing/sparsification/degree_zero_hn_remover.h

@@ -79,7 +79,12 @@ class DegreeZeroHypernodeRemover {
       });
     // Sort blocks of partition in increasing order of their weight
     auto distance_to_max = [&](const PartitionID block) {
-      return hypergraph.partWeight(block) - _context.partition.max_part_weights[block];
+      if (!_context.partition.allow_empty_blocks && hypergraph.partWeight(block) == 0) {
+        // repairing empty blocks gets highest priority
+        return -(_context.partition.max_part_weights[block] + hypergraph.totalWeight());
+      } else {
+        return hypergraph.partWeight(block) - _context.partition.max_part_weights[block];
+      }
     };
     parallel::scalable_vector<PartitionID> blocks(_context.partition.k, 0);
     std::iota(blocks.begin(), blocks.end(), 0);

mt-kahypar/partition/refinement/rebalancing/repair_empty_blocks.cpp

@@ -62,6 +62,35 @@ void RepairEmtpyBlocks<GraphAndGainTypes>::computeEmptyParts(PartitionedHypergra
       _empty_parts.push_back(block);
     }
   }
+
+  const auto& max_weights = _context.partition.max_part_weights;
+  if (!_empty_parts.empty() && _context.partition.use_individual_part_weights) {
+    // We sort the empty parts, so that
+    // (1) we can determine which parts to skip for degree zero nodes
+    // (2) computeBestMovesBlockIndependent can maintain the invariant that the last entry
+    // of best_move_for_part is the worst move in the list. This invariant could be broken
+    // if a node does not fit in a block (unlikely, but possible) and therefore "skips"
+    // a part of the list. However, by sorting descending by part weight, this can't happen
+    // since a move at position i + 1 is guaranteed to also fit in position i, and thus
+    // can not be better than the move at position i (or it would be placed there).
+    std::sort(_empty_parts.begin(), _empty_parts.end(), [&](PartitionID lhs, PartitionID rhs) {
+      // deterministic tie breaking
+      return max_weights[lhs] > max_weights[rhs] || (max_weights[lhs] == max_weights[rhs] && lhs < rhs);
+    });
+  }
+
+  if (!_empty_parts.empty() && phg.numRemovedHypernodes() > 0) {
+    // since some of the blocks can be filled by degree zero nodes at the end, we can throw
+    // out all blocks that can be filled in this way
+    HypernodeWeight max_removed_weight = phg.maxWeightOfRemovedDegreeZeroNode();
+    size_t last_fitting = 0;
+    while (last_fitting < _empty_parts.size()
+           && max_removed_weight <= max_weights[_empty_parts[last_fitting]]) {
+      ++last_fitting;
+    }
+    size_t start = (phg.numRemovedHypernodes() >= last_fitting) ? 0 : last_fitting - phg.numRemovedHypernodes();
+    _empty_parts.erase(_empty_parts.begin() + start, _empty_parts.begin() + last_fitting);
+  }
 }
 
 template <typename GraphAndGainTypes>
@@ -74,20 +103,6 @@ void RepairEmtpyBlocks<GraphAndGainTypes>::computeBestMovesBlockIndependent(Part
     _global_best_move_for_part.clear();
     _global_best_move_for_part.resize(_empty_parts.size(), Move{});
 
-    if (_context.partition.use_individual_part_weights) {
-      // We sort the empty parts, so that we can maintain the invariant that the last entry
-      // of best_move_for_part is the worst move in the list. This invariant could be broken
-      // if a node does not fit in a block (unlikely, but possible) and therefore "skips"
-      // a part of the list. However, by sorting descending by part weight, this can't happen
-      // since a move at position i + 1 is guaranteed to also fit in position i, and thus
-      // can not be better than the move at position i (or it would be placed there).
-      const auto& max_weights = _context.partition.max_part_weights;
-      std::sort(_empty_parts.begin(), _empty_parts.end(), [&](PartitionID lhs, PartitionID rhs) {
-        // deterministic tie breaking
-        return max_weights[lhs] > max_weights[rhs] || (max_weights[lhs] == max_weights[rhs] && lhs < rhs);
-      });
-    }
-
     auto insert_move_into_list = [&](Move& current_move, vec<Move>& move_for_part) {
       const Move& worst_move = move_for_part.back();
       if (moveIsBetter(current_move, worst_move)) {