Deterministic 2

config/deterministic_preset.ini

@@ -48,6 +48,7 @@ i-r-lp-maximum-iterations=5
 i-r-sync-lp-sub-rounds=1
 i-r-lp-he-size-activation-threshold=100
 i-r-sync-lp-active-nodeset=true
+i-r-sync-lp-recalculate-gains-on-second-apply=false
 # main -> initial_partitioning -> refinement -> fm
 i-r-fm-type=do_nothing
 i-population-size=64
@@ -59,5 +60,6 @@ r-lp-maximum-iterations=5
 r-sync-lp-sub-rounds=1
 r-lp-he-size-activation-threshold=100
 r-sync-lp-active-nodeset=true
+r-sync-lp-recalculate-gains-on-second-apply=false
 # main -> refinement -> fm
 r-fm-type=do_nothing

mt-kahypar/datastructures/array.h

@@ -108,7 +108,7 @@ class Array {
       }
 
       reference operator[](const difference_type& n) const {
-        return *_ptr[n];
+        return _ptr[n];
       }
 
       bool operator==(const ArrayIterator& other) const {
@@ -483,4 +483,4 @@ namespace parallel {
 
 }
 
-}  // namespace mt_kahypar
+}  // namespace mt_kahypar

mt-kahypar/datastructures/concurrent_bucket_map.h

@@ -69,8 +69,7 @@ class ConcurrentBucketMap {
  public:
 
   ConcurrentBucketMap() :
-    _num_buckets(align_to_next_power_of_two(
-      BUCKET_FACTOR * std::thread::hardware_concurrency())),
+    _num_buckets(align_to_next_power_of_two(BUCKET_FACTOR * std::thread::hardware_concurrency())),
     _mod_mask(_num_buckets - 1),
     _spin_locks(_num_buckets),
     _buckets(_num_buckets) { }
@@ -79,8 +78,7 @@ class ConcurrentBucketMap {
   ConcurrentBucketMap & operator= (const ConcurrentBucketMap &) = delete;
 
   ConcurrentBucketMap(ConcurrentBucketMap&& other) :
-    _num_buckets(align_to_next_power_of_two(
-      BUCKET_FACTOR * std::thread::hardware_concurrency())),
+    _num_buckets(other._num_buckets),
     _mod_mask(_num_buckets - 1),
     _spin_locks(_num_buckets),
     _buckets(std::move(other._buffer)) { }

mt-kahypar/datastructures/dynamic_graph.h

@@ -680,7 +680,7 @@ class DynamicGraph {
 
   // ####################### Contract / Uncontract #######################
 
-  DynamicGraph contract(parallel::scalable_vector<HypernodeID>&) {
+  DynamicGraph contract(parallel::scalable_vector<HypernodeID>&, bool deterministic = false) {
     throw NonSupportedOperationException(
       "contract(c, id) is not supported in dynamic graph");
     return DynamicGraph();
@@ -929,4 +929,4 @@ class DynamicGraph {
 };
 
 } // namespace ds
-} // namespace mt_kahypar
+} // namespace mt_kahypar

mt-kahypar/datastructures/dynamic_hypergraph.cpp

@@ -498,7 +498,7 @@ void DynamicHypergraph::memoryConsumption(utils::MemoryTreeNode* parent) const {
   parent->addChild("Incidence Array", sizeof(HypernodeID) * _incidence_array.size());
   parent->addChild("Hyperedge Ownership Vector", sizeof(bool) * _acquired_hes.size());
   parent->addChild("Bitsets",
-    ( _num_hyperedges * _he_bitset.size() ) / 8UL + sizeof(uint16_t) * _num_hyperedges);
+    ( _num_hyperedges * _he_bitset.size() ) / size_t(8) + sizeof(uint16_t) * _num_hyperedges);
 
   utils::MemoryTreeNode* contraction_tree_node = parent->addChild("Contraction Tree");
   _contraction_tree.memoryConsumption(contraction_tree_node);
@@ -763,4 +763,4 @@ BatchVector DynamicHypergraph::createBatchUncontractionHierarchyForVersion(Batch
 }
 
 } // namespace ds
-} // namespace mt_kahypar
+} // namespace mt_kahypar

mt-kahypar/datastructures/dynamic_hypergraph.h

