CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.25)
-project(blt-gp VERSION 0.1.45)
+project(blt-gp VERSION 0.1.40)
 
 include(CTest)
 
@@ -16,7 +16,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
-SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -g")
+#SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -g")
 
 if (NOT TARGET BLT)
     add_subdirectory(lib/blt)

dhat.out.293761

@@ -1240,9 +1240,9 @@
  ,"0x122836: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12E6ED: void std::vector<blt::gp::operator_id, std::allocator<blt::gp::operator_id> >::_M_realloc_insert<blt::gp::operator_id const&>(__gnu_cxx::__normal_iterator<blt::gp::operator_id*, std::vector<blt::gp::operator_id, std::allocator<blt::gp::operator_id> > >, blt::gp::operator_id const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12284D: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
- ,"0x12EB76: void std::vector<blt::gp::operator_info_t, std::allocator<blt::gp::operator_info_t> >::_M_realloc_insert<blt::gp::operator_info_t const&>(__gnu_cxx::__normal_iterator<blt::gp::operator_info_t*, std::vector<blt::gp::operator_info_t, std::allocator<blt::gp::operator_info_t> > >, blt::gp::operator_info_t const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
+ ,"0x12EB76: void std::vector<blt::gp::operator_info, std::allocator<blt::gp::operator_info> >::_M_realloc_insert<blt::gp::operator_info const&>(__gnu_cxx::__normal_iterator<blt::gp::operator_info*, std::vector<blt::gp::operator_info, std::allocator<blt::gp::operator_info> > >, blt::gp::operator_info const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12294C: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
- ,"0x12E897: void std::vector<blt::gp::operator_info_t, std::allocator<blt::gp::operator_info_t> >::_M_realloc_insert<blt::gp::operator_info_t const&>(__gnu_cxx::__normal_iterator<blt::gp::operator_info_t*, std::vector<blt::gp::operator_info_t, std::allocator<blt::gp::operator_info_t> > >, blt::gp::operator_info_t const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
+ ,"0x12E897: void std::vector<blt::gp::operator_info, std::allocator<blt::gp::operator_info> >::_M_realloc_insert<blt::gp::operator_info const&>(__gnu_cxx::__normal_iterator<blt::gp::operator_info*, std::vector<blt::gp::operator_info, std::allocator<blt::gp::operator_info> > >, blt::gp::operator_info const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12F1FA: void std::vector<std::function<void (std::ostream&, blt::gp::stack_allocator&)>, std::allocator<std::function<void (std::ostream&, blt::gp::stack_allocator&)> > >::_M_realloc_insert<std::function<void (std::ostream&, blt::gp::stack_allocator&)> >(__gnu_cxx::__normal_iterator<std::function<void (std::ostream&, blt::gp::stack_allocator&)>*, std::vector<std::function<void (std::ostream&, blt::gp::stack_allocator&)>, std::allocator<std::function<void (std::ostream&, blt::gp::stack_allocator&)> > > >, std::function<void (std::ostream&, blt::gp::stack_allocator&)>&&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12298F: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12F3EB: void std::vector<std::optional<std::basic_string_view<char, std::char_traits<char> > >, std::allocator<std::optional<std::basic_string_view<char, std::char_traits<char> > > > >::_M_realloc_insert<std::optional<std::basic_string_view<char, std::char_traits<char> > > >(__gnu_cxx::__normal_iterator<std::optional<std::basic_string_view<char, std::char_traits<char> > >*, std::vector<std::optional<std::basic_string_view<char, std::char_traits<char> > >, std::allocator<std::optional<std::basic_string_view<char, std::char_traits<char> > > > > >, std::optional<std::basic_string_view<char, std::char_traits<char> > >&&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
@@ -1261,7 +1261,7 @@
  ,"0x122F78: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x123052: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x12305D: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
- ,"0x12ED14: std::vector<blt::gp::operator_info_t, std::allocator<blt::gp::operator_info_t> >::push_back(blt::gp::operator_info_t const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
+ ,"0x12ED14: std::vector<blt::gp::operator_info, std::allocator<blt::gp::operator_info> >::push_back(blt::gp::operator_info const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x1231C6: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x123321: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
  ,"0x123390: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"

examples/symbolic_regression.cpp

@@ -22,7 +22,6 @@
 #include <blt/std/format.h>
 #include <iostream>
 #include "operations_common.h"
-#include "blt/math/averages.h"
 
 //static constexpr long SEED = 41912;
 static const unsigned long SEED = std::random_device()();
@@ -143,43 +142,26 @@ int main()
     BLT_PRINT_PROFILE("Symbolic Regression", blt::PRINT_CYCLES | blt::PRINT_THREAD | blt::PRINT_WALL);
 
 #ifdef BLT_TRACK_ALLOCATIONS
