Add ability to print out found colourings

Author: RudyBricks

include/colouring/graph_colouring.h

@@ -269,15 +269,17 @@ namespace graph_colouring {
          * @param k the (maximum) number of colors
          * @param populationSize the number of maintained colourings
          * @param maxItr the maximum number of iterations
-         * @param threadCount the number of used threads
+         * @param threadCount the number of used worker threads
+         * @param outputStream if not null, it will be used to report recently found colourings
          * @return the best colourings for each passed colouring category
          */
         std::vector<ColouringResult> perform(const std::vector<std::shared_ptr<ColouringStrategy>> &strategies,
                                              const graph_access &G,
                                              ColorCount k,
                                              size_t populationSize,
                                              size_t maxItr,
-                                             size_t threadCount = std::thread::hardware_concurrency());
+                                             size_t threadCount = std::thread::hardware_concurrency(),
+                                             std::ostream *outputStream = nullptr);
     };
 
 

include/colouring/hca.h

@@ -18,6 +18,7 @@ namespace graph_colouring {
      * for k-i coloring could be obtained in the previous runs
      * @param logStream if specified, the algorithm will print out the results of each
      * iteration into the output stream
+     * @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,
@@ -27,6 +28,7 @@ namespace graph_colouring {
                                        size_t L,
                                        size_t A,
                                        double alpha,
-                                       size_t threadCount = std::thread::hardware_concurrency());
+                                       size_t threadCount = std::thread::hardware_concurrency(),
+                                       std::ostream *outputStream = nullptr);
 
 }

src/colouring/graph_colouring.cpp

@@ -30,6 +30,9 @@ namespace graph_colouring {
     struct MasterPackage {
         /**< The next k to be searched */
         ColorCount next_k;
+        /**< The strategy which reported this found k */
+        size_t reportingStrategy;
+        /**< The actual colouring */
     };
 
     /**
@@ -198,7 +201,7 @@ 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});
+                    masterQueue.push({last_reported_k, wp.strategyId});
                 }
             }
             std::this_thread::yield();
@@ -211,7 +214,8 @@ namespace graph_colouring {
                                 const ColorCount k,
                                 const size_t populationSize,
                                 const size_t maxItr,
-                                const size_t threadCount) {
+                                const size_t threadCount,
+                                std::ostream *outputStream) {
 
         assert(!strategies.empty());
         assert(populationSize > 0);
@@ -220,6 +224,7 @@ namespace graph_colouring {
 
         if (4 * threadCount > strategies.size() * populationSize) {
             std::cerr << "WARNING: Make sure that populationSize is bigger than 4*categoryCount*threadCount\n";
+            assert(0);
         }
 
         std::vector<Colouring> P(strategies.size() * populationSize);
@@ -264,9 +269,14 @@ namespace graph_colouring {
             }
         }
 
-        MasterPackage mp = {0};
+        MasterPackage mp = {0, 0};
         while (!hasFinished(context)) {
             while (masterQueue.pop(mp)) {
+                if (outputStream != nullptr) {
+                    auto &ss = *outputStream;
+                    ss << "Found colouring k = " << mp.next_k
+                       << " from colouring strategy " << mp.reportingStrategy << "\n";
+                }
                 if (target_k >= mp.next_k) {
                     target_k = mp.next_k - 1;
                     for (size_t strategyId = 0; strategyId < strategies.size(); strategyId++) {

src/colouring/hca.cpp

@@ -14,7 +14,9 @@ namespace graph_colouring {
             const size_t L,
             const size_t A,
             const double alpha,
-            const size_t threadCount) {
+            const size_t threadCount,
+            std::ostream *outputStream) {
+
         std::vector<InitOperator> hcaInitOps = {[](const graph_access &graph,
                                                    const ColorCount colors) {
             return graph_colouring::initByGreedySaturation(graph, colors);
@@ -39,6 +41,7 @@ namespace graph_colouring {
                                             k,
                                             population_size,
                                             maxItr,
-                                            threadCount)[0].s;
+                                            threadCount,
+                                            outputStream)[0].s;
     }
 }