@@ -774,7 +774,7 @@ class DynamicHypergraph {
 
   // ####################### Contract / Uncontract #######################
 
-  DynamicHypergraph contract(parallel::scalable_vector<HypernodeID>&) {
+  DynamicHypergraph contract(parallel::scalable_vector<HypernodeID>&, bool deterministic = false) {
     throw NonSupportedOperationException(
       "contract(c, id) is not supported in dynamic hypergraph");
     return DynamicHypergraph();
@@ -1164,4 +1164,4 @@ class DynamicHypergraph {
 };
 
 } // namespace ds
-} // namespace mt_kahypar
+} // namespace mt_kahypar

mt-kahypar/datastructures/partitioned_hypergraph.h

@@ -454,7 +454,7 @@ class PartitionedHypergraph {
     // Recalculate pin count in parts
     const size_t incidence_array_start = _hg->hyperedge(he).firstEntry();
     const size_t incidence_array_end = _hg->hyperedge(he).firstInvalidEntry();
-    tls_enumerable_thread_specific< vec<HypernodeID> > ets_pin_count_in_part(_k, 0);
+    tbb::enumerable_thread_specific< vec<HypernodeID> > ets_pin_count_in_part(_k, 0);
     tbb::parallel_for(incidence_array_start, incidence_array_end, [&](const size_t pos) {
       const HypernodeID pin = _hg->_incidence_array[pos];
       const PartitionID block = partID(pin);

mt-kahypar/datastructures/pin_count_snapshot.h

@@ -151,7 +151,7 @@ class PinCountSnapshot {
   static size_t num_entries_per_value(const PartitionID k,
                                       const HypernodeID max_value) {
     const size_t bits_per_element = num_bits_per_element(max_value);
-    const size_t bits_per_value = sizeof(Value) * 8UL;
+    const size_t bits_per_value = sizeof(Value) * size_t(8);
     ASSERT(bits_per_element <= bits_per_value);
     return std::min(bits_per_value / bits_per_element, static_cast<size_t>(k));
   }

mt-kahypar/datastructures/static_graph.cpp

@@ -46,14 +46,14 @@ namespace mt_kahypar::ds {
    *
    * \param communities Community structure that should be contracted
    */
-  StaticGraph StaticGraph::contract(parallel::scalable_vector<HypernodeID>& communities) {
+  StaticGraph StaticGraph::contract(parallel::scalable_vector<HypernodeID>& communities, bool /*deterministic*/) {
     ASSERT(communities.size() == _num_nodes);
 
     if ( !_tmp_contraction_buffer ) {
       allocateTmpContractionBuffer();
     }
 
-    // AUXILLIARY BUFFERS - Reused during multilevel hierarchy to prevent expensive allocations
+    // AUXILIARY BUFFERS - Reused during multilevel hierarchy to prevent expensive allocations
     Array<HypernodeID>& mapping = _tmp_contraction_buffer->mapping;
     Array<Node>& tmp_nodes = _tmp_contraction_buffer->tmp_nodes;
     Array<HyperedgeID>& node_sizes = _tmp_contraction_buffer->node_sizes;
@@ -507,4 +507,4 @@ namespace mt_kahypar::ds {
                                          }, std::plus<>());
   }
 
-} // namespace
+} // namespace

mt-kahypar/datastructures/static_graph.h

@@ -767,7 +767,7 @@ class StaticGraph {
    *
    * \param communities Community structure that should be contracted
    */
-  StaticGraph contract(parallel::scalable_vector<HypernodeID>& communities);
+  StaticGraph contract(parallel::scalable_vector<HypernodeID>& communities, bool deterministic = false);
 
   bool registerContraction(const HypernodeID, const HypernodeID) {
     throw NonSupportedOperationException(
@@ -960,4 +960,4 @@ class StaticGraph {
 };
 
 } // namespace ds
-} // namespace mt_kahypar
+} // namespace mt_kahypar

mt-kahypar/datastructures/static_hypergraph.cpp

@@ -33,6 +33,7 @@
 #include "mt-kahypar/utils/memory_tree.h"
 
 #include <tbb/parallel_reduce.h>
+#include <tbb/parallel_sort.h>
 
 namespace mt_kahypar::ds {
 
@@ -57,7 +58,7 @@ namespace mt_kahypar::ds {
    *
    * \param communities Community structure that should be contracted
    */
-  StaticHypergraph StaticHypergraph::contract(parallel::scalable_vector<HypernodeID>& communities) {
+  StaticHypergraph StaticHypergraph::contract(parallel::scalable_vector<HypernodeID>& communities, bool deterministic) {
 
     ASSERT(communities.size() == _num_hypernodes);
 
@@ -131,9 +132,6 @@ namespace mt_kahypar::ds {
       ASSERT(coarse_hn < num_hypernodes, V(coarse_hn) << V(num_hypernodes));
       // Weight vector is atomic => thread-safe
       hn_weights[coarse_hn] += nodeWeight(hn);
-      // In case community detection is enabled all vertices matched to one vertex
-      // in the contracted hypergraph belong to same community. Otherwise, all communities
-      // are default assigned to community 0
       // Aggregate upper bound for number of incident nets of the contracted vertex
       tmp_num_incident_nets[coarse_hn] += nodeDegree(hn);
     });
@@ -288,6 +286,12 @@ namespace mt_kahypar::ds {
           // Update number of incident nets of high degree vertex
           const size_t contracted_size = incident_nets_pos.load() - incident_nets_start;
           tmp_hypernodes[coarse_hn].setSize(contracted_size);
+
+          if (deterministic) {
+            // sort for determinism
+            tbb::parallel_sort(tmp_incident_nets.begin() + incident_nets_start,
+                               tmp_incident_nets.begin() + incident_nets_start + contracted_size);
+          }
         }
         duplicate_incident_nets_map.free();
       }
@@ -373,8 +377,7 @@ namespace mt_kahypar::ds {
     // Compute number of hyperedges in coarse graph (those flagged as valid)
     parallel::TBBPrefixSum<size_t, Array> he_mapping(valid_hyperedges);
     tbb::parallel_invoke([&] {
-      tbb::parallel_scan(tbb::blocked_range<size_t>(
-              UL(0), UI64(_num_hyperedges)), he_mapping);
+      tbb::parallel_scan(tbb::blocked_range<size_t>(size_t(0), size_t(_num_hyperedges)), he_mapping);
     }, [&] {
       hypergraph._hypernodes.resize(num_hypernodes);
     });
@@ -394,7 +397,7 @@ namespace mt_kahypar::ds {
       // Compute start position of each hyperedge in incidence array
       parallel::TBBPrefixSum<size_t, Array> num_pins_prefix_sum(he_sizes);
       tbb::parallel_invoke([&] {
-        tbb::parallel_for(ID(0), _num_hyperedges, [&](const HyperedgeID& id) {
+        tbb::parallel_for(HyperedgeID(0), _num_hyperedges, [&](HyperedgeID id) {
           if ( he_mapping.value(id) ) {
             he_sizes[id] = tmp_hyperedges[id].size();
           } else {
@@ -414,11 +417,11 @@ namespace mt_kahypar::ds {
       // Write hyperedges from temporary buffers to incidence array
       tbb::enumerable_thread_specific<size_t> local_max_edge_size(UL(0));
       tbb::parallel_for(ID(0), _num_hyperedges, [&](const HyperedgeID& id) {
-        if ( he_mapping.value(id) /* hyperedge is valid */ ) {
+        if ( he_mapping.value(id) > 0 /* hyperedge is valid */ ) {
           const size_t he_pos = he_mapping[id];
           const size_t incidence_array_start = num_pins_prefix_sum[id];
           Hyperedge& he = hypergraph._hyperedges[he_pos];
-          he = std::move(tmp_hyperedges[id]);
+          he = tmp_hyperedges[id];
           const size_t tmp_incidence_array_start = he.firstEntry();
           const size_t edge_size = he.size();
           local_max_edge_size.local() = std::max(local_max_edge_size.local(), edge_size);
@@ -442,7 +445,7 @@ namespace mt_kahypar::ds {
         size_t incident_nets_end = tmp_hypernodes[id].firstInvalidEntry();
         for ( size_t pos = incident_nets_start; pos < incident_nets_end; ++pos ) {
           const HyperedgeID he = tmp_incident_nets[pos];
-          if ( he_mapping.value(he) ) {
+          if ( he_mapping.value(he) > 0 /* hyperedge is valid */ ) {
             tmp_incident_nets[pos] = he_mapping[he];
           } else {
             std::swap(tmp_incident_nets[pos--], tmp_incident_nets[--incident_nets_end]);
@@ -466,7 +469,7 @@ namespace mt_kahypar::ds {
       tbb::parallel_for(ID(0), num_hypernodes, [&](const HypernodeID& id) {
         const size_t incident_nets_start = num_incident_nets_prefix_sum[id];
         Hypernode& hn = hypergraph._hypernodes[id];
-        hn = std::move(tmp_hypernodes[id]);
+        hn = tmp_hypernodes[id];
         const size_t tmp_incident_nets_start = hn.firstEntry();
         std::memcpy(hypergraph._incident_nets.data() + incident_nets_start,
                     tmp_incident_nets.data() + tmp_incident_nets_start,
@@ -593,4 +596,4 @@ namespace mt_kahypar::ds {
                                          }, std::plus<>());
   }
 
-} // namespace
+} // namespace

mt-kahypar/datastructures/static_hypergraph.h

@@ -738,7 +738,7 @@ class StaticHypergraph {
    *
    * \param communities Community structure that should be contracted
    */
-  StaticHypergraph contract(parallel::scalable_vector<HypernodeID>& communities);
+  StaticHypergraph contract(parallel::scalable_vector<HypernodeID>& communities, bool deterministic = false);
 
   bool registerContraction(const HypernodeID, const HypernodeID) {
     throw NonSupportedOperationException(
@@ -1013,4 +1013,4 @@ class StaticHypergraph {
 };
 
 } // namespace ds
-} // namespace mt_kahypar
+} // namespace mt_kahypar

mt-kahypar/io/command_line_options.cpp

@@ -72,8 +72,7 @@ namespace mt_kahypar {
     options.add_options()
             ("help", "show help message")
             ("deterministic", po::value<bool>(&context.partition.deterministic)->value_name("<bool>")->default_value(false),
-             "Shortcut to enables deterministic partitioning mode, where results are reproducible across runs. "
-             "If set, the specific deterministic subroutines don't need to be set manually.")
+             "Enables deterministic mode.")
             ("verbose,v", po::value<bool>(&context.partition.verbose_output)->value_name("<bool>")->default_value(true),
              "Verbose main partitioning output")
             ("fixed,f",
@@ -367,7 +366,7 @@ namespace mt_kahypar {
              po::value<bool>((!initial_partitioning ? &context.refinement.deterministic_refinement.use_active_node_set :
                                 &context.initial_partitioning.refinement.deterministic_refinement.use_active_node_set))->value_name(
                      "<bool>")->default_value(true),
-             "Number of sub-rounds for deterministic synchronous label propagation")
+             "Use active nodeset in synchronous label propagation")
             ((initial_partitioning ? "i-r-lp-rebalancing" : "r-lp-rebalancing"),
              po::value<bool>((!initial_partitioning ? &context.refinement.label_propagation.rebalancing :
                               &context.initial_partitioning.refinement.label_propagation.rebalancing))->value_name(

mt-kahypar/io/sql_plottools_serializer.cpp

@@ -117,8 +117,7 @@ std::string serialize(const PartitionedHypergraph& hypergraph,
         << " lp_relative_improvement_threshold=" << context.refinement.label_propagation.relative_improvement_threshold
         << " lp_hyperedge_size_activation_threshold=" << context.refinement.label_propagation.hyperedge_size_activation_threshold
         << " sync_lp_num_sub_rounds_sync_lp=" << context.refinement.deterministic_refinement.num_sub_rounds_sync_lp
-        << " sync_lp_use_active_node_set=" << context.refinement.deterministic_refinement.use_active_node_set
-        << " sync_lp_recalculate_gains_on_second_apply=" << context.refinement.deterministic_refinement.recalculate_gains_on_second_apply;
+        << " sync_lp_use_active_node_set=" << context.refinement.deterministic_refinement.use_active_node_set;
     oss << " fm_algorithm=" << context.refinement.fm.algorithm
         << " fm_multitry_rounds=" << context.refinement.fm.multitry_rounds
         << " fm_perform_moves_global=" << std::boolalpha << context.refinement.fm.perform_moves_global

mt-kahypar/partition/coarsening/coarsening_commons.h

@@ -164,12 +164,12 @@ class UncoarseningData {
   }
 
   void performMultilevelContraction(
-          parallel::scalable_vector<HypernodeID>&& communities,
+          parallel::scalable_vector<HypernodeID>&& communities, bool deterministic,
           const HighResClockTimepoint& round_start) {
     ASSERT(!is_finalized);
     Hypergraph& current_hg = hierarchy.empty() ? _hg : hierarchy.back().contractedHypergraph();
     ASSERT(current_hg.initialNumNodes() == communities.size());
-    Hypergraph contracted_hg = current_hg.contract(communities);
+    Hypergraph contracted_hg = current_hg.contract(communities, deterministic);
     const HighResClockTimepoint round_end = std::chrono::high_resolution_clock::now();
     const double elapsed_time = std::chrono::duration<double>(round_end - round_start).count();
     hierarchy.emplace_back(std::move(contracted_hg), std::move(communities), elapsed_time);

mt-kahypar/partition/coarsening/deterministic_multilevel_coarsener.cpp

@@ -83,12 +83,14 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
         }
       }
     });
+
     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);
     }
+
     nodes_in_too_heavy_clusters.clear();
   }
 
@@ -97,7 +99,7 @@ bool DeterministicMultilevelCoarsener<TypeTraits>::coarseningPassImpl() {
   if (num_nodes_before_pass / num_nodes <= _context.coarsening.minimum_shrink_factor) {
     return false;
   }
-  _uncoarseningData.performMultilevelContraction(std::move(clusters), pass_start_time);
+  _uncoarseningData.performMultilevelContraction(std::move(clusters), true /* deterministic */, pass_start_time);
   return true;
 }
 

mt-kahypar/partition/coarsening/multilevel_coarsener.h

@@ -213,7 +213,7 @@ class MultilevelCoarsener : public ICoarsener,
 
     _timer.start_timer("contraction", "Contraction");
     // Perform parallel contraction
-    _uncoarseningData.performMultilevelContraction(std::move(cluster_ids), round_start);
+    _uncoarseningData.performMultilevelContraction(std::move(cluster_ids), false /* deterministic */, round_start);
     _timer.stop_timer("contraction");
 
     ++_pass_nr;

mt-kahypar/partition/context.cpp

@@ -183,8 +183,6 @@ namespace mt_kahypar {
   std::ostream& operator<<(std::ostream& out, const DeterministicRefinementParameters& params) {
     out << "    Number of sub-rounds for Sync LP:  " << params.num_sub_rounds_sync_lp << std::endl;
     out << "    Use active node set:               " << std::boolalpha << params.use_active_node_set << std::endl;
-    out << "    recalculate gains on second apply: " << std::boolalpha
-        << params.recalculate_gains_on_second_apply << std::endl;
     return out;
   }
 
@@ -352,6 +350,8 @@ namespace mt_kahypar {
                   partition.max_part_weights.size());
     }
 
+    shared_memory.static_balancing_work_packages = std::clamp(shared_memory.static_balancing_work_packages, size_t(4), size_t(256));
+
     if ( partition.objective == Objective::steiner_tree ) {
       if ( !target_graph ) {
         partition.objective = Objective::km1;

mt-kahypar/partition/context.h

@@ -206,7 +206,6 @@ std::ostream& operator<<(std::ostream& out, const FlowParameters& params);
 struct DeterministicRefinementParameters {
   size_t num_sub_rounds_sync_lp = 5;
   bool use_active_node_set = false;
-  bool recalculate_gains_on_second_apply = false;
 };
 
 std::ostream& operator<<(std::ostream& out, const DeterministicRefinementParameters& params);

mt-kahypar/partition/factories.h

@@ -93,7 +93,7 @@ using LabelPropagationDispatcher = kahypar::meta::StaticMultiDispatchFactory<
 using DeterministicLabelPropagationDispatcher = kahypar::meta::StaticMultiDispatchFactory<
                                                   DeterministicLabelPropagationRefiner,
                                                   IRefiner,
-                                                  kahypar::meta::Typelist<TypeTraitsList>>;
+                                                  kahypar::meta::Typelist<TypeTraitsList, GainTypes>>;
 
 using FMFactory = kahypar::meta::Factory<FMAlgorithm,
                     IRefiner* (*)(HypernodeID, HyperedgeID, const Context&, gain_cache_t, IRebalancer&)>;