Fix empty reusable maps in ThreadPool

Author: wvpm

src/openvic-simulation/types/FixedVector.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <memory>
 #include <utility>
 
 #include "openvic-simulation/core/template/Concepts.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
 
 namespace OpenVic::_detail {
 	//fixed capacity + not movable + not copyable
@@ -19,6 +21,12 @@ namespace OpenVic::_detail {
 		OV_NO_UNIQUE_ADDRESS Allocator _allocator;
 		T* const _data_start_ptr;
 
+		explicit FixedVector(const size_t capacity)
+			: _max_size(capacity),
+			_size(0),
+			_allocator(),
+			_data_start_ptr(allocator_traits::allocate(_allocator, capacity)) {}
+
 	public:
 		using const_reference = T const&;
 		using difference_type = ptrdiff_t;
@@ -33,19 +41,23 @@ namespace OpenVic::_detail {
 		constexpr T const* data() const { return _data_start_ptr; }
 		constexpr bool empty() const { return _size == 0; }
 
-		explicit FixedVector(const size_t capacity)
-			: _max_size(capacity),
-			_size(0),
+		FixedVector static create_empty(const size_t capacity) { return FixedVector(capacity); }
+
+		FixedVector(const size_t size, T const& value_for_all_indices)
+			: _max_size(size),
+			_size(size),
 			_allocator(),
-			_data_start_ptr(allocator_traits::allocate(_allocator, capacity)) {}
+			_data_start_ptr(allocator_traits::allocate(_allocator, size)) {
+			std::fill(_data_start_ptr, _data_start_ptr + size, value_for_all_indices);
+		}
 
 		//Generator (size_t i) -> U (where T is constructable from U)
 		template<typename GeneratorTemplateType>
 		// The generator must NOT return a tuple
 		requires (!specialization_of<std::remove_cvref_t<std::invoke_result_t<GeneratorTemplateType, size_t>>, std::tuple>)
 		// The type must be constructible from the generator's single return value
 		&& std::constructible_from<T, decltype(std::declval<GeneratorTemplateType>()(std::declval<size_t>()))>
-		FixedVector(size_t size, GeneratorTemplateType&& generator)
+		FixedVector(const size_t size, GeneratorTemplateType&& generator)
 			: _max_size(size),
 			_size(size),
 			_allocator(),
@@ -74,7 +86,7 @@ namespace OpenVic::_detail {
 				)
 			};
 		}
-		FixedVector(size_t size, GeneratorTemplateType&& generator)
+		FixedVector(const size_t size, GeneratorTemplateType&& generator)
 			: _max_size(size),
 			_size(size),
 			_allocator(),
@@ -125,12 +137,22 @@ namespace OpenVic::_detail {
 		const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 		const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
 
-		T& operator[](size_t index) {
-			assert(index < _size && "Index out of bounds.");
+		T& operator[](const size_t index) {
+			if (OV_unlikely(_size <= index)) {
+				spdlog::error_s(
+					"Out of bound non-const indexing on FixedVector. index {} _size {}",
+					index, _size
+				);
+			}
 			return _data_start_ptr[index];
 		}
-		const T& operator[](size_t index) const {
-			assert(index < _size && "Index out of bounds.");
+		const T& operator[](const size_t index) const {
+			if (OV_unlikely(_size <= index)) {
+				spdlog::error_s(
+					"Out of bound const indexing on FixedVector. index {} _size {}",
+					index, _size
+				);
+			}
 			return _data_start_ptr[index];
 		}
 

src/openvic-simulation/types/IndexedFlatMap.hpp

@@ -269,7 +269,7 @@ namespace OpenVic {
 		) : keys(new_keys),
 			min_index { new_keys.front().index },
 			max_index { new_keys.back().index },
-			values(new_keys.size()) {
+			values(memory::FixedVector<ValueType>::create_empty(new_keys.size())) {
 			static_assert(has_index<ForwardedKeyType>);
 			if (!validate_new_keys(new_keys)) {
 				return;
@@ -363,7 +363,7 @@ namespace OpenVic {
 		) : keys(new_keys),
 			min_index { type_safe::get(new_keys.front().index) },
 			max_index { type_safe::get(new_keys.back().index) },
-			values(new_keys.size()) {
+			values(memory::FixedVector<ValueType>::create_empty(new_keys.size())) {
 			static_assert(has_index<ForwardedKeyType>);
 			if (!validate_new_keys(new_keys)) {
 				return;
@@ -428,7 +428,7 @@ namespace OpenVic {
 			: keys(new_keys),
 			min_index { type_safe::get(new_keys.front().index) },
 			max_index { type_safe::get(new_keys.back().index) },
-			values(new_keys.size()) {
+			values(memory::FixedVector<ValueType>::create_empty(new_keys.size())) {
 			static_assert(has_index<ForwardedKeyType>);
 			if (!validate_new_keys(new_keys)) {
 				return;

src/openvic-simulation/utility/ThreadPool.cpp

@@ -26,8 +26,8 @@ void ThreadPool::loop_until_cancelled(
 ) {
 	IndexedFlatMap<GoodDefinition, char> reusable_goods_mask { good_keys };
 
-	memory::FixedVector<fixed_point_t> reusable_country_map_0 { country_keys.size() };
-	memory::FixedVector<fixed_point_t> reusable_country_map_1 { country_keys.size() };
+	memory::FixedVector<fixed_point_t> reusable_country_map_0 { country_keys.size(), fixed_point_t::_0 };
+	memory::FixedVector<fixed_point_t> reusable_country_map_1 { country_keys.size(), fixed_point_t::_0 };
 	TypedSpan<country_index_t, fixed_point_t> reusable_country_map_0_span { reusable_country_map_0 };
 	TypedSpan<country_index_t, fixed_point_t> reusable_country_map_1_span { reusable_country_map_1 };
 

tests/src/types/FixedVector.cpp

@@ -67,7 +67,7 @@ int DestructionCounter::destructor_count = 0;
 // A simple test case to check the basic constructor and accessors with a simple type.
 TEST_CASE("FixedVector Construction and basic accessors","[FixedVector]") {
 	constexpr size_t capacity = 5;
-	FixedVector<int> vec(capacity);
+	FixedVector<int> vec = FixedVector<int>::create_empty(capacity);
 
 	// Initial state check
 	CHECK(vec.size() == 0);
@@ -111,7 +111,7 @@ TEST_CASE("FixedVector Generator constructor (tuple)","[FixedVector]") {
 // Test emplace_back, pop_back, and clear with a complex type.
 TEST_CASE("FixedVector Manipulation (emplace_back, pop_back, clear)","[FixedVector]") {
 	constexpr size_t capacity = 4;
-	FixedVector<ComplexType> vec(capacity);
+	FixedVector<ComplexType> vec = FixedVector<ComplexType>::create_empty(capacity);
 
 	// Emplace elements with multiple arguments
 	vec.emplace_back(1, "hello");
@@ -153,7 +153,7 @@ TEST_CASE("FixedVector Manipulation (emplace_back, pop_back, clear)","[FixedVect
 // Test that accessor methods return references to the same memory location
 TEST_CASE("FixedVector Accessor reference consistency","[FixedVector]") {
 	constexpr size_t capacity = 3;
-	FixedVector<int> vec(capacity);
+	FixedVector<int> vec = FixedVector<int>::create_empty(capacity);
 
 	vec.emplace_back(1);
 	CHECK(&vec.front() == &vec.back());
@@ -171,7 +171,7 @@ TEST_CASE("FixedVector Accessor reference consistency","[FixedVector]") {
 // Test with a non-copyable and non-movable type to ensure in-place construction.
 TEST_CASE("FixedVector Non-copyable, non-movable type","[FixedVector]") {
 	constexpr size_t capacity = 2;
-	FixedVector<NonCopyableNonMovable> vec(capacity);
+	FixedVector<NonCopyableNonMovable> vec = FixedVector<NonCopyableNonMovable>::create_empty(capacity);
 
 	// This should work because emplace_back constructs in place
 	const int value0 = 1;
@@ -196,7 +196,7 @@ TEST_CASE("FixedVector Destruction, Clear, and Refill","[FixedVector]") {
 
 	{
 		// Use a scope to test the FixedVector's destructor
-		FixedVector<DestructionCounter> vec(capacity);
+		FixedVector<DestructionCounter> vec = FixedVector<DestructionCounter>::create_empty(capacity);
 
 		// Emplace a few objects
 		vec.emplace_back();