-    BLT_TRACE("Total Allocations: %ld times with a total of %s, peak allocated bytes %s", blt::gp::tracker.getAllocations(),
+    BLT_TRACE("Total Allocations: %ld times with a total of %s", blt::gp::tracker.getAllocations(),
-              blt::byte_convert_t(blt::gp::tracker.getAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str(),
+              blt::byte_convert_t(blt::gp::tracker.getAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str());
-              blt::byte_convert_t(blt::gp::tracker.getPeakAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str());
-    BLT_TRACE("------------------------------------------------------");
-    auto evaluation_calls_v = blt::gp::evaluation_calls.get_calls();
-    auto evaluation_allocations_v = blt::gp::evaluation_allocations.get_calls();
-    BLT_TRACE("Total Evaluation Calls: %ld; Peak Bytes Allocated %s", evaluation_calls_v,
-              blt::string::bytes_to_pretty(blt::gp::evaluation_calls.get_value()).c_str());
-    BLT_TRACE("Total Evaluation Allocations: %ld; Bytes %s; Average %s", evaluation_allocations_v,
-              blt::string::bytes_to_pretty(blt::gp::evaluation_allocations.get_value()).c_str(),
-              blt::string::bytes_to_pretty(blt::average(blt::gp::evaluation_allocations.get_value(), evaluation_allocations_v)).c_str());
-    BLT_TRACE("Percent Evaluation calls allocate? %lf%%", blt::average(evaluation_allocations_v, evaluation_calls_v) * 100);
-    BLT_TRACE("------------------------------------------------------");
     auto crossover_calls_v = blt::gp::crossover_calls.get_calls();
     auto crossover_allocations_v = blt::gp::crossover_allocations.get_calls();
     auto mutation_calls_v = blt::gp::mutation_calls.get_calls();
     auto mutation_allocations_v = blt::gp::mutation_allocations.get_calls();
     auto reproduction_calls_v = blt::gp::reproduction_calls.get_calls();
     auto reproduction_allocations_v = blt::gp::reproduction_allocations.get_calls();
-    BLT_TRACE("Total Crossover Calls: %ld; Peak Bytes Allocated %s", crossover_calls_v,
+    BLT_TRACE("Total Crossover Calls: %ld Bytes %s", crossover_calls_v, blt::byte_convert_t(blt::gp::crossover_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-              blt::string::bytes_to_pretty(blt::gp::crossover_calls.get_value()).c_str());
+    BLT_TRACE("Total Mutation Calls: %ld Bytes %s", mutation_calls_v, blt::byte_convert_t(blt::gp::mutation_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-    BLT_TRACE("Total Mutation Calls: %ld; Peak Bytes Allocated %s", mutation_calls_v,
+    BLT_TRACE("Total Reproduction Calls: %ld Bytes %s", reproduction_calls_v, blt::byte_convert_t(blt::gp::reproduction_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-              blt::string::bytes_to_pretty(blt::gp::mutation_calls.get_value()).c_str());
+    BLT_TRACE("Total Crossover Allocations: %ld Bytes %s", crossover_allocations_v, blt::byte_convert_t(blt::gp::crossover_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-    BLT_TRACE("Total Reproduction Calls: %ld; Peak Bytes Allocated %s", reproduction_calls_v,
+    BLT_TRACE("Total Mutation Allocations: %ld Bytes %s", mutation_allocations_v, blt::byte_convert_t(blt::gp::mutation_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-              blt::string::bytes_to_pretty(blt::gp::reproduction_calls.get_value()).c_str());
+    BLT_TRACE("Total Reproduction Allocations: %ld Bytes %s", reproduction_allocations_v, blt::byte_convert_t(blt::gp::reproduction_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
-    BLT_TRACE("Total Crossover Allocations: %ld; Bytes %s; Average %s", crossover_allocations_v,
+    BLT_TRACE("Percent Crossover calls allocate? %lf%%",
-              blt::string::bytes_to_pretty(blt::gp::crossover_allocations.get_value()).c_str(),
+              static_cast<double>(crossover_allocations_v) / static_cast<double>(crossover_calls_v == 0 ? 1 : crossover_calls_v) * 100);
-              blt::string::bytes_to_pretty(blt::average(blt::gp::crossover_allocations.get_value(), crossover_allocations_v)).c_str());
+    BLT_TRACE("Percent Mutation calls allocate? %lf%%",
-    BLT_TRACE("Total Mutation Allocations: %ld; Bytes %s; Average %s", mutation_allocations_v,
+              static_cast<double>(mutation_allocations_v) / static_cast<double>(mutation_calls_v == 0 ? 1 : mutation_calls_v) * 100);
-              blt::string::bytes_to_pretty(blt::gp::mutation_allocations.get_value()).c_str(),
+    BLT_TRACE("Percent Reproduction calls allocate? %lf%%",
-              blt::string::bytes_to_pretty(blt::average(blt::gp::mutation_allocations.get_value(), mutation_allocations_v)).c_str());
+              static_cast<double>(reproduction_allocations_v) / static_cast<double>(reproduction_calls_v == 0 ? 1 : reproduction_calls_v) * 100);
-    BLT_TRACE("Total Reproduction Allocations: %ld; Bytes %s; Average %s", reproduction_allocations_v,
-              blt::string::bytes_to_pretty(blt::gp::reproduction_allocations.get_value()).c_str(),
-              blt::string::bytes_to_pretty(blt::average(blt::gp::reproduction_allocations.get_value(), reproduction_allocations_v)).c_str());
-    BLT_TRACE("Percent Crossover calls allocate? %lf%%", blt::average(crossover_allocations_v, crossover_calls_v) * 100);
-    BLT_TRACE("Percent Mutation calls allocate? %lf%%", blt::average(mutation_allocations_v, mutation_calls_v) * 100);
-    BLT_TRACE("Percent Reproduction calls allocate? %lf%%", blt::average(reproduction_allocations_v, reproduction_calls_v) * 100);
 #endif
     
     return 0;

include/blt/gp/fwdecl.h

@@ -30,18 +30,12 @@ namespace blt::gp
 {
 #ifdef BLT_TRACK_ALLOCATIONS
     inline allocation_tracker_t tracker;
-    
-    // population gen specifics
     inline call_tracker_t crossover_calls;
     inline call_tracker_t mutation_calls;
     inline call_tracker_t reproduction_calls;
     inline call_tracker_t crossover_allocations;
     inline call_tracker_t mutation_allocations;
     inline call_tracker_t reproduction_allocations;
-    
-    // for evaluating fitness
-    inline call_tracker_t evaluation_calls;
-    inline call_tracker_t evaluation_allocations;
 #endif
     
     class gp_program;
@@ -94,7 +88,6 @@ namespace blt::gp
             {
 #ifdef BLT_TRACK_ALLOCATIONS
                 tracker.allocate(bytes);
-//                std::cout << "Hey our aligned allocator allocated " << bytes << " bytes!\n";
 #endif
                 return std::aligned_alloc(8, bytes);
             }
@@ -105,7 +98,6 @@ namespace blt::gp
                     return;
 #ifdef BLT_TRACK_ALLOCATIONS
                 tracker.deallocate(bytes);
-//                std::cout << "[Hey our aligned allocator deallocated " << bytes << " bytes!]\n";
 #else
                 (void) bytes;
 #endif
@@ -136,7 +128,6 @@ namespace blt::gp
             {
 #ifdef BLT_TRACK_ALLOCATIONS
                 tracker.allocate(n * sizeof(T));
-//                std::cout << "Hey our tracked allocator allocated " << (n * sizeof(T)) << " bytes!\n";
 #endif
                 return static_cast<pointer>(std::malloc(n * sizeof(T)));
             }
@@ -150,7 +141,6 @@ namespace blt::gp
             {
 #ifdef BLT_TRACK_ALLOCATIONS
                 tracker.deallocate(n * sizeof(T));
-//                std::cout << "[Hey our tracked allocator deallocated " << (n * sizeof(T)) << " bytes!]\n";
 #else
                 (void) n;
 #endif

include/blt/gp/program.h

@@ -67,7 +67,7 @@ namespace blt::gp
         }
     };
     
-    struct operator_info_t
+    struct operator_info
     {
         // types of the arguments
         tracked_vector<type_id> argument_types;
@@ -79,13 +79,6 @@ namespace blt::gp
         detail::operator_func_t func;
     };
     
-    struct operator_metadata_t
-    {
-        blt::size_t arg_size_bytes = 0;
-        blt::size_t return_size_bytes = 0;
-        argc_t argc{};
-    };
-    
     struct program_operator_storage_t
     {
         // indexed from return TYPE ID, returns index of operator
@@ -94,8 +87,7 @@ namespace blt::gp
         blt::expanding_buffer<tracked_vector<std::pair<operator_id, blt::size_t>>> operators_ordered_terminals;
         // indexed from OPERATOR ID (operator number)
         blt::hashset_t<operator_id> ephemeral_leaf_operators;
-        tracked_vector<operator_info_t> operators;
+        tracked_vector<operator_info> operators;
-        tracked_vector<operator_metadata_t> operator_metadata;
         tracked_vector<detail::print_func_t> print_funcs;
         tracked_vector<detail::destroy_func_t> destroy_funcs;
         tracked_vector<std::optional<std::string_view>> names;
@@ -118,17 +110,11 @@ namespace blt::gp
             template<typename... Operators>
             program_operator_storage_t& build(Operators& ... operators)
             {
-                blt::size_t largest_args = 0;
+                tracked_vector<blt::size_t> sizes;
-                blt::size_t largest_returns = 0;
+                (sizes.push_back(add_operator(operators)), ...);
-                blt::u32 largest_argc = 0;
+                blt::size_t largest = 0;
-                operator_metadata_t meta;
+                for (auto v : sizes)
-                ((meta = add_operator(operators), largest_argc = std::max(meta.argc.argc, largest_argc),
+                    largest = std::max(v, largest);
-                  largest_args = std::max(meta.arg_size_bytes, largest_args), largest_returns = std::max(meta.return_size_bytes,
-                                                                                                         largest_returns)), ...);
-
-//                largest = largest * largest_argc;
-                blt::size_t largest = largest_args * largest_argc * largest_returns * largest_argc;
-                BLT_TRACE(largest);
                 
                 storage.eval_func = [&operators..., largest](const tree_t& tree, void* context) -> evaluation_context& {
                     const auto& ops = tree.get_operations();
@@ -139,11 +125,9 @@ namespace blt::gp
                     results.values.reserve(largest);
                     
                     blt::size_t total_so_far = 0;
-                    blt::size_t op_pos = 0;
                     
                     for (const auto& operation : blt::reverse_iterate(ops.begin(), ops.end()))
                     {
-                        op_pos++;
                         if (operation.is_value)
                         {
                             total_so_far += stack_allocator::aligned_size(operation.type_size);
@@ -230,11 +214,14 @@ namespace blt::gp
                 (storage.system.register_type<Args>(), ...);
                 storage.system.register_type<Return>();
                 
+                auto total_size_required = stack_allocator::aligned_size(sizeof(Return));
+                ((total_size_required += stack_allocator::aligned_size(sizeof(Args))), ...);
+                
                 auto return_type_id = storage.system.get_type<Return>().id();
                 auto operator_id = blt::gp::operator_id(storage.operators.size());
                 op.id = operator_id;
                 
-                operator_info_t info;
+                operator_info info;
                 
                 if constexpr (sizeof...(Args) > 0)
                 {
@@ -253,16 +240,6 @@ namespace blt::gp
                 BLT_ASSERT(info.argc.argc_context - info.argc.argc <= 1 && "Cannot pass multiple context as arguments!");
                 
                 storage.operators.push_back(info);
-                
-                operator_metadata_t meta;
-                if constexpr (sizeof...(Args) != 0)
-                {
-                    meta.arg_size_bytes = (stack_allocator::aligned_size(sizeof(Args)) + ...);
-                }
-                meta.return_size_bytes = sizeof(Return);
-                meta.argc = info.argc;
-                
-                storage.operator_metadata.push_back(meta);
                 storage.print_funcs.push_back([&op](std::ostream& out, stack_allocator& stack) {
                     if constexpr (blt::meta::is_streamable_v<Return>)
                     {
@@ -290,11 +267,11 @@ namespace blt::gp
                 storage.names.push_back(op.get_name());
                 if (op.is_ephemeral())
                     storage.ephemeral_leaf_operators.insert(operator_id);
-                return meta;
+                return total_size_required * 2;
             }
             
             template<typename T>
-            void add_non_context_argument(decltype(operator_info_t::argument_types)& types)
+            void add_non_context_argument(decltype(operator_info::argument_types)& types)
             {
                 if constexpr (!std::is_same_v<Context, detail::remove_cv_ref<T>>)
                 {
@@ -390,7 +367,8 @@ namespace blt::gp
                 (*thread_execution_service)(0);
 #ifdef BLT_TRACK_ALLOCATIONS
                 blt::gp::tracker.stop_measurement(gen_alloc);
-                gen_alloc.pretty_print("Generation");
+        BLT_TRACE("Generation Allocated %ld times with a total of %s", gen_alloc.getAllocationDifference(),
+                  blt::byte_convert_t(gen_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
 #endif
             }
             
@@ -408,13 +386,8 @@ namespace blt::gp
                 evaluate_fitness_internal();
 #ifdef BLT_TRACK_ALLOCATIONS
                 blt::gp::tracker.stop_measurement(fitness_alloc);
-                fitness_alloc.pretty_print("Fitness");
+                BLT_TRACE("Fitness Allocated %ld times with a total of %s", fitness_alloc.getAllocationDifference(),
-                evaluation_calls.call();
+                          blt::byte_convert_t(fitness_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
-                evaluation_calls.set_value(std::max(evaluation_calls.get_value(), fitness_alloc.getAllocatedByteDifference()));
-                if (fitness_alloc.getAllocatedByteDifference() > 0)
-                {
-                    evaluation_allocations.call(fitness_alloc.getAllocatedByteDifference());
-                }
 #endif
                 
             }
@@ -504,7 +477,9 @@ namespace blt::gp
                                     mutation_selection.pre_process(*this, current_pop);
                                     reproduction_selection.pre_process(*this, current_pop);
                                     
-                                    blt::size_t start = perform_elitism(args, next_pop);
+                                    perform_elitism(args, next_pop);
+                                    
+                                    blt::size_t start = config.elites;
                                     
                                     while (start < config.population_size)
                                     {
@@ -593,8 +568,10 @@ namespace blt::gp
                                             mutation_selection.pre_process(*this, current_pop);
                                         if (&crossover_selection != &reproduction_selection)
                                             reproduction_selection.pre_process(*this, current_pop);
-                                        auto elite_amount = perform_elitism(args, next_pop);
+                                        
-                                        thread_helper.next_gen_left -= elite_amount;
+                                        perform_elitism(args, next_pop);
+                                        
+                                        thread_helper.next_gen_left -= config.elites;
                                     }
                                     thread_helper.barrier.wait();
                                     
@@ -678,7 +655,7 @@ namespace blt::gp
                 return storage.system;
             }
             
-            [[nodiscard]] inline operator_info_t& get_operator_info(operator_id id)
+            [[nodiscard]] inline operator_info& get_operator_info(operator_id id)
             {
                 return storage.operators[id];
             }
@@ -748,10 +725,8 @@ namespace blt::gp
                     return a.second > b.second;
                 });
                 
-                for (blt::size_t i = 0; i < std::min(size, config.population_size); i++)
+                for (blt::size_t i = 0; i < size; i++)
                     arr[i] = values[i].first;
-                for (blt::size_t i = std::min(size, config.population_size); i < size; i++)
-                    arr[i] = 0;
                 
                 return arr;
             }
@@ -818,7 +793,7 @@ namespace blt::gp
             
             struct concurrency_storage
             {
-                std::vector<std::unique_ptr<std::thread>> threads;
+                tracked_vector<std::unique_ptr<std::thread>> threads;
                 
                 std::mutex thread_function_control{};
                 std::condition_variable thread_function_condition{};

include/blt/gp/selection.h

@@ -41,7 +41,7 @@ namespace blt::gp
     constexpr inline auto perform_elitism = [](const selector_args& args, population_t& next_pop) {
         auto& [program, current_pop, current_stats, config, random] = args;
         
-        if (config.elites > 0 && current_pop.get_individuals().size() >= config.elites)
+        if (config.elites > 0)
         {
             static thread_local tracked_vector<std::pair<std::size_t, double>> values;
             values.clear();
@@ -70,9 +70,7 @@ namespace blt::gp
             
             for (blt::size_t i = 0; i < config.elites; i++)
                 next_pop.get_individuals()[i].copy_fast(current_pop.get_individuals()[values[i].first].tree);
-            return config.elites;
         }
-        return 0ul;
     };
     
     template<typename Crossover, typename Mutation, typename Reproduction>
@@ -91,7 +89,7 @@ namespace blt::gp
                 if (random.choice(config.crossover_chance))
                 {
 #ifdef BLT_TRACK_ALLOCATIONS
-                    auto state = tracker.start_measurement_thread_local();
+                    auto state = tracker.start_measurement();
 #endif
                     // crossover
                     const tree_t* p1;
@@ -102,13 +100,10 @@ namespace blt::gp
                         p2 = &crossover_selection.select(program, current_pop);
                     } while (!config.crossover.get().apply(program, *p1, *p2, c1, *c2));
 #ifdef BLT_TRACK_ALLOCATIONS
-                    tracker.stop_measurement_thread_local(state);
+                    tracker.stop_measurement(state);
-                    crossover_calls.call();
+                    crossover_calls.call(state.getAllocatedByteDifference());
-                    crossover_calls.set_value(std::max(crossover_calls.get_value(), state.getAllocatedByteDifference()));
+                    if (state.getAllocationDifference() != 0)
-                    if (state.getAllocatedByteDifference() != 0)
-                    {
                         crossover_allocations.call(state.getAllocatedByteDifference());
-                    }
 #endif
                     return 2;
                 }
@@ -117,7 +112,7 @@ namespace blt::gp
                 if (random.choice(config.mutation_chance))
                 {
 #ifdef BLT_TRACK_ALLOCATIONS
-                    auto state = tracker.start_measurement_thread_local();
+                    auto state = tracker.start_measurement();
 #endif
                     // mutation
                     const tree_t* p;
@@ -126,9 +121,8 @@ namespace blt::gp
                         p = &mutation_selection.select(program, current_pop);
                     } while (!config.mutator.get().apply(program, *p, c1));
 #ifdef BLT_TRACK_ALLOCATIONS
-                    tracker.stop_measurement_thread_local(state);
+                    tracker.stop_measurement(state);
-                    mutation_calls.call();
+                    mutation_calls.call(state.getAllocatedByteDifference());
-                    mutation_calls.set_value(std::max(mutation_calls.get_value(), state.getAllocatedByteDifference()));
                     if (state.getAllocationDifference() != 0)
                     {
                         mutation_allocations.call(state.getAllocatedByteDifference());
@@ -141,14 +135,13 @@ namespace blt::gp
                 if (config.reproduction_chance > 0 && random.choice(config.reproduction_chance))
                 {
 #ifdef BLT_TRACK_ALLOCATIONS
-                    auto state = tracker.start_measurement_thread_local();
+                    auto state = tracker.start_measurement();
 #endif
                     // reproduction
                     c1 = reproduction_selection.select(program, current_pop);
 #ifdef BLT_TRACK_ALLOCATIONS
-                    tracker.stop_measurement_thread_local(state);
+                    tracker.stop_measurement(state);
-                    reproduction_calls.call();
+                    reproduction_calls.call(state.getAllocatedByteDifference());
-                    reproduction_calls.set_value(std::max(reproduction_calls.get_value(), state.getAllocatedByteDifference()));
                     if (state.getAllocationDifference() != 0)
                     {
                         reproduction_allocations.call(state.getAllocatedByteDifference());

include/blt/gp/stack.h

@@ -115,7 +115,7 @@ namespace blt::gp
             {
                 if (stack.empty())
                     return;
-                if (stack.bytes_stored + bytes_stored > size_)
+                if (size_ < stack.bytes_stored + bytes_stored)
                     expand(stack.bytes_stored + size_);
                 std::memcpy(data_ + bytes_stored, stack.data_, stack.bytes_stored);
                 bytes_stored += stack.bytes_stored;
@@ -125,7 +125,7 @@ namespace blt::gp
             {
                 if (bytes == 0)
                     return;
-                if (bytes + bytes_stored > size_)
+                if (size_ < bytes + bytes_stored)
                     expand(bytes + size_);
                 std::memcpy(data_ + bytes_stored, stack.data_ + (stack.bytes_stored - bytes), bytes);
                 bytes_stored += bytes;
@@ -135,7 +135,7 @@ namespace blt::gp
             {
                 if (bytes == 0 || data == nullptr)
                     return;
-                if (bytes + bytes_stored > size_)
+                if (size_ < bytes + bytes_stored)
                     expand(bytes + size_);
                 std::memcpy(data_ + bytes_stored, data, bytes);
                 bytes_stored += bytes;

include/blt/gp/stats.h

@@ -20,64 +20,15 @@
 #define BLT_GP_STATS_H
 
 #include <blt/std/types.h>
-#include <blt/std/hashmap.h>
-#include <blt/std/assert.h>
-#include <thread>
-#include <cmath>
-#include <string>
-#include <mutex>
 #include <atomic>
-#include <condition_variable>
+#include <cmath>
 
 namespace blt::gp
 {
+    
     class allocation_tracker_t
     {
         public:
-            class tl_t
-            {
-                    friend allocation_tracker_t;
-                public:
-                    [[nodiscard]] blt::u64 getAllocations() const
-                    {
-                        return get_map(allocations);
-                    }
-                    
-                    [[nodiscard]] blt::u64 getDeallocations() const
-                    {
-                        return get_map(deallocations);
-                    }
-                    
-                    [[nodiscard]] blt::u64 getAllocatedBytes() const
-                    {
-                        return get_map(allocated_bytes);
-                    }
-                    
-                    [[nodiscard]] blt::u64 getDeallocatedBytes() const
-                    {
-                        return get_map(deallocated_bytes);
-                    }
-                    
-                    [[nodiscard]] blt::u64 getAllocationDifference() const
-                    {
-                        return std::abs(static_cast<blt::i64>(getAllocations()) - static_cast<blt::i64>(getDeallocations()));
-                    }
-                    
-                    [[nodiscard]] blt::u64 getCurrentlyAllocatedBytes() const
-                    {
-                        return getAllocatedBytes() - getDeallocatedBytes();
-                    }
-                
-                private:
-                    blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> allocations;
-                    blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> deallocations;
-                    blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> allocated_bytes;
-                    blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> deallocated_bytes;
-                    
-                    std::mutex mutex;
-                    std::condition_variable var;
-            };
-            
             struct allocation_data_t
             {
                 blt::u64 start_allocations = 0;
@@ -109,55 +60,18 @@ namespace blt::gp
                 {
                     return end_deallocated_bytes - start_deallocated_bytes;
                 }
-                
-                void pretty_print(const std::string& name) const;
             };
             
-            void reserve()
-            {
-                {
-                    std::scoped_lock lock(tl.mutex);
-                    tl.allocations.insert({std::this_thread::get_id(), std::make_unique<blt::u64>()});
-                    tl.deallocations.insert({std::this_thread::get_id(), std::make_unique<blt::u64>()});
-                    tl.allocated_bytes.insert({std::this_thread::get_id(), std::make_unique<blt::u64>()});
-                    tl.deallocated_bytes.insert({std::this_thread::get_id(), std::make_unique<blt::u64>()});
-                }
-                tl.var.notify_all();
-            }
-            
-            blt::size_t reserved_threads()
-            {
-                return tl.allocations.size();
-            }
-            
-            void await_thread_loading_complete(blt::u64 required_threads)
-            {
-                std::unique_lock lock(tl.mutex);
-                tl.var.wait(lock, [this, required_threads]() {
-                    return reserved_threads() == required_threads;
-                });
-            }
-            
             void allocate(blt::size_t bytes)
             {
                 allocations++;
                 allocated_bytes += bytes;
-                
-                auto diff = getCurrentlyAllocatedBytes();
-                auto atomic_val = peak_allocated_bytes.load(std::memory_order_relaxed);
-                while (diff > atomic_val &&
-                       !peak_allocated_bytes.compare_exchange_weak(atomic_val, diff, std::memory_order_relaxed, std::memory_order_relaxed));
-                
-                add_map(tl.allocations, 1);
-                add_map(tl.allocated_bytes, bytes);
             }
             
             void deallocate(blt::size_t bytes)
             {
                 deallocations++;
                 deallocated_bytes += bytes;
-                add_map(tl.deallocations, 1);
-                add_map(tl.deallocated_bytes, bytes);
             }
             
             [[nodiscard]] blt::u64 getAllocations() const
@@ -190,78 +104,29 @@ namespace blt::gp
                 return getAllocatedBytes() - getDeallocatedBytes();
             }
             
-            [[nodiscard]] blt::u64 getPeakAllocatedBytes() const
-            {
-                return peak_allocated_bytes;
-            }
-            
-            allocation_tracker_t::tl_t& get_thread_local()
-            {
-                return tl;
-            }
-            
             [[nodiscard]] allocation_data_t start_measurement() const
             {
                 allocation_data_t data{};
-                data.start_allocations = getAllocations();
+                data.start_allocations = allocations;
-                data.start_deallocations = getDeallocations();
+                data.start_deallocations = deallocations;
-                data.start_allocated_bytes = getAllocatedBytes();
+                data.start_allocated_bytes = allocated_bytes;
-                data.start_deallocated_bytes = getDeallocatedBytes();
+                data.start_deallocated_bytes = deallocated_bytes;
-                return data;
-            }
-            
-            [[nodiscard]] allocation_data_t start_measurement_thread_local() const
-            {
-                allocation_data_t data{};
-                data.start_allocations = tl.getAllocations();
-                data.start_deallocations = tl.getDeallocations();
-                data.start_allocated_bytes = tl.getAllocatedBytes();
-                data.start_deallocated_bytes = tl.getDeallocatedBytes();
                 return data;
             }
             
             void stop_measurement(allocation_data_t& data) const
             {
-                data.end_allocations = getAllocations();
+                data.end_allocations = allocations;
-                data.end_deallocations = getDeallocations();
+                data.end_deallocations = deallocations;
-                data.end_allocated_bytes = getAllocatedBytes();
+                data.end_allocated_bytes = allocated_bytes;
-                data.end_deallocated_bytes = getDeallocatedBytes();
+                data.end_deallocated_bytes = deallocated_bytes;
-            }
-            
-            void stop_measurement_thread_local(allocation_data_t& data) const
-            {
-                data.end_allocations = tl.getAllocations();
-                data.end_deallocations = tl.getDeallocations();
-                data.end_allocated_bytes = tl.getAllocatedBytes();
-                data.end_deallocated_bytes = tl.getDeallocatedBytes();
             }
         
         private:
-            static void add_map(blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>>& map, blt::u64 value)
-            {
-                auto l = map.find(std::this_thread::get_id());
-                if (l == map.end())
-                    BLT_ABORT("Thread doesn't exist inside this map!");
-                auto& v = *l->second;
-                v += value;
-            }
-            
-            static blt::u64 get_map(const blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>>& map)
-            {
-                auto l = map.find(std::this_thread::get_id());
-                if (l == map.end())
-                    BLT_ABORT("Thread doesn't exist inside this map!");
-                return *l->second;
-            }
-            
-            tl_t tl;
-            
             std::atomic_uint64_t allocations = 0;
             std::atomic_uint64_t deallocations = 0;
             std::atomic_uint64_t allocated_bytes = 0;
             std::atomic_uint64_t deallocated_bytes = 0;
-            
-            std::atomic_uint64_t peak_allocated_bytes = 0;
     };
     
     class call_tracker_t
@@ -290,11 +155,6 @@ namespace blt::gp
                 secondary_value += value;
             }
             
-            void set_value(blt::u64 value)
-            {
-                secondary_value = value;
-            }
-            
             void call()
             {
                 primary_calls++;
@@ -330,6 +190,7 @@ namespace blt::gp
             std::atomic_uint64_t primary_calls = 0;
             std::atomic_uint64_t secondary_value = 0;
     };
+    
 }
 
 #endif //BLT_GP_STATS_H

include/blt/gp/tree.h

@@ -247,16 +247,6 @@ namespace blt::gp
                 normalized_fitness.push_back(v);
         }
         
-        population_stats(population_stats&& move) noexcept:
-                overall_fitness(move.overall_fitness.load()), average_fitness(move.average_fitness.load()), best_fitness(move.best_fitness.load()),
-                worst_fitness(move.worst_fitness.load()), normalized_fitness(std::move(move.normalized_fitness))
-        {
-            move.overall_fitness = 0;
-            move.average_fitness = 0;
-            move.best_fitness = 0;
-            move.worst_fitness = 0;
-        }
-        
         std::atomic<double> overall_fitness = 0;
         std::atomic<double> average_fitness = 0;
         std::atomic<double> best_fitness = 0;

lib/blt

@@ -1 +1 @@
-Subproject commit a7645d9ddec57ecaad525b48a30f8001adcf75e8
+Subproject commit ab482f1a1c5782bd3501428f26c02f0bb4729946

src/program.cpp

@@ -58,20 +58,12 @@ namespace blt::gp
     
     void gp_program::create_threads()
     {
-#ifdef BLT_TRACK_ALLOCATIONS
-        tracker.reserve();
-#endif
-        statistic_history.reserve(config.max_generations + 1);
         if (config.threads == 0)
             config.set_thread_count(std::thread::hardware_concurrency());
         // main thread is thread0
         for (blt::size_t i = 1; i < config.threads; i++)
         {
             thread_helper.threads.emplace_back(new std::thread([i, this]() {
-#ifdef BLT_TRACK_ALLOCATIONS
-                tracker.reserve();
-                tracker.await_thread_loading_complete(config.threads);
-#endif
                 std::function<void(blt::size_t)>* execution_function = nullptr;
                 while (!should_thread_terminate())
                 {
@@ -91,8 +83,5 @@ namespace blt::gp
                 }
             }));
         }
-#ifdef BLT_TRACK_ALLOCATIONS
-        tracker.await_thread_loading_complete(config.threads);
-#endif
     }
 }

src/stats.cpp

@@ -17,14 +17,8 @@
  */
 #include <blt/gp/stats.h>
 #include <blt/std/logging.h>
-#include "blt/std/format.h"
 
 namespace blt::gp
 {
 
-    void allocation_tracker_t::allocation_data_t::pretty_print(const std::string& name) const
-    {
-        BLT_TRACE("%s Allocations: %ld times with a total of %s", name.c_str(), getAllocationDifference(),
-                  blt::byte_convert_t(getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
-    }
 }

src/transformers.cpp

@@ -105,9 +105,6 @@ namespace blt::gp
         auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
         auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
         
-        c1_stack.reserve(c1_stack.bytes_in_head() - c1_stack_for_bytes + c2_stack_for_bytes);
-        c2_stack.reserve(c2_stack.bytes_in_head() - c2_stack_for_bytes + c1_stack_for_bytes);
-        
         c1_stack.copy_to(copy_ptr_c1, c1_total);
         c1_stack.pop_bytes(c1_total);
         
@@ -171,7 +168,7 @@ namespace blt::gp
         blt::size_t attempted_point = 0;
         
         const auto& crossover_point_type = program.get_operator_info(c1_ops[crossover_point].id);
-        operator_info_t* attempted_point_type = nullptr;
+        operator_info* attempted_point_type = nullptr;
         
         blt::size_t counter = 0;
         do
@@ -459,7 +456,8 @@ namespace blt::gp
                                 config.generator.get().generate(tree,
                                         {program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
                                          config.replacement_max_depth});
-                                vals.insert(tree.get_values());
+                                blt::size_t total_bytes_for = tree.total_value_bytes();
+                                vals.copy_from(tree.get_values(), total_bytes_for);
                                 ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(start_index), tree.get_operations().begin(),
                                            tree.get_operations().end());
                                 start_index += tree.get_operations().size();