Report always the last successful colouring (if found any)

Author: RudyBricks

framework/colouring/graph_colouring.cpp

@@ -126,6 +126,7 @@ namespace graph_colouring {
                              boost::lockfree::queue<WorkingPackage> &workQueue,
                              boost::lockfree::queue<MasterPackage> &masterQueue,
                              std::vector<Colouring> &population,
+                             std::vector<Colouring> &localBestColourings,
                              std::vector<std::atomic<bool>> &lock,
                              std::atomic<ColorCount> &target_k,
                              std::atomic<bool> &terminated) {
@@ -202,6 +203,8 @@ namespace graph_colouring {
                 if (strategy.isSolution(G, target_k, result) && last_reported_k > target_k) {
                     last_reported_k = colorCount(result);
                     masterQueue.push({last_reported_k, wp.strategyId});
+                    size_t threadCount = localBestColourings.size() / strategies.size();
+                    localBestColourings[wp.strategyId * threadCount + threadId] = result;
                 }
             }
             std::this_thread::yield();
@@ -227,6 +230,7 @@ namespace graph_colouring {
         }
 
         std::vector<Colouring> population(strategies.size() * populationSize);
+        std::vector<Colouring> localBestColourings(strategies.size() * threadCount);
         //lock[i] = true -> i-th individual is free for mating
         std::vector<std::atomic<bool>> lock(strategies.size() * populationSize);
         std::vector<ColouringStrategyContext> context(strategies.size());
@@ -254,6 +258,7 @@ namespace graph_colouring {
                                     std::ref(workQueue),
                                     std::ref(masterQueue),
                                     std::ref(population),
+                                    std::ref(localBestColourings),
                                     std::ref(lock),
                                     std::ref(target_k),
                                     std::ref(terminated));
@@ -306,14 +311,34 @@ namespace graph_colouring {
 
         std::vector<ColouringResult> bestResults(strategies.size());
         for (size_t strategyId = 0; strategyId < strategies.size(); strategyId++) {
-            auto best = strategyId;
-            for (int i = 0; i < populationSize; i++) {
-                auto nextTry = strategyId * populationSize + i;
-                if (strategies[strategyId]->compare(G, population[best], population[nextTry])) {
-                    best = nextTry;
+            Colouring *bestColouring = nullptr;
+            for (size_t i = 0; i < threadCount; i++) {
+                auto &localBestColouring = localBestColourings[strategyId * threadCount + i];
+                if (localBestColouring.empty()) {
+                    continue;
+                }
+                if (bestColouring == nullptr) {
+                    bestColouring = &localBestColouring;
+                    continue;
+                }
+                bestColouring = colorCount(*bestColouring) > colorCount(localBestColouring)
+                                ? &localBestColouring : bestColouring;
+            }
+
+            bool foundBestColourings = bestColouring != nullptr;
+
+            if (!foundBestColourings) {
+                for (size_t i = 0; i < populationSize; i++) {
+                    auto nextTry = strategyId * populationSize + i;
+                    if (bestColouring == nullptr) {
+                        bestColouring = &population[nextTry];
+                        continue;
+                    }
+                    bestColouring = strategies[strategyId]->compare(G, *bestColouring, population[nextTry])
+                                    ? &population[nextTry] : bestColouring;
                 }
             }
-            bestResults[strategyId] = {population[best], nullptr};
+            bestResults[strategyId] = {*bestColouring, foundBestColourings};
         }
         return bestResults;
     }

framework/colouring/graph_colouring.h

@@ -170,11 +170,15 @@ namespace graph_colouring {
         virtual bool isFixedKStrategy() const = 0;
 
         /**
-         * Used to compare the scoring of two coloring.
+         * Used to compare the scorings of two colorings within a strategy-specific population.
+         * It is guaranteed that the compared instances resulted from the same initialization phase,
+         * which may be important in fixed-k strategies.
+         * The executing parallel colouring algorithm will always prefer the colourings with the smallest
+         * amount of used colours for the final reporting.
          * @param G the target graph
          * @param a the first coloring
          * @param b the second coloring
-         * @return True if coloring \p has a lesser score compared to coloring \p b
+         * @return True if coloring \p a has a lesser score compared to coloring \p b
          */
         virtual bool compare(const graph_access &G,
                              const Colouring &a,
@@ -223,13 +227,13 @@ namespace graph_colouring {
     };
 
     /**
-     * @brief Represents a single result from coloringAlgorithm()
+     * @brief Represents the best colouring for each strategy
      */
     struct ColouringResult {
         /**< The best configuration */
         Colouring s;
-        /**< The algorithm category used to retrieve the corresponding category */
-        std::unique_ptr<ColouringStrategy> strategy;
+        /**< True if no correct colouring could be found for the particular configuration */
+        bool isValid;
     };
 
     class ColouringAlgorithm {

framework/colouring/hca.cpp

@@ -6,7 +6,7 @@
 
 namespace graph_colouring {
 
-    Colouring hybridColouringAlgorithm(
+    ColouringResult hybridColouringAlgorithm(
             const graph_access &G,
             const ColorCount k,
             const size_t population_size,
@@ -20,17 +20,17 @@ namespace graph_colouring {
         std::vector<std::unique_ptr<ColouringStrategy>> strategies;
         strategies.emplace_back(new FixedKColouringStrategy());
         strategies[0]->initOperators.emplace_back([](const graph_access &graph,
-                                                       const ColorCount colors) {
+                                                     const ColorCount colors) {
             return graph_colouring::initByGreedySaturation(graph, colors);
 
         });
         strategies[0]->crossoverOperators.emplace_back([](const Colouring &s1,
-                                                            const Colouring &s2,
-                                                            const graph_access &graph) {
+                                                          const Colouring &s2,
+                                                          const graph_access &graph) {
             return graph_colouring::gpxCrossover(s1, s2);
         });
         strategies[0]->lsOperators.emplace_back([L, A, alpha](const Colouring &s,
-                                                                const graph_access &graph) {
+                                                              const graph_access &graph) {
             return graph_colouring::tabuSearchOperator(s, graph, L, A, alpha);
         });
 
@@ -40,6 +40,6 @@ namespace graph_colouring {
                                             population_size,
                                             maxItr,
                                             threadCount,
-                                            outputStream)[0].s;
+                                            outputStream)[0];
     }
 }

framework/colouring/hca.h

@@ -21,14 +21,14 @@ namespace graph_colouring {
      * @param outputStream if not null, it will be used to report recently found colourings
      * @return the best found colouring
      */
-    Colouring hybridColouringAlgorithm(const graph_access &G,
-                                       ColorCount k,
-                                       size_t populationSize,
-                                       size_t maxItr,
-                                       size_t L,
-                                       size_t A,
-                                       double alpha,
-                                       size_t threadCount = std::thread::hardware_concurrency(),
-                                       std::ostream *outputStream = nullptr);
+    ColouringResult hybridColouringAlgorithm(const graph_access &G,
+                                             ColorCount k,
+                                             size_t populationSize,
+                                             size_t maxItr,
+                                             size_t L,
+                                             size_t A,
+                                             double alpha,
+                                             size_t threadCount = std::thread::hardware_concurrency(),
+                                             std::ostream *outputStream = nullptr);
 
 }

micro_benchs/colouring/hca_mb.cpp

@@ -22,21 +22,24 @@ void BM_hca(benchmark::State &state,
         auto A = size_t(state.range(6));
         const double alpha = double(state.range(7)) / 10;
         auto result = hybridColouringAlgorithm(G, k, population_size, maxItr, L, A, alpha, threadCount);
-        auto result_k = graph_colouring::colorCount(result);
+        auto result_k = graph_colouring::colorCount(result.s);
         if (result_k > min_k) {
             std::cerr << "Should return a colouring with k = "
                       << min_k << " (is actually " << result_k << ")\n";
         }
+        if (!result.isValid) {
+            std::cerr << "Should return a valid colouring\n";
+        }
     }
 }
 
 BENCHMARK_CAPTURE(BM_hca, miles250,
                   "../../input/miles250-sorted.graph")
         ->Unit(benchmark::kMillisecond)
-        ->Args({1, 7, 9, 100,  20, 5, 2, 6})
-        ->Args({2, 7, 9, 100,  20, 5, 2, 6})
-        ->Args({1, 7, 9, 1000, 20, 5, 2, 6})
-        ->Args({2, 7, 9, 1000, 20, 5, 2, 6});
+        ->Args({1, 8, 9, 100,  20, 5, 2, 6})
+        ->Args({2, 8, 9, 100,  20, 5, 2, 6})
+        ->Args({1, 8, 9, 1000, 20, 5, 2, 6})
+        ->Args({2, 8, 9, 1000, 20, 5, 2, 6});
 
 /*
 BENCHMARK_CAPTURE(BM_hca, DSJC250_5,

tests/framework/colouring/hca_test.cpp

@@ -24,7 +24,26 @@ TEST(HybridColouringAlgorithm, miles250_Graph_k7) {
     const size_t k = 7;
     const size_t population_size = 20;
     const size_t maxItr = 20;
-    auto s_best = graph_colouring::hybridColouringAlgorithm(G, k, population_size, maxItr, L, A, alpha);
-    EXPECT_EQ(graph_colouring::colorCount(s_best), 7);
-    EXPECT_TRUE(graph_colouring::numberOfConflictingEdges(G, s_best) <= 4);
+    auto best = hybridColouringAlgorithm(G, k, population_size, maxItr, L, A, alpha);
+    EXPECT_EQ(colorCount(best.s), 7);
+    EXPECT_FALSE(best.isValid);
+    EXPECT_TRUE(numberOfConflictingEdges(G, best.s) <= 4);
+}
+
+
+TEST(HybridColouringAlgorithm, miles250_Graph_k8) {
+    graph_access G;
+    std::string graph_filename = "../../input/miles250-sorted.graph";
+    graph_io::readGraphWeighted(G, graph_filename);
+
+    const size_t L = 5;
+    const size_t A = 2;
+    const double alpha = 0.6;
+    const size_t k = 8;
+    const size_t population_size = 20;
+    const size_t maxItr = 20;
+    auto best = hybridColouringAlgorithm(G, k, population_size, maxItr, L, A, alpha);
+    EXPECT_EQ(colorCount(best.s), 8);
+    EXPECT_TRUE(best.isValid);
+    EXPECT_EQ(numberOfConflictingEdges(G, best.s), 0);
 }