Minor threadpool cleanup

src/openvic-simulation/utility/ThreadPool.cpp

@@ -1,5 +1,10 @@
 #include "ThreadPool.hpp"
 
+#include <array>
+#include <cstddef>
+#include <span>
+#include <thread>
+
 #include "openvic-simulation/country/CountryInstance.hpp"
 #include "openvic-simulation/economy/GoodDefinition.hpp" // IWYU pragma: keep for constructor requirement
 #include "openvic-simulation/economy/GoodInstance.hpp"
@@ -28,7 +33,7 @@ void ThreadPool::loop_until_cancelled(
 	memory::FixedVector<fixed_point_t, country_index_t> reusable_country_map_0 { country_index_t(country_keys.size()), fixed_point_t::_0 };
 	memory::FixedVector<fixed_point_t, country_index_t> reusable_country_map_1 { country_index_t(country_keys.size()), fixed_point_t::_0 };
 
-	static constexpr size_t VECTOR_COUNT = std::max(
+	static constexpr std::size_t VECTOR_COUNT = std::max(
 		GoodMarket::VECTORS_FOR_EXECUTE_ORDERS,
 		std::max(
 			CountryInstance::VECTORS_FOR_COUNTRY_TICK,
@@ -204,14 +209,14 @@ void ThreadPool::initialise_threadpool(
 	auto countries_begin = countries.begin();
 	auto provinces_begin = provinces.begin();
 
-	for (size_t i = 0; i < WORK_BUNDLE_COUNT; i++) {
-		const size_t goods_chunk_size = i < goods_remainder
+	for (std::size_t i = 0; i < WORK_BUNDLE_COUNT; i++) {
+		const std::size_t goods_chunk_size = i < goods_remainder
 			? goods_quotient + 1
 			: goods_quotient;
-		const size_t countries_chunk_size = i < countries_remainder
+		const std::size_t countries_chunk_size = i < countries_remainder
 			? countries_quotient + 1
 			: countries_quotient;
-		const size_t provinces_chunk_size = i < provinces_remainder
+		const std::size_t provinces_chunk_size = i < provinces_remainder
 			? provinces_quotient + 1
 			: provinces_quotient;
 
@@ -234,16 +239,19 @@ void ThreadPool::initialise_threadpool(
 		provinces_begin = provinces_end;
 	}
 
-	const size_t max_worker_threads = std::max<size_t>(std::thread::hardware_concurrency(), 1);
+	const std::size_t max_worker_threads = std::min(
+		std::max<std::size_t>(std::thread::hardware_concurrency(), 1),
+		WORK_BUNDLE_COUNT
+	);
 	threads.reserve(max_worker_threads);
 	work_per_thread.resize(max_worker_threads, work_t::NONE);
 
 
 	const auto [work_bundles_quotient, work_bundles_remainder] = std::ldiv(WORK_BUNDLE_COUNT, max_worker_threads);
 	auto work_bundles_begin = all_work_bundles.begin();
 
-	for (size_t i = 0; i < max_worker_threads; ++i) {
-		const size_t work_bundles_chunk_size = i < work_bundles_remainder
+	for (std::size_t i = 0; i < max_worker_threads; ++i) {
+		const std::size_t work_bundles_chunk_size = i < work_bundles_remainder
 			? work_bundles_quotient + 1
 			: work_bundles_quotient;
 

src/openvic-simulation/utility/ThreadPool.hpp

@@ -1,12 +1,13 @@
 #pragma once
 
+#include <array>
 #include <condition_variable>
+#include <cstddef>
 #include <cstdint>
 #include <mutex>
 #include <thread>
 
 #include "openvic-simulation/population/PopValuesFromProvince.hpp"
-#include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/core/random/RandomGenerator.hpp"
@@ -58,17 +59,15 @@ namespace OpenVic {
 			COUNTRY_TICK_AFTER_MAP
 		};
 
-		constexpr static size_t WORK_BUNDLE_COUNT = 32;
+		constexpr static std::size_t WORK_BUNDLE_COUNT = 32;
 		std::array<WorkBundle, WORK_BUNDLE_COUNT> all_work_bundles;
 		memory::vector<std::thread> threads;
 		memory::vector<work_t> work_per_thread;
 		std::mutex thread_mutex, completed_mutex;
 		std::condition_variable thread_condition, completed_condition;
-		std::atomic<size_t> active_work_count = 0;
+		std::atomic<std::size_t> active_work_count = 0;
 		bool is_cancellation_requested = false;
 		Date const& current_date;
-		bool is_good_execute_orders_requested = false;
-		bool is_province_tick_requested = false;
 
 		void loop_until_cancelled(
 			work_t& work_type,