Visual Studio Code – Varying results using multiple threads

The first program never uses the threadpool. Except to join.

If you fix at least the first, the performance matches between the two:

I’ve also removed cruft that didn’t get used or was unrelated to the question. Also reworded the chrono hell to be more elegant. Notably shifted the random generator to each task because they are NOT threadsafe! Finally renamed "threads" to "tasks" in the std::async version because std::async guarantees little about thread scheduling in the standard.

Live On Coliru

• File test.h

   #pragma once
   #include <atomic>
  
   namespace Test {
       static void boost_worker_task();
       static void run(unsigned, bool);
  
       static inline std::atomic_uint games_solved_counter{0};
   }; // namespace Test
  
   namespace TestMulThread {
       static void worker_task(unsigned);
       static void run(unsigned);
  
       static inline std::atomic_uint games_solved{0};
   }; // namespace TestMulThread
  
   struct MyEngine {
       using State = char[3][3];
       static void init_rand();
       static void random_start_state(State&);
       static void solve_game(State&);
   };
  

• File test.cpp

   #include "test.h"
   #include <boost/asio.hpp>
   #include <iostream>
   #include <random>
   #include <thread>
   using namespace std::chrono_literals;
   static constexpr auto now = std::chrono::high_resolution_clock::now;
  
   void MyEngine::init_rand() {}
   void MyEngine::random_start_state(State&) {}
   void MyEngine::solve_game(State&) {
       thread_local static std::mt19937                  prng{std::random_device{}()};
       thread_local static std::uniform_int_distribution work(3, 8);
       std::this_thread::sleep_for(1ms * work(prng));
   };
  
   void TestMulThread::worker_task(unsigned num_iterations) {
       MyEngine::init_rand();
       for (unsigned int i = 0; i < num_iterations; ++i) {
           char new_state[3][3];
           MyEngine::random_start_state(new_state);
           MyEngine::solve_game(new_state);
  
           ++games_solved;
       }
   }
  
   void TestMulThread::run(unsigned total_games_to_solve) {
       auto     start_time      = now();
       unsigned num_tasks       = std::thread::hardware_concurrency();
       unsigned games_per_task  = total_games_to_solve / num_tasks;
       unsigned remaining_games = total_games_to_solve % games_per_task;
       std::cout << "Using " << num_tasks << " tasks to solve " << total_games_to_solve << " games" << std::endl;
  
       // Distribute the remaining games
       std::vector buckets(num_tasks, games_per_task);
       for (unsigned int i = 0; i < remaining_games; ++i) {
           buckets[i]++;
       }
  
       std::vector<std::future<void>> futures;
  
       for (unsigned i = 0; i < num_tasks; ++i)
           futures.push_back(std::async(std::launch::async, worker_task, buckets[i]));
  
       for (auto& future : futures)
           future.get();
  
       auto elapsed = now() - start_time;
       std::cout << "Solved " << games_solved << " games!" << std::endl;
       std::cout << "Elapsed time: " << elapsed / 1.s << " seconds" << std::endl;
       std::cout << "Elapsed time: " << elapsed / 1ms << " millisecondsn" << std::endl;
   }
  
   void Test::boost_worker_task() {
       char new_state[3][3];
       MyEngine::random_start_state(new_state);
       MyEngine::solve_game(new_state);
       ++games_solved_counter;
   }
  
   void Test::run(unsigned games_to_solve, bool threaded) {
       auto const start = now();
  
       unsigned num_threads = threaded ? std::thread::hardware_concurrency() : 1;
       std::cout << "Using " << num_threads << " threads to solve " << games_to_solve << " games" << std::endl;
  
       boost::asio::thread_pool pool(num_threads);
  
       for (unsigned i = 0; i < games_to_solve; ++i)
           post(pool, Test::boost_worker_task);
  
       // Run and wait for all tasks to complete
       pool.join();
  
       auto elapsed = now() - start;
  
       std::cout << "Solved " << games_solved_counter << " games!" << std::endl;
       std::cout << "Elapsed time: " << elapsed / 1.s << " seconds" << std::endl;
       std::cout << "Elapsed time: " << elapsed / 1ms << " millisecondsn" << std::endl;
   }
  
   int main() { //
       auto N = 10'000u;
       Test::run(N, true);
       TestMulThread::run(N);
   }
  

Prints, online:

Using 4 threads to solve 10000 games
Solved 10000 games!
Elapsed time: 14.0106 seconds
Elapsed time: 14010 milliseconds

Using 4 tasks to solve 10000 games
Solved 10000 games!
Elapsed time: 14.2782 seconds
Elapsed time: 14278 milliseconds

And locally for me:

Using 8 threads to solve 10000 games
Solved 10000 games!
Elapsed time: 6.96683 seconds
Elapsed time: 6966 milliseconds

Using 8 threads to solve 10000 games
Solved 10000 games!
Elapsed time: 7.04044 seconds
Elapsed time: 7040 milliseconds