refactor: update randomIndividualSafe and randomIndividualPartitionCopySafe methods to accept deterministic flag instead of full context

Author: schrapsi

mt-kahypar/partition/evo_partitioner.cpp

@@ -489,7 +489,7 @@ namespace mt_kahypar {
         std::mt19937* rng) {
     Hypergraph hypergraph = input_hg.copy(parallel_tag_t{});
 
-    const std::vector rnd_ind_partition(population.randomIndividualPartitionCopySafe(context, rng));
+    const std::vector rnd_ind_partition(population.randomIndividualPartitionCopySafe(context.partition.deterministic, rng));
     switch (pick::decideNextMutation(context, rng)) {
         case EvoMutateStrategy::new_initial_partitioning_vcycle:
             return mutate::vCycleWithNewInitialPartitioning<TypeTraits>(hypergraph, rnd_ind_partition, target_graph,

mt-kahypar/partition/evolutionary/combine.h

@@ -117,10 +117,10 @@ static constexpr bool debug = false;
   Individual usingKWaySelection(const typename TypeTraits::Hypergraph& input_hg, TargetGraph* target_graph, Population& population, Context context, std::mt19937* rng) {
     std::vector<size_t> parents;
     //Maybe change to actually use Tournament Selection
-    size_t best(population.randomIndividualSafe(context, rng));
+    size_t best(population.randomIndividualSafe(context.partition.deterministic, rng));
     parents.push_back(best);
     for (int x = 1; x < context.evolutionary.kway_combine; x++) {
-      size_t new_parent = population.randomIndividualSafe(context, rng);
+      size_t new_parent = population.randomIndividualSafe(context.partition.deterministic, rng);
       parents.push_back(new_parent);
       if (population.fitnessAtSafe(new_parent) <= population.fitnessAtSafe(best)) {
         best = new_parent;
@@ -166,7 +166,7 @@ static constexpr bool debug = false;
   template <typename TypeTraits>
   Individual usingArtificialSecondParent(const typename TypeTraits::Hypergraph& input_hg, Population& population, TargetGraph* target_graph, ContextModifierParameters params,const Context context, std::mt19937* rng) {
      std::vector<std::vector<PartitionID>> parent_partitions;
-        size_t best(population.randomIndividualSafe(context, rng));
+        size_t best(population.randomIndividualSafe(context.partition.deterministic, rng));
 
         // generate new parent individual with modified context
         Context modified_context = modifyContext(context, params);

mt-kahypar/partition/evolutionary/population.h

@@ -173,9 +173,9 @@ class Population {
   }
 
   // Thread-safe accessors
-  inline size_t randomIndividualSafe(Context context, std::mt19937* rng = nullptr) {
+  inline size_t randomIndividualSafe(const bool deterministic, std::mt19937* rng = nullptr) {
     std::lock_guard<std::mutex> guard(_population_mutex);
-    if (context.partition.deterministic) {
+    if (deterministic) {
       ASSERT(rng != nullptr, "Deterministic mode requires a valid RNG");
       std::uniform_int_distribution<size_t> dist(0, _individuals.size() - 1);
       return dist(*rng);
@@ -202,10 +202,10 @@ class Population {
     return _individuals[best_position].partition(); // returns copy
   }
 
-  inline std::vector<PartitionID> randomIndividualPartitionCopySafe(const Context& context, std::mt19937* rng = nullptr) {
+  inline std::vector<PartitionID> randomIndividualPartitionCopySafe(const bool deterministic, std::mt19937* rng = nullptr) {
     std::lock_guard<std::mutex> guard(_population_mutex);
     size_t random_position;
-    if (context.partition.deterministic) {
+    if (deterministic) {
       ASSERT(rng != nullptr, "Deterministic mode requires a valid RNG");
       std::uniform_int_distribution<size_t> dist(0, _individuals.size() - 1);
       random_position = dist(*rng);

tests/partition/evolutionary/population_test.cc

@@ -334,19 +334,19 @@ TYPED_TEST(APopulation, ConcurrentSafeAccessorsKeepIndicesAndFitnessValid) {
 
     executeConcurrent([&] {
         for (size_t i = 0; i < 200; ++i) {
-            const size_t idx = pop.randomIndividualSafe(this->context);
+            const size_t idx = pop.randomIndividualSafe(this->context.partition.deterministic);
             EXPECT_LT(idx, pop.size());
             EXPECT_EQ(pop.bestFitnessSafe(), expected_best_fitness);
             EXPECT_LT(pop.bestSafe(), pop.size());
         }
     }, [&] {
         for (size_t i = 0; i < 200; ++i) {
-            const size_t idx = pop.randomIndividualSafe(this->context);
+            const size_t idx = pop.randomIndividualSafe(this->context.partition.deterministic);
             EXPECT_LT(idx, pop.size());
             EXPECT_EQ(pop.fitnessAtSafe(pop.bestSafe()), expected_best_fitness);
             EXPECT_EQ(pop.bestPartitionCopySafe().size(), 7);
             EXPECT_EQ(pop.partitionCopySafe(idx).size(), 7);
-            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(this->context).size(), 7);
+            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(this->context.partition.deterministic).size(), 7);
         }
     });
 }
@@ -395,20 +395,20 @@ TYPED_TEST(APopulation, DeterministicSafeRandomMethodsAreStableAcrossThreads) {
     std::vector<std::vector<PartitionID>> expected_partitions;
     expected_partitions.reserve(100);
     for (size_t i = 0; i < 100; ++i) {
-        expected_idxs.push_back(pop.randomIndividualSafe(ctx, &rng));
-        expected_partitions.push_back(pop.randomIndividualPartitionCopySafe(ctx, &rng));
+        expected_idxs.push_back(pop.randomIndividualSafe(ctx.partition.deterministic, &rng));
+        expected_partitions.push_back(pop.randomIndividualPartitionCopySafe(ctx.partition.deterministic, &rng));
     }
     executeConcurrent([&] {
         std::mt19937 thread_rng(ctx.partition.seed);
         for (size_t i = 0; i < 100; ++i) {
-            EXPECT_EQ(pop.randomIndividualSafe(ctx, &thread_rng), expected_idxs[i]);
-            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(ctx, &thread_rng), expected_partitions[i]);
+            EXPECT_EQ(pop.randomIndividualSafe(ctx.partition.deterministic, &thread_rng), expected_idxs[i]);
+            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(ctx.partition.deterministic, &thread_rng), expected_partitions[i]);
         }
     }, [&] {
         std::mt19937 thread_rng(ctx.partition.seed);
         for (size_t i = 0; i < 100; ++i) {
-            EXPECT_EQ(pop.randomIndividualSafe(ctx, &thread_rng), expected_idxs[i]);
-            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(ctx, &thread_rng), expected_partitions[i]);
+            EXPECT_EQ(pop.randomIndividualSafe(ctx.partition.deterministic, &thread_rng), expected_idxs[i]);
+            EXPECT_EQ(pop.randomIndividualPartitionCopySafe(ctx.partition.deterministic, &thread_rng), expected_partitions[i]);
         }
     });
 }
@@ -444,7 +444,7 @@ TYPED_TEST(APopulation, ConcurrentInsertsAndSafeReadsRemainConsistent) {
         }
     }, [&] {
         for (size_t i = 0; i < 300; ++i) {
-            const size_t idx = this->population.randomIndividualSafe(this->context);
+            const size_t idx = this->population.randomIndividualSafe(this->context.partition.deterministic);
             EXPECT_LT(idx, this->population.size());
             EXPECT_LT(this->population.bestSafe(), this->population.size());