fix copy op, change selection behaviour

.gitignore

@@ -1,4 +1,4 @@
-cmake-build*/
+\cmake-build*/
 build/
 out/
 ./cmake-build*/
@@ -8,3 +8,4 @@ massif.*
 callgrind.*
 *.out.*
 heaptrack.*
+vgcore.*

CMakeLists.txt

@@ -27,7 +27,7 @@ macro(compile_options target_name)
     sanitizers(${target_name})
 endmacro()
 
-project(blt-gp VERSION 0.3.0)
+project(blt-gp VERSION 0.3.31)
 
 include(CTest)
 
@@ -46,6 +46,10 @@ find_package(Threads REQUIRED)
 
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -g")
 
+if (NOT ${CMAKE_BUILD_TYPE})
+    set(CMAKE_BUILD_TYPE Release)
+endif ()
+
 if (NOT TARGET BLT)
     add_subdirectory(lib/blt)
 endif ()
@@ -103,18 +107,19 @@ endif ()
 
 if (${BUILD_GP_TESTS})
 
-    blt_add_project(blt-stack tests/old/stack_tests.cpp test)
-    blt_add_project(blt-eval tests/old/evaluation_tests.cpp test)
-    blt_add_project(blt-order tests/old/order_tests.cpp test)
+#    blt_add_project(blt-stack tests/old/stack_tests.cpp test)
+#    blt_add_project(blt-eval tests/old/evaluation_tests.cpp test)
+#    blt_add_project(blt-order tests/old/order_tests.cpp test)
     #blt_add_project(blt-destructor tests/destructor_test.cpp test)
-    blt_add_project(blt-gp1 tests/old/gp_test_1.cpp test)
-    blt_add_project(blt-gp2 tests/old/gp_test_2.cpp test)
-    blt_add_project(blt-gp3 tests/old/gp_test_3.cpp test)
-    blt_add_project(blt-gp4 tests/old/gp_test_4.cpp test)
-    blt_add_project(blt-gp5 tests/old/gp_test_5.cpp test)
-    blt_add_project(blt-gp6 tests/old/gp_test_6.cpp test)
-    blt_add_project(blt-gp7 tests/old/gp_test_7.cpp test)
+#    blt_add_project(blt-gp1 tests/old/gp_test_1.cpp test)
+#    blt_add_project(blt-gp2 tests/old/gp_test_2.cpp test)
+#    blt_add_project(blt-gp3 tests/old/gp_test_3.cpp test)
+#    blt_add_project(blt-gp4 tests/old/gp_test_4.cpp test)
+#    blt_add_project(blt-gp5 tests/old/gp_test_5.cpp test)
+#    blt_add_project(blt-gp6 tests/old/gp_test_6.cpp test)
+#    blt_add_project(blt-gp7 tests/old/gp_test_7.cpp test)
 
     blt_add_project(blt-symbolic-regression tests/symbolic_regression_test.cpp test)
+    blt_add_project(blt-drop tests/drop_test.cpp test)
 
 endif ()

dev_branch.txt

@@ -1,41 +0,0 @@
- Performance counter stats for './cmake-build-release/blt-symbolic-regression-example' (30 runs):
-
-    24,277,728,279      branches                                                                ( +- 19.01% )  (20.47%)
-        76,457,616      branch-misses                    #    0.31% of all branches             ( +- 17.97% )  (21.41%)
-        14,213,192      cache-misses                     #    4.73% of all cache refs           ( +- 14.24% )  (22.52%)
-       300,581,049      cache-references                                                        ( +- 21.08% )  (23.68%)
-    48,914,779,668      cycles                                                                  ( +- 19.65% )  (24.80%)
-   123,068,193,359      instructions                     #    2.52  insn per cycle              ( +- 19.44% )  (25.09%)
-                 0      alignment-faults                                                      
-             4,202      cgroup-switches                                                         ( +- 13.56% )
-           115,962      faults                                                                  ( +- 10.95% )
-       871,101,993 ns   duration_time                                                           ( +- 13.40% )
-    11,507,605,674 ns   user_time                                                               ( +-  3.56% )
-       299,016,204 ns   system_time                                                             ( +-  3.32% )
-    41,446,831,795      L1-dcache-loads                                                         ( +- 19.28% )  (24.69%)
-       167,603,194      L1-dcache-load-misses            #    0.40% of all L1-dcache accesses   ( +- 22.47% )  (23.95%)
-        81,992,073      L1-dcache-prefetches                                                    ( +- 25.34% )  (23.24%)
-       350,398,072      L1-icache-loads                                                         ( +- 15.30% )  (22.70%)
-           909,504      L1-icache-load-misses            #    0.26% of all L1-icache accesses   ( +- 14.46% )  (22.18%)
-        14,271,381      dTLB-loads                                                              ( +- 20.04% )  (21.90%)
-         1,559,972      dTLB-load-misses                 #   10.93% of all dTLB cache accesses  ( +- 14.74% )  (21.39%)
-           246,888      iTLB-loads                                                              ( +- 21.69% )  (20.54%)
-           403,152      iTLB-load-misses                 #  163.29% of all iTLB cache accesses  ( +- 13.35% )  (19.94%)
-       210,585,840      l2_request_g1.all_no_prefetch                                           ( +- 20.07% )  (19.93%)
-           115,962      page-faults                                                             ( +- 10.95% )
-           115,958      page-faults:u                                                           ( +- 10.95% )
-                 3      page-faults:k                                                           ( +-  4.54% )
-    41,209,739,257      L1-dcache-loads                                                         ( +- 19.02% )  (19.60%)
-       181,755,898      L1-dcache-load-misses            #    0.44% of all L1-dcache accesses   ( +- 20.60% )  (20.01%)
-   <not supported>      LLC-loads                                                             
-   <not supported>      LLC-load-misses                                                       
-       425,056,352      L1-icache-loads                                                         ( +- 12.27% )  (20.43%)
-         1,076,486      L1-icache-load-misses            #    0.31% of all L1-icache accesses   ( +- 10.84% )  (20.98%)
-        15,418,419      dTLB-loads                                                              ( +- 17.74% )  (21.24%)
-         1,648,473      dTLB-load-misses                 #   11.55% of all dTLB cache accesses  ( +- 13.11% )  (20.94%)
-           325,141      iTLB-loads                                                              ( +- 26.87% )  (20.80%)
-           459,828      iTLB-load-misses                 #  186.25% of all iTLB cache accesses  ( +- 11.50% )  (20.34%)
-        94,270,593      L1-dcache-prefetches                                                    ( +- 22.82% )  (20.09%)
-   <not supported>      L1-dcache-prefetch-misses                                             
-
-             0.871 +- 0.117 seconds time elapsed  ( +- 13.40% )

examples/rice_classification.h

@@ -131,7 +131,7 @@ namespace blt::gp::example
                 BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.get_hits(), record.get_total(), record.get_percent_hit());
                 std::cout << record.pretty_print() << std::endl;
                 BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
-                i.tree.print(program, std::cout);
+                i.tree.print(std::cout);
 
                 std::cout << "\n";
             }

examples/src/rice_classification.cpp

@@ -35,7 +35,7 @@ blt::gp::prog_config_t config = blt::gp::prog_config_t()
                                 .set_initial_min_tree_size(2)
                                 .set_initial_max_tree_size(6)
                                 .set_elite_count(2)
-                                .set_crossover_chance(0.9)
+                                .set_crossover_chance(0.8)
                                 .set_mutation_chance(0.1)
                                 .set_reproduction_chance(0)
                                 .set_max_generations(50)
@@ -73,7 +73,7 @@ void blt::gp::example::rice_classification_t::make_operators()
     static operation_t mul([](const float a, const float b) { return a * b; }, "mul");
     static operation_t pro_div([](const float a, const float b) { return b == 0.0f ? 0.0f : a / b; }, "div");
     static operation_t op_exp([](const float a) { return std::exp(a); }, "exp");
-    static operation_t op_log([](const float a) { return a == 0.0f ? 0.0f : std::log(a); }, "log");
+    static operation_t op_log([](const float a) { return a <= 0.0f ? 0.0f : std::log(a); }, "log");
     static auto lit = operation_t([this]()
     {
         return program.get_random().get_float(-32000.0f, 32000.0f);

examples/symbolic_regression.h

@@ -91,7 +91,7 @@ namespace blt::gp::example
             static operation_t op_sin([](const float a) { return std::sin(a); }, "sin");
             static operation_t op_cos([](const float a) { return std::cos(a); }, "cos");
             static operation_t op_exp([](const float a) { return std::exp(a); }, "exp");
-            static operation_t op_log([](const float a) { return a == 0.0f ? 0.0f : std::log(a); }, "log");
+            static operation_t op_log([](const float a) { return a <= 0.0f ? 0.0f : std::log(a); }, "log");
             static auto lit = operation_t([this]()
             {
                 return program.get_random().get_float(-1.0f, 1.0f);
@@ -164,7 +164,7 @@ namespace blt::gp::example
             {
                 auto& i = i_ref.get();
                 BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
-                i.tree.print(program, std::cout);
+                i.tree.print(std::cout);
                 std::cout << "\n";
             }
 
@@ -195,6 +195,11 @@ namespace blt::gp::example
             print_stats();
         }
 
+        [[nodiscard]] const auto& get_training_cases() const
+        {
+            return training_cases;
+        }
+
     private:
         std::array<context, 200> training_cases{};
     };

include/blt/gp/config.h

@@ -52,9 +52,9 @@ namespace blt::gp
         std::reference_wrapper<crossover_t> crossover;
         std::reference_wrapper<population_initializer_t> pop_initializer;
 
-        blt::size_t threads = std::thread::hardware_concurrency();
+        size_t threads = std::thread::hardware_concurrency();
         // number of elements each thread should pull per execution. this is for granularity performance and can be optimized for better results!
-        blt::size_t evaluation_size = 4;
+        size_t evaluation_size = 4;
 
         // default config (ramped half-and-half init) or for buildering
         prog_config_t();

include/blt/gp/fwdecl.h

@@ -76,11 +76,11 @@ namespace blt::gp
         
         enum class destroy_t
         {
-            ARGS,
+            PTR,
             RETURN
         };
         
-        using destroy_func_t = std::function<void(destroy_t, stack_allocator&)>;
+        using destroy_func_t = std::function<void(destroy_t, u8*)>;
         
         using const_op_iter_t = tracked_vector<op_container_t>::const_iterator;
         using op_iter_t = tracked_vector<op_container_t>::iterator;

include/blt/gp/operations.h

@@ -22,77 +22,36 @@
 #include <blt/std/types.h>
 #include <blt/gp/typesystem.h>
 #include <blt/gp/stack.h>
+#include <blt/gp/util/meta.h>
 #include <functional>
 #include <type_traits>
 #include <optional>
 
 namespace blt::gp
 {
-    namespace detail
-    {
-        template<typename T>
-        using remove_cv_ref = std::remove_cv_t<std::remove_reference_t<T>>;
-        
-        
-        template<typename...>
-        struct first_arg;
-        
-        template<typename First, typename... Args>
-        struct first_arg<First, Args...>
-        {
-            using type = First;
-        };
-        
-        template<>
-        struct first_arg<>
-        {
-            using type = void;
-        };
-        
-        template<bool b, typename... types>
-        struct is_same;
-        
-        template<typename... types>
-        struct is_same<true, types...> : public std::false_type
-        {
-        };
-        
-        template<typename... types>
-        struct is_same<false, types...> : public std::is_same<types...>
-        {
-        };
-        
-        template<typename... types>
-        constexpr bool is_same_v = is_same<sizeof...(types) == 0, types...>::value;
-        
-        struct empty_t
-        {
-        };
-    }
-    
-    template<typename Return, typename... Args>
+    template <typename Return, typename... Args>
     struct call_with
     {
-        template<blt::u64 index>
-        [[nodiscard]] inline constexpr static blt::size_t getByteOffset()
+        template <u64 index>
+        [[nodiscard]] constexpr static size_t getByteOffset()
         {
-            blt::size_t offset = 0;
-            blt::size_t current_index = 0;
+            size_t offset = 0;
+            size_t current_index = 0;
             ((offset += (current_index++ > index ? stack_allocator::aligned_size<detail::remove_cv_ref<Args>>() : 0)), ...);
-//            BLT_INFO("offset %ld for argument %ld", offset, index);
+            (void)current_index;
             return offset;
         }
-        
-        template<blt::u64... indices>
-        void print_args(std::integer_sequence<blt::u64, indices...>)
+
+        template <u64... indices>
+        void print_args(std::integer_sequence<u64, indices...>)
         {
             BLT_INFO("Arguments:");
             (BLT_INFO("%ld: %s", indices, blt::type_string<Args>().c_str()), ...);
         }
-        
-        template<typename Func, blt::u64... indices, typename... ExtraArgs>
-        inline static constexpr Return exec_sequence_to_indices(Func&& func, stack_allocator& allocator, std::integer_sequence<blt::u64, indices...>,
-                                                                ExtraArgs&& ... args)
+
+        template <typename Func, u64... indices, typename... ExtraArgs>
+        static constexpr Return exec_sequence_to_indices(Func&& func, stack_allocator& allocator, std::integer_sequence<u64, indices...>,
+                                                         ExtraArgs&&... args)
         {
             //blt::size_t arg_size = (stack_allocator::aligned_size<detail::remove_cv_ref<Args>>() + ...);
             //BLT_TRACE(arg_size);
@@ -100,29 +59,39 @@ namespace blt::gp
             return std::forward<Func>(func)(std::forward<ExtraArgs>(args)...,
                                             allocator.from<detail::remove_cv_ref<Args>>(getByteOffset<indices>())...);
         }
-        
-        template<typename context = void, typename... NoCtxArgs>
-        void call_destructors_without_first(stack_allocator& read_allocator)
+
+        template<typename T>
+        static void call_drop(stack_allocator& read_allocator, const size_t offset)
         {
-            if constexpr (sizeof...(NoCtxArgs) > 0)
+            if constexpr (blt::gp::detail::has_func_drop_v<T>)
             {
-                read_allocator.call_destructors<detail::remove_cv_ref<NoCtxArgs>...>();
+                auto [type, ptr] = read_allocator.access_pointer<detail::remove_cv_ref<T>>(offset);
+                if (!ptr.bit(0))
+                    type.drop();
             }
         }
-        
-        template<typename Func, typename... ExtraArgs>
-        Return operator()(bool has_context, Func&& func, stack_allocator& read_allocator, ExtraArgs&& ... args)
+
+        static void call_destructors(stack_allocator& read_allocator)
         {
-            constexpr auto seq = std::make_integer_sequence<blt::u64, sizeof...(Args)>();
+            if constexpr (sizeof...(Args) > 0)
+            {
+                size_t offset = (stack_allocator::aligned_size<detail::remove_cv_ref<Args>>() + ...) - stack_allocator::aligned_size<
+                    detail::remove_cv_ref<typename meta::arg_helper<Args...>::First>>();
+                ((call_drop<Args>(read_allocator, offset), offset -= stack_allocator::aligned_size<detail::remove_cv_ref<Args>>()), ...);
+                (void)offset;
+            }
+        }
+
+        template <typename Func, typename... ExtraArgs>
+        Return operator()(const bool, Func&& func, stack_allocator& read_allocator, ExtraArgs&&... args)
+        {
+            constexpr auto seq = std::make_integer_sequence<u64, sizeof...(Args)>();
 #if BLT_DEBUG_LEVEL > 0
             try
             {
 #endif
             Return ret = exec_sequence_to_indices(std::forward<Func>(func), read_allocator, seq, std::forward<ExtraArgs>(args)...);
-            if (has_context)
-                call_destructors_without_first<Args...>(read_allocator);
-            else
-                read_allocator.call_destructors<detail::remove_cv_ref<Args>...>();
+            call_destructors(read_allocator);
             read_allocator.pop_bytes((stack_allocator::aligned_size<detail::remove_cv_ref<Args>>() + ...));
             return ret;
 #if BLT_DEBUG_LEVEL > 0
@@ -134,121 +103,132 @@ namespace blt::gp
 #endif
         }
     };
-    
-    template<typename Return, typename, typename... Args>
+
+    template <typename Return, typename, typename... Args>
     struct call_without_first : public call_with<Return, Args...>
     {
         using call_with<Return, Args...>::call_with;
     };
-    
-    template<typename, typename>
+
+    template <typename, typename>
     class operation_t;
-    
-    template<typename RawFunction, typename Return, typename... Args>
+
+    template <typename RawFunction, typename Return, typename... Args>
     class operation_t<RawFunction, Return(Args...)>
     {
-        public:
-            using function_t = RawFunction;
-            using First_Arg = typename blt::meta::arg_helper<Args...>::First;
-            
-            constexpr operation_t(const operation_t& copy) = default;
-            
-            constexpr operation_t(operation_t&& move) = default;
-            
-            template<typename Functor>
-            constexpr explicit operation_t(const Functor& functor, std::optional<std::string_view> name = {}): func(functor), name(name)
-            {}
-            
-            [[nodiscard]] constexpr inline Return operator()(stack_allocator& read_allocator) const
+    public:
+        using function_t = RawFunction;
+        using First_Arg = typename blt::meta::arg_helper<Args...>::First;
+
+        constexpr operation_t(const operation_t& copy) = default;
+
+        constexpr operation_t(operation_t&& move) = default;
+
+        template <typename Functor>
+        constexpr explicit operation_t(const Functor& functor, const std::optional<std::string_view> name = {}): func(functor), name(name)
+        {
+        }
+
+        [[nodiscard]] constexpr Return operator()(stack_allocator& read_allocator) const
+        {
+            if constexpr (sizeof...(Args) == 0)
             {
-                if constexpr (sizeof...(Args) == 0)
+                return func();
+            }
+            else
+            {
+                return call_with<Return, Args...>()(false, func, read_allocator);
+            }
+        }
+
+        [[nodiscard]] constexpr Return operator()(void* context, stack_allocator& read_allocator) const
+        {
+            // should be an impossible state
+            if constexpr (sizeof...(Args) == 0)
+            {
+                BLT_ABORT("Cannot pass context to function without arguments!");
+            }
+            auto& ctx_ref = *static_cast<detail::remove_cv_ref<typename detail::first_arg<Args...>::type>*>(context);
+            if constexpr (sizeof...(Args) == 1)
+            {
+                return func(ctx_ref);
+            }
+            else
+            {
+                return call_without_first<Return, Args...>()(true, func, read_allocator, ctx_ref);
+            }
+        }
+
+        template <typename Context>
+        [[nodiscard]] detail::operator_func_t make_callable() const
+        {
+            return [this](void* context, stack_allocator& read_allocator, stack_allocator& write_allocator)
+            {
+                if constexpr (detail::is_same_v<Context, detail::remove_cv_ref<typename detail::first_arg<Args...>::type>>)
                 {
-                    return func();
-                } else
-                {
-                    return call_with<Return, Args...>()(false, func, read_allocator);
+                    // first arg is context
+                    write_allocator.push(this->operator()(context, read_allocator));
                 }
-            }
-            
-            [[nodiscard]] constexpr inline Return operator()(void* context, stack_allocator& read_allocator) const
-            {
-                // should be an impossible state
-                if constexpr (sizeof...(Args) == 0)
+                else
                 {
-                    BLT_ABORT("Cannot pass context to function without arguments!");
+                    // first arg isn't context
+                    write_allocator.push(this->operator()(read_allocator));
                 }
-                auto& ctx_ref = *static_cast<detail::remove_cv_ref<typename detail::first_arg<Args...>::type>*>(context);
-                if constexpr (sizeof...(Args) == 1)
-                {
-                    return func(ctx_ref);
-                } else
-                {
-                    return call_without_first<Return, Args...>()(true, func, read_allocator, ctx_ref);
-                }
-            }
-            
-            template<typename Context>
-            [[nodiscard]] detail::operator_func_t make_callable() const
-            {
-                return [this](void* context, stack_allocator& read_allocator, stack_allocator& write_allocator) {
-                    if constexpr (detail::is_same_v<Context, detail::remove_cv_ref<typename detail::first_arg<Args...>::type>>)
-                    {
-                        // first arg is context
-                        write_allocator.push(this->operator()(context, read_allocator));
-                    } else
-                    {
-                        // first arg isn't context
-                        write_allocator.push(this->operator()(read_allocator));
-                    }
-                };
-            }
-            
-            [[nodiscard]] inline constexpr std::optional<std::string_view> get_name() const
-            {
-                return name;
-            }
-            
-            inline constexpr const auto& get_function() const
-            {
-                return func;
-            }
-            
-            inline auto set_ephemeral()
-            {
-                is_ephemeral_ = true;
-                return *this;
-            }
-            
-            inline bool is_ephemeral()
-            {
-                return is_ephemeral_;
-            }
-            
-            operator_id id = -1;
-        private:
-            function_t func;
-            std::optional<std::string_view> name;
-            bool is_ephemeral_ = false;
+            };
+        }
+
+        [[nodiscard]] inline constexpr std::optional<std::string_view> get_name() const
+        {
+            return name;
+        }
+
+        inline constexpr const auto& get_function() const
+        {
+            return func;
+        }
+
+        auto set_ephemeral()
+        {
+            is_ephemeral_ = true;
+            return *this;
+        }
+
+        [[nodiscard]] bool is_ephemeral() const
+        {
+            return is_ephemeral_;
+        }
+
+        [[nodiscard]] bool return_has_ephemeral_drop() const
+        {
+            return detail::has_func_drop_v<Return>;
+        }
+
+        operator_id id = -1;
+
+    private:
+        function_t func;
+        std::optional<std::string_view> name;
+        bool is_ephemeral_ = false;
     };
-    
-    template<typename RawFunction, typename Return, typename Class, typename... Args>
+
+    template <typename RawFunction, typename Return, typename Class, typename... Args>
     class operation_t<RawFunction, Return (Class::*)(Args...) const> : public operation_t<RawFunction, Return(Args...)>
     {
-        public:
-            using operation_t<RawFunction, Return(Args...)>::operation_t;
+    public:
+        using operation_t<RawFunction, Return(Args...)>::operation_t;
     };
-    
-    template<typename Lambda>
+
+    template <typename Lambda>
     operation_t(Lambda) -> operation_t<Lambda, decltype(&Lambda::operator())>;
-    
-    template<typename Return, typename... Args>
-    operation_t(Return(*)(Args...)) -> operation_t<Return(*)(Args...), Return(Args...)>;
-    
-    template<typename Lambda>
+
+    template <typename Return, typename... Args>
+    operation_t(Return (*)(Args...)) -> operation_t<Return(*)(Args...), Return(Args...)>;
+
+    template <typename Lambda>
     operation_t(Lambda, std::optional<std::string_view>) -> operation_t<Lambda, decltype(&Lambda::operator())>;
-    
-    template<typename Return, typename... Args>
-    operation_t(Return(*)(Args...), std::optional<std::string_view>) -> operation_t<Return(*)(Args...), Return(Args...)>;
+
+    template <typename Return, typename... Args>
+    operation_t(Return (*)(Args...), std::optional<std::string_view>) -> operation_t<Return(*)(Args...), Return(Args...)>;
 }
 
 #endif //BLT_GP_OPERATIONS_H

include/blt/gp/program.h

@@ -52,6 +52,7 @@
 #include <blt/gp/stack.h>
 #include <blt/gp/config.h>
 #include <blt/gp/random.h>
+#include <blt/gp/threading.h>
 #include "blt/format/format.h"
 
 namespace blt::gp
@@ -89,11 +90,12 @@ namespace blt::gp
     struct program_operator_storage_t
     {
         // indexed from return TYPE ID, returns index of operator
-        blt::expanding_buffer<tracked_vector<operator_id>> terminals;
-        blt::expanding_buffer<tracked_vector<operator_id>> non_terminals;
-        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;
+        expanding_buffer<tracked_vector<operator_id>> terminals;
+        expanding_buffer<tracked_vector<operator_id>> non_terminals;
+        expanding_buffer<tracked_vector<std::pair<operator_id, size_t>>> operators_ordered_terminals;
+        // indexed from OPERATOR ID (operator number) to a bitfield of flags
+        hashmap_t<operator_id, operator_special_flags> operator_flags;
+
         tracked_vector<operator_info_t> operators;
         tracked_vector<operator_metadata_t> operator_metadata;
         tracked_vector<detail::print_func_t> print_funcs;
@@ -127,33 +129,9 @@ namespace blt::gp
                     largest_returns)), ...);
 
             //                largest = largest * largest_argc;
-            blt::size_t largest = largest_args * largest_argc * largest_returns * largest_argc;
+            size_t largest = largest_args * largest_argc * largest_returns * largest_argc;
 
-            storage.eval_func = [&operators..., largest](const tree_t& tree, void* context) -> evaluation_context& {
-                const auto& ops = tree.get_operations();
-                const auto& vals = tree.get_values();
-
-                static thread_local evaluation_context results{};
-                results.values.reset();
-                results.values.reserve(largest);
-
-                blt::size_t total_so_far = 0;
-                blt::size_t op_pos = 0;
-
-                for (const auto& operation : iterate(ops).rev())
-                {
-                    op_pos++;
-                    if (operation.is_value())
-                    {
-                        total_so_far += operation.type_size();
-                        results.values.copy_from(vals.from(total_so_far), operation.type_size());
-                        continue;
-                    }
-                    call_jmp_table(operation.id(), context, results.values, results.values, operators...);
-                }
-
-                return results;
-            };
+            storage.eval_func = tree_t::make_execution_lambda<Context>(largest, operators...);
 
             blt::hashset_t<type_id> has_terminals;
 
@@ -246,7 +224,7 @@ namespace blt::gp
             info.return_type = return_type_id;
             info.func = op.template make_callable<Context>();
 
-            ((std::is_same_v<detail::remove_cv_ref<Args>, Context> ? info.argc.argc -= 1 : (blt::size_t)nullptr), ...);
+            ((std::is_same_v<detail::remove_cv_ref<Args>, Context> ? info.argc.argc -= 1 : 0), ...);
 
             auto& operator_list = info.argc.argc == 0 ? storage.terminals : storage.non_terminals;
             operator_list[return_type_id].push_back(operator_id);
@@ -276,24 +254,21 @@ namespace blt::gp
                     out << "[Printing Value on '" << (op.get_name() ? *op.get_name() : "") << "' Not Supported!]";
                 }
             });
-            storage.destroy_funcs.push_back([](detail::destroy_t type, stack_allocator& alloc)
+            storage.destroy_funcs.push_back([](const detail::destroy_t type, u8* data)
             {
                 switch (type)
                 {
-                case detail::destroy_t::ARGS:
-                    alloc.call_destructors<Args...>();
-                    break;
+                case detail::destroy_t::PTR:
                 case detail::destroy_t::RETURN:
                     if constexpr (detail::has_func_drop_v<remove_cvref_t<Return>>)
                     {
-                        alloc.from<detail::remove_cv_ref<Return>>(0).drop();
+                        reinterpret_cast<detail::remove_cv_ref<Return>*>(data)->drop();
                     }
                     break;
                 }
             });
             storage.names.push_back(op.get_name());
-            if (op.is_ephemeral())
-                storage.ephemeral_leaf_operators.insert(operator_id);
+            storage.operator_flags.emplace(operator_id, operator_special_flags{op.is_ephemeral(), op.return_has_ephemeral_drop()});
             return meta;
         }
 
@@ -306,48 +281,7 @@ namespace blt::gp
             }
         }
 
-        template <typename Operator>
-        static void execute(void* context, stack_allocator& write_stack, stack_allocator& read_stack, Operator& operation)
-        {
-            if constexpr (std::is_same_v<detail::remove_cv_ref<typename Operator::First_Arg>, Context>)
-            {
-                write_stack.push(operation(context, read_stack));
-            }
-            else
-            {
-                write_stack.push(operation(read_stack));
-            }
-        }
-
-        template <blt::size_t id, typename Operator>
-        static bool call(blt::size_t op, void* context, stack_allocator& write_stack, stack_allocator& read_stack, Operator& operation)
-        {
-            if (id == op)
-            {
-                execute(context, write_stack, read_stack, operation);
-                return false;
-            }
-            return true;
-        }
-
-        template <typename... Operators, size_t... operator_ids>
-        static void call_jmp_table_internal(size_t op, void* context, stack_allocator& write_stack, stack_allocator& read_stack,
-                                                   std::integer_sequence<size_t, operator_ids...>, Operators&... operators)
-        {
-            if (op >= sizeof...(operator_ids))
-            {
-                BLT_UNREACHABLE;
-            }
-            (call<operator_ids>(op, context, write_stack, read_stack, operators) && ...);
-        }
-
-        template <typename... Operators>
-        static void call_jmp_table(size_t op, void* context, stack_allocator& write_stack, stack_allocator& read_stack,
-                                          Operators&... operators)
-        {
-            call_jmp_table_internal(op, context, write_stack, read_stack, std::index_sequence_for<Operators...>(), operators...);
-        }
-
+    private:
         program_operator_storage_t storage;
     };
 
@@ -363,11 +297,13 @@ namespace blt::gp
         explicit gp_program(blt::u64 seed): seed_func([seed] { return seed; })
         {
             create_threads();
+            selection_probabilities.update(config);
         }
 
         explicit gp_program(blt::u64 seed, const prog_config_t& config): seed_func([seed] { return seed; }), config(config)
         {
             create_threads();
+            selection_probabilities.update(config);
         }
 
         /**
@@ -378,11 +314,13 @@ namespace blt::gp
         explicit gp_program(std::function<blt::u64()> seed_func): seed_func(std::move(seed_func))
         {
             create_threads();
+            selection_probabilities.update(config);
         }
 
         explicit gp_program(std::function<blt::u64()> seed_func, const prog_config_t& config): seed_func(std::move(seed_func)), config(config)
         {
             create_threads();
+            selection_probabilities.update(config);
         }
 
         ~gp_program()
@@ -464,13 +402,12 @@ namespace blt::gp
          *
          * NOTE: 0 is considered the best, in terms of standardized fitness
          */
-        template <typename FitnessFunc, typename Crossover, typename Mutation, typename Reproduction, typename CreationFunc = decltype(
-                      default_next_pop_creator<Crossover, Mutation, Reproduction>)>
+        template <typename FitnessFunc, typename Crossover, typename Mutation, typename Reproduction>
         void generate_population(type_id root_type, FitnessFunc& fitness_function,
                                  Crossover& crossover_selection, Mutation& mutation_selection, Reproduction& reproduction_selection,
-                                 CreationFunc& func = default_next_pop_creator<Crossover, Mutation, Reproduction>, bool eval_fitness_now = true)
+                                 bool eval_fitness_now = true)
         {
-            using LambdaReturn = typename decltype(blt::meta::lambda_helper(fitness_function))::Return;
+            using LambdaReturn = std::invoke_result_t<decltype(fitness_function), const tree_t&, fitness_t&, size_t>;
             current_pop = config.pop_initializer.get().generate(
                 {*this, root_type, config.population_size, config.initial_min_tree_size, config.initial_max_tree_size});
             next_pop = population_t(current_pop);
@@ -481,8 +418,8 @@ namespace blt::gp
             if (config.threads == 1)
             {
                 BLT_INFO("Starting with single thread variant!");
-                thread_execution_service = std::unique_ptr<std::function<void(blt::size_t)>>(new std::function(
-                    [this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection, &func](blt::size_t)
+                thread_execution_service = std::unique_ptr<std::function<void(size_t)>>(new std::function(
+                    [this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection](size_t)
                     {
                         if (thread_helper.evaluation_left > 0)
                         {
@@ -493,8 +430,7 @@ namespace blt::gp
                                 ind.fitness = {};
                                 if constexpr (std::is_same_v<LambdaReturn, bool> || std::is_convertible_v<LambdaReturn, bool>)
                                 {
-                                    auto result = fitness_function(ind.tree, ind.fitness, index);
-                                    if (result)
+                                    if (fitness_function(ind.tree, ind.fitness, index))
                                         fitness_should_exit = true;
                                 }
                                 else
@@ -524,7 +460,7 @@ 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);
+                            size_t start = detail::perform_elitism(args, next_pop);
 
                             while (start < config.population_size)
                             {
@@ -532,7 +468,7 @@ namespace blt::gp
                                 tree_t* c2 = nullptr;
                                 if (start + 1 < config.population_size)
                                     c2 = &next_pop.get_individuals()[start + 1].tree;
-                                start += func(args, crossover_selection, mutation_selection, reproduction_selection, c1, c2, fitness_function);
+                                start += perform_selection(crossover_selection, mutation_selection, reproduction_selection, c1, c2);
                             }
 
                             thread_helper.next_gen_left = 0;
@@ -544,9 +480,10 @@ namespace blt::gp
                 BLT_INFO("Starting thread execution service!");
                 std::scoped_lock lock(thread_helper.thread_function_control);
                 thread_execution_service = std::unique_ptr<std::function<void(blt::size_t)>>(new std::function(
-                    [this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection, &func](blt::size_t id)
+                    [this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection](size_t id)
                     {
                         thread_helper.barrier.wait();
+
                         if (thread_helper.evaluation_left > 0)
                         {
                             while (thread_helper.evaluation_left > 0)
@@ -606,6 +543,7 @@ namespace blt::gp
                         }
                         if (thread_helper.next_gen_left > 0)
                         {
+                            thread_helper.barrier.wait();
                             auto args = get_selector_args();
                             if (id == 0)
                             {
@@ -623,16 +561,16 @@ 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);
+                                const auto elite_amount = detail::perform_elitism(args, next_pop);
                                 thread_helper.next_gen_left -= elite_amount;
                             }
                             thread_helper.barrier.wait();
 
                             while (thread_helper.next_gen_left > 0)
                             {
-                                blt::size_t size = 0;
-                                blt::size_t begin = 0;
-                                blt::size_t end = thread_helper.next_gen_left.load(std::memory_order_relaxed);
+                                size_t size = 0;
+                                size_t begin = 0;
+                                size_t end = thread_helper.next_gen_left.load(std::memory_order_relaxed);
                                 do
                                 {
                                     size = std::min(end, config.evaluation_size);
@@ -649,7 +587,7 @@ namespace blt::gp
                                     tree_t* c2 = nullptr;
                                     if (begin + 1 < end)
                                         c2 = &next_pop.get_individuals()[index + 1].tree;
-                                    begin += func(args, crossover_selection, mutation_selection, reproduction_selection, c1, c2, fitness_function);
+                                    begin += perform_selection(crossover_selection, mutation_selection, reproduction_selection, c1, c2);
                                 }
                             }
                         }
@@ -703,6 +641,11 @@ namespace blt::gp
 
         [[nodiscard]] random_t& get_random() const;
 
+        [[nodiscard]] const prog_config_t& get_config() const
+        {
+            return config;
+        }
+
         [[nodiscard]] type_provider& get_typesystem()
         {
             return storage.system;
@@ -753,9 +696,19 @@ namespace blt::gp
             return current_stats;
         }
 
-        [[nodiscard]] bool is_operator_ephemeral(operator_id id)
+        [[nodiscard]] bool is_operator_ephemeral(const operator_id id) const
         {
-            return storage.ephemeral_leaf_operators.contains(static_cast<blt::size_t>(id));
+            return storage.operator_flags.find(static_cast<size_t>(id))->second.is_ephemeral();
+        }
+
+        [[nodiscard]] bool operator_has_ephemeral_drop(const operator_id id) const
+        {
+            return storage.operator_flags.find(static_cast<size_t>(id))->second.has_ephemeral_drop();
+        }
+
+        [[nodiscard]] operator_special_flags get_operator_flags(const operator_id id) const
+        {
+            return storage.operator_flags.find(static_cast<size_t>(id))->second;
         }
 
         void set_operations(program_operator_storage_t op)
@@ -808,6 +761,104 @@ namespace blt::gp
         }
 
     private:
+        template <typename Crossover, typename Mutation, typename Reproduction>
+        size_t perform_selection(Crossover& crossover, Mutation& mutation, Reproduction& reproduction, tree_t& c1, tree_t* c2)
+        {
+            if (get_random().choice(selection_probabilities.crossover_chance))
+            {
+                auto ptr = c2;
+                if (ptr == nullptr)
+                    ptr = &tree_t::get_thread_local(*this);
+#ifdef BLT_TRACK_ALLOCATIONS
+                auto state = tracker.start_measurement_thread_local();
+#endif
+                const tree_t* p1;
+                const tree_t* p2;
+                size_t runs = 0;
+                do
+                {
+                    // BLT_TRACE("%lu %p %p", runs, &c1, &tree);
+                    p1 = &crossover.select(*this, current_pop);
+                    p2 = &crossover.select(*this, current_pop);
+                    // BLT_TRACE("%p %p || %lu", p1, p2, current_pop.get_individuals().size());
+
+                    c1.copy_fast(*p1);
+                    ptr->copy_fast(*p2);
+                    // ptr->copy_fast(*p2);
+
+                    if (++runs >= config.crossover.get().get_config().max_crossover_iterations)
+                        return 0;
+#ifdef BLT_TRACK_ALLOCATIONS
+                    crossover_calls.value(1);
+#endif
+                }
+                while (!config.crossover.get().apply(*this, *p1, *p2, c1, *ptr));
+#ifdef BLT_TRACK_ALLOCATIONS
+                tracker.stop_measurement_thread_local(state);
+                crossover_calls.call();
+                if (state.getAllocatedByteDifference() != 0)
+                {
+                    crossover_allocations.call(state.getAllocatedByteDifference());
+                    crossover_allocations.set_value(std::max(crossover_allocations.get_value(), state.getAllocatedByteDifference()));
+                }
+#endif
+                if (c2 == nullptr)
+                {
+                    tree_t::get_thread_local(*this).clear(*this);
+                    return 1;
+                }
+                return 2;
+            }
+            if (get_random().choice(selection_probabilities.mutation_chance))
+            {
+#ifdef BLT_TRACK_ALLOCATIONS
+                auto state = tracker.start_measurement_thread_local();
+#endif
+                // mutation
+                const tree_t* p;
+                do
+                {
+                    p = &mutation.select(*this, current_pop);
+                    c1.copy_fast(*p);
+#ifdef BLT_TRACK_ALLOCATIONS
+                    mutation_calls.value(1);
+#endif
+                }
+                while (!config.mutator.get().apply(*this, *p, c1));
+#ifdef BLT_TRACK_ALLOCATIONS
+                tracker.stop_measurement_thread_local(state);
+                mutation_calls.call();
+                if (state.getAllocationDifference() != 0)
+                {
+                    mutation_allocations.call(state.getAllocatedByteDifference());
+                    mutation_allocations.set_value(std::max(mutation_allocations.get_value(), state.getAllocatedByteDifference()));
+                }
+#endif
+                return 1;
+            }
+            if (selection_probabilities.reproduction_chance > 0)
+            {
+#ifdef BLT_TRACK_ALLOCATIONS
+                auto state = tracker.start_measurement_thread_local();
+#endif
+                // reproduction
+                c1.copy_fast(reproduction.select(*this, current_pop));
+#ifdef BLT_TRACK_ALLOCATIONS
+                tracker.stop_measurement_thread_local(state);
+                reproduction_calls.call();
+                reproduction_calls.value(1);
+                if (state.getAllocationDifference() != 0)
+                {
+                    reproduction_allocations.call(state.getAllocatedByteDifference());
+                    reproduction_allocations.set_value(std::max(reproduction_allocations.get_value(), state.getAllocatedByteDifference()));
+                }
+#endif
+                return 1;
+            }
+
+            return 0;
+        }
+
         selector_args get_selector_args()
         {
             return {*this, current_pop, current_stats, config, get_random()};
@@ -815,7 +866,7 @@ namespace blt::gp
 
         template <typename Return, blt::size_t size, typename Accessor, blt::size_t... indexes>
         Return convert_array(std::array<blt::size_t, size>&& arr, Accessor&& accessor,
-                                    std::integer_sequence<blt::size_t, indexes...>)
+                             std::integer_sequence<blt::size_t, indexes...>)
         {
             return Return{accessor(arr, indexes)...};
         }
@@ -837,6 +888,22 @@ namespace blt::gp
         std::function<u64()> seed_func;
         prog_config_t config{};
 
+        // internal cache which stores already calculated probability values
+        struct
+        {
+            double crossover_chance = 0;
+            double mutation_chance = 0;
+            double reproduction_chance = 0;
+
+            void update(const prog_config_t& config)
+            {
+                const auto total = config.crossover_chance + config.mutation_chance + config.reproduction_chance;
+                crossover_chance = config.crossover_chance / total;
+                mutation_chance = config.mutation_chance / total;
+                reproduction_chance = config.reproduction_chance / total;
+            }
+        } selection_probabilities;
+
         population_t current_pop;
         population_t next_pop;
 

include/blt/gp/selection.h

@@ -39,185 +39,51 @@ namespace blt::gp
         random_t& random;
     };
 
-    constexpr inline auto perform_elitism = [](const selector_args& args, population_t& next_pop)
+    namespace detail
     {
-        auto& [program, current_pop, current_stats, config, random] = args;
-
-        BLT_ASSERT_MSG(config.elites <= current_pop.get_individuals().size(), ("Not enough individuals in population (" +
-                           std::to_string(current_pop.get_individuals().size()) +
-                           ") for requested amount of elites (" + std::to_string(config.elites) + ")").c_str());
-
-        if (config.elites > 0 && current_pop.get_individuals().size() >= config.elites)
+        constexpr inline auto perform_elitism = [](const selector_args& args, population_t& next_pop)
         {
-            static thread_local tracked_vector<std::pair<std::size_t, double>> values;
-            values.clear();
+            auto& [program, current_pop, current_stats, config, random] = args;
 
-            for (blt::size_t i = 0; i < config.elites; i++)
-                values.emplace_back(i, current_pop.get_individuals()[i].fitness.adjusted_fitness);
+            BLT_ASSERT_MSG(config.elites <= current_pop.get_individuals().size(), ("Not enough individuals in population (" +
+                               std::to_string(current_pop.get_individuals().size()) +
+                               ") for requested amount of elites (" + std::to_string(config.elites) + ")").c_str());
 
-            for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
+            if (config.elites > 0 && current_pop.get_individuals().size() >= config.elites)
             {
-                for (blt::size_t i = 0; i < config.elites; i++)
+                thread_local tracked_vector<std::pair<std::size_t, double>> values;
+                values.clear();
+
+                for (size_t i = 0; i < config.elites; i++)
+                    values.emplace_back(i, current_pop.get_individuals()[i].fitness.adjusted_fitness);
+
+                for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
                 {
-                    if (ind.value.fitness.adjusted_fitness >= values[i].second)
+                    for (size_t i = 0; i < config.elites; i++)
                     {
-                        bool doesnt_contain = true;
-                        for (blt::size_t j = 0; j < config.elites; j++)
+                        if (ind.value.fitness.adjusted_fitness >= values[i].second)
                         {
-                            if (ind.index == values[j].first)
-                                doesnt_contain = false;
+                            bool doesnt_contain = true;
+                            for (blt::size_t j = 0; j < config.elites; j++)
+                            {
+                                if (ind.index == values[j].first)
+                                    doesnt_contain = false;
+                            }
+                            if (doesnt_contain)
+                                values[i] = {ind.index, ind.value.fitness.adjusted_fitness};
+                            break;
                         }
-                        if (doesnt_contain)
-                            values[i] = {ind.index, ind.value.fitness.adjusted_fitness};
-                        break;
                     }
                 }
+
+                for (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;
+        };
 
-            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;
-    };
-
-    inline std::atomic<double> parent_fitness = 0;
-    inline std::atomic<double> child_fitness = 0;
-
-    template <typename Crossover, typename Mutation, typename Reproduction>
-    constexpr inline auto default_next_pop_creator = [](
-        selector_args& args, Crossover& crossover_selection, Mutation& mutation_selection, Reproduction& reproduction_selection,
-        tree_t& c1, tree_t* c2, const std::function<bool(const tree_t&, fitness_t&, size_t)>& test_fitness_func)
-    {
-        auto& [program, current_pop, current_stats, config, random] = args;
-
-        switch (random.get_i32(0, 3))
-        {
-        case 0:
-            if (c2 == nullptr)
-                return 0;
-        // everyone gets a chance once per loop.
-            if (random.choice(config.crossover_chance))
-            {
-#ifdef BLT_TRACK_ALLOCATIONS
-                auto state = tracker.start_measurement_thread_local();
-#endif
-                // crossover
-
-                const tree_t* p1;
-                const tree_t* p2;
-                // double parent_val = 0;
-                do
-                {
-                    p1 = &crossover_selection.select(program, current_pop);
-                    p2 = &crossover_selection.select(program, current_pop);
-
-                    // fitness_t fitness1;
-                    // fitness_t fitness2;
-                    // test_fitness_func(*p1, fitness1, 0);
-                    // test_fitness_func(*p2, fitness2, 0);
-                    // parent_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
-                    // BLT_TRACE("%ld> P1 Fit: %lf, P2 Fit: %lf", val, fitness1.adjusted_fitness, fitness2.adjusted_fitness);
-
-                    c1.copy_fast(*p1);
-                    c2->copy_fast(*p2);
-
-#ifdef BLT_TRACK_ALLOCATIONS
-                    crossover_calls.value(1);
-#endif
-                }
-                while (!config.crossover.get().apply(program, *p1, *p2, c1, *c2));
-                // fitness_t fitness1;
-                // fitness_t fitness2;
-                // test_fitness_func(c1, fitness1, 0);
-                // test_fitness_func(*c2, fitness2, 0);
-
-                // const auto child_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
-
-                // auto old_parent_val = parent_fitness.load(std::memory_order_relaxed);
-                // while (!parent_fitness.compare_exchange_weak(old_parent_val, old_parent_val + parent_val, std::memory_order_relaxed,
-                // std::memory_order_relaxed))
-                // {
-                // }
-
-                // auto old_child_val = child_fitness.load(std::memory_order_relaxed);
-                // while (!child_fitness.compare_exchange_weak(old_child_val, old_child_val + child_val, std::memory_order_relaxed,
-                // std::memory_order_relaxed))
-                // {
-                // }
-
-                // BLT_TRACE("%ld> C1 Fit: %lf, C2 Fit: %lf", val, fitness1.adjusted_fitness, fitness2.adjusted_fitness);
-#ifdef BLT_TRACK_ALLOCATIONS
-                tracker.stop_measurement_thread_local(state);
-                crossover_calls.call();
-                if (state.getAllocatedByteDifference() != 0)
-                {
-                    crossover_allocations.call(state.getAllocatedByteDifference());
-                    crossover_allocations.set_value(std::max(crossover_allocations.get_value(), state.getAllocatedByteDifference()));
-                }
-#endif
-                return 2;
-            }
-            break;
-        case 1:
-            if (random.choice(config.mutation_chance))
-            {
-#ifdef BLT_TRACK_ALLOCATIONS
-                auto state = tracker.start_measurement_thread_local();
-#endif
-                // mutation
-                const tree_t* p;
-                do
-                {
-                    p = &mutation_selection.select(program, current_pop);
-                    c1.copy_fast(*p);
-#ifdef BLT_TRACK_ALLOCATIONS
-                    mutation_calls.value(1);
-#endif
-                }
-                while (!config.mutator.get().apply(program, *p, c1));
-#ifdef BLT_TRACK_ALLOCATIONS
-                tracker.stop_measurement_thread_local(state);
-                mutation_calls.call();
-                if (state.getAllocationDifference() != 0)
-                {
-                    mutation_allocations.call(state.getAllocatedByteDifference());
-                    mutation_allocations.set_value(std::max(mutation_allocations.get_value(), state.getAllocatedByteDifference()));
-                }
-#endif
-                return 1;
-            }
-            break;
-        case 2:
-            if (config.reproduction_chance > 0 && random.choice(config.reproduction_chance))
-            {
-#ifdef BLT_TRACK_ALLOCATIONS
-                auto state = tracker.start_measurement_thread_local();
-#endif
-                // reproduction
-                c1.copy_fast(reproduction_selection.select(program, current_pop));
-#ifdef BLT_TRACK_ALLOCATIONS
-                tracker.stop_measurement_thread_local(state);
-                reproduction_calls.call();
-                reproduction_calls.value(1);
-                if (state.getAllocationDifference() != 0)
-                {
-                    reproduction_allocations.call(state.getAllocatedByteDifference());
-                    reproduction_allocations.set_value(std::max(reproduction_allocations.get_value(), state.getAllocatedByteDifference()));
-                }
-#endif
-                return 1;
-            }
-            break;
-        default:
-#if BLT_DEBUG_LEVEL > 0
-                BLT_ABORT("This is not possible!");
-#else
-            BLT_UNREACHABLE;
-#endif
-        }
-        return 0;
-    };
+    }
 
     class selection_t
     {

include/blt/gp/stack.h

@@ -42,11 +42,12 @@ namespace blt::gp
     namespace detail
     {
         BLT_META_MAKE_FUNCTION_CHECK(drop);
+        // BLT_META_MAKE_FUNCTION_CHECK(drop_ephemeral);
     }
 
     class stack_allocator
     {
-        constexpr static blt::size_t PAGE_SIZE = 0x100;
+        constexpr static size_t PAGE_SIZE = 0x100;
         template <typename T>
         using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
         using Allocator = aligned_allocator;
@@ -87,7 +88,7 @@ namespace blt::gp
         {
             const auto bytes = detail::aligned_size(sizeof(NO_REF_T<T>));
             if constexpr (blt::gp::detail::has_func_drop_v<T>)
-                return bytes + aligned_size<size_t*>();
+                return bytes + detail::aligned_size(sizeof(std::atomic_uint64_t*));
             return bytes;
         }
 
@@ -132,8 +133,9 @@ namespace blt::gp
             bytes_stored += stack.bytes_stored;
         }
 
-        void copy_from(const stack_allocator& stack, blt::size_t bytes)
+        void copy_from(const stack_allocator& stack, const size_t bytes)
         {
+            // TODO: add debug checks to these functions! (check for out of bounds copy)
             if (bytes == 0)
                 return;
             if (bytes + bytes_stored > size_)
@@ -142,6 +144,16 @@ namespace blt::gp
             bytes_stored += bytes;
         }
 
+        void copy_from(const stack_allocator& stack, const size_t bytes, const size_t offset)
+        {
+            if (bytes == 0)
+                return;
+            if (bytes + bytes_stored > size_)
+                expand(bytes + size_);
+            std::memcpy(data_ + bytes_stored, stack.data_ + (stack.bytes_stored - bytes - offset), bytes);
+            bytes_stored += bytes;
+        }
+
         void copy_from(const u8* data, const size_t bytes)
         {
             if (bytes == 0 || data == nullptr)
@@ -164,8 +176,13 @@ namespace blt::gp
         {
             static_assert(std::is_trivially_copyable_v<NO_REF>, "Type must be bitwise copyable!");
             static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT, "Type alignment must not be greater than the max alignment!");
-            const auto ptr = allocate_bytes_for_size(aligned_size<NO_REF>());
+            const auto ptr = static_cast<char*>(allocate_bytes_for_size(aligned_size<NO_REF>()));
             std::memcpy(ptr, &t, sizeof(NO_REF));
+
+            if constexpr (gp::detail::has_func_drop_v<T>)
+            {
+                new(ptr + sizeof(NO_REF)) mem::pointer_storage<std::atomic_uint64_t>{nullptr};
+            }
         }
 
         template <typename T, typename NO_REF = NO_REF_T<T>>
@@ -176,7 +193,7 @@ namespace blt::gp
             constexpr auto size = aligned_size<NO_REF>();
 #if BLT_DEBUG_LEVEL > 0
             if (bytes_stored < size)
-                BLT_ABORT("Not enough bytes left to pop!");
+                throw std::runtime_error(("Not enough bytes left to pop!" __FILE__ ":") + std::to_string(__LINE__));
 #endif
             bytes_stored -= size;
             return *reinterpret_cast<T*>(data_ + bytes_stored);
@@ -186,20 +203,48 @@ namespace blt::gp
         {
 #if BLT_DEBUG_LEVEL > 0
             if (bytes_stored < bytes)
-                BLT_ABORT(("Not enough bytes in stack to reference " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
-                " bytes stored!").c_str());
+                throw std::runtime_error(
+                    "Not enough bytes in stack! " + std::to_string(bytes) + " bytes requested but only " + std::to_string(bytes_stored) +
+                    (" bytes stored! (at " __FILE__ ":") + std::to_string(__LINE__));
 #endif
             return data_ + (bytes_stored - bytes);
         }
 
         template <typename T, typename NO_REF = NO_REF_T<T>>
-        T& from(const size_t bytes)
+        T& from(const size_t bytes) const
         {
             static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
             static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!");
             return *reinterpret_cast<NO_REF*>(from(aligned_size<NO_REF>() + bytes));
         }
 
+        [[nodiscard]] std::pair<u8*, mem::pointer_storage<std::atomic_uint64_t>&> access_pointer(const size_t bytes, const size_t type_size) const
+        {
+            const auto type_ref = from(bytes);
+            return {type_ref, *std::launder(
+                reinterpret_cast<mem::pointer_storage<std::atomic_uint64_t>*>(type_ref + (type_size - detail::aligned_size(
+                    sizeof(std::atomic_uint64_t*)))))};
+        }
+
+        [[nodiscard]] std::pair<u8*, mem::pointer_storage<std::atomic_uint64_t>&> access_pointer_forward(const size_t bytes, const size_t type_size) const
+        {
+            const auto type_ref = data_ + bytes;
+            return {type_ref, *std::launder(
+                reinterpret_cast<mem::pointer_storage<std::atomic_uint64_t>*>(type_ref + (type_size - detail::aligned_size(
+                    sizeof(std::atomic_uint64_t*)))))};
+        }
+
+        template <typename T>
+        [[nodiscard]] std::pair<T&, mem::pointer_storage<std::atomic_uint64_t>&> access_pointer(const size_t bytes) const
+        {
+            auto& type_ref = from<T>(bytes);
+            return {
+                type_ref, *std::launder(
+                    reinterpret_cast<mem::pointer_storage<std::atomic_uint64_t>*>(reinterpret_cast<char*>(&type_ref) +
+                        detail::aligned_size(sizeof(T))))
+            };
+        }
+
         void pop_bytes(const size_t bytes)
         {
 #if BLT_DEBUG_LEVEL > 0
@@ -215,23 +260,25 @@ namespace blt::gp
         {
 #if BLT_DEBUG_LEVEL > 0
             if (bytes_stored < aligned_bytes)
-                BLT_ABORT(("Not enough bytes in stack to transfer " + std::to_string(aligned_bytes) + " bytes requested but " + std::to_string(aligned_bytes) +
-                " bytes stored!").c_str());
+                BLT_ABORT(
+                ("Not enough bytes in stack to transfer " + std::to_string(aligned_bytes) + " bytes requested but " + std::to_string(aligned_bytes) +
+                    " bytes stored!").c_str());
             gp::detail::check_alignment(aligned_bytes);
 #endif
             to.copy_from(*this, aligned_bytes);
             pop_bytes(aligned_bytes);
         }
 
-        template <typename... Args>
-        void call_destructors()
-        {
-            if constexpr (sizeof...(Args) > 0)
-            {
-                size_t offset = (aligned_size<NO_REF_T<Args>>() + ...) - aligned_size<NO_REF_T<typename meta::arg_helper<Args...>::First>>();
-                ((call_drop<Args>(offset), offset -= aligned_size<NO_REF_T<Args>>()), ...);
-            }
-        }
+        // template <typename... Args>
+        // void call_destructors()
+        // {
+        //     if constexpr (sizeof...(Args) > 0)
+        //     {
+        //         size_t offset = (aligned_size<NO_REF_T<Args>>() + ...) - aligned_size<NO_REF_T<typename meta::arg_helper<Args...>::First>>();
+        //         ((call_drop<Args>(offset + (gp::detail::has_func_drop_v<Args> ? sizeof(u64*) : 0)), offset -= aligned_size<NO_REF_T<Args>>()), ...);
+        //         (void) offset;
+        //     }
+        // }
 
         [[nodiscard]] bool empty() const noexcept
         {
@@ -330,14 +377,14 @@ namespace blt::gp
             return aligned_ptr;
         }
 
-        template <typename T>
-        void call_drop(const size_t offset)
-        {
-            if constexpr (blt::gp::detail::has_func_drop_v<T>)
-            {
-                from<NO_REF_T<T>>(offset).drop();
-            }
-        }
+        // template <typename T>
+        // void call_drop(const size_t offset)
+        // {
+        //     if constexpr (blt::gp::detail::has_func_drop_v<T>)
+        //     {
+        //         from<NO_REF_T<T>>(offset).drop();
+        //     }
+        // }
 
         u8* data_ = nullptr;
         // place in the data_ array which has a free spot.

include/blt/gp/threading.h

@@ -0,0 +1,241 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_GP_THREADING_H
+#define BLT_GP_THREADING_H
+
+#include <blt/std/types.h>
+#include <blt/std/thread.h>
+#include <thread>
+#include <functional>
+#include <atomic>
+#include <type_traits>
+
+namespace blt::gp
+{
+    namespace detail
+    {
+        struct empty_callable
+        {
+            void operator()() const
+            {
+            }
+        };
+    }
+
+    template <typename EnumId>
+    class task_builder_t;
+
+    template <typename EnumId, typename Parallel, typename Single = detail::empty_callable>
+    class task_t
+    {
+        static_assert(std::is_enum_v<EnumId>, "Enum ID must be of enum type!");
+        static_assert(std::is_invocable_v<Parallel, int>, "Parallel must be invocable with exactly one argument (thread index)");
+        static_assert(std::is_invocable_v<Single>, "Single must be invocable with no arguments");
+
+        friend task_builder_t<EnumId>;
+
+    public:
+        task_t(const EnumId task_id, const Parallel& parallel, const Single& single): parallel(std::forward<Parallel>(parallel)),
+                                                                                      single(std::forward<Single>(single)),
+                                                                                      requires_single_sync(true), task_id(task_id)
+        {
+        }
+
+        explicit task_t(const EnumId task_id, const Parallel& parallel): parallel(std::forward<Parallel>(parallel)), single(detail::empty_callable{}),
+                                                                         task_id(task_id)
+        {
+        }
+
+        void call_parallel(size_t thread_index) const
+        {
+            parallel(thread_index);
+        }
+
+        void call_single() const
+        {
+            single();
+        }
+
+        [[nodiscard]] EnumId get_task_id() const
+        {
+            return task_id;
+        }
+
+    private:
+        const Parallel& parallel;
+        const Single& single;
+        bool requires_single_sync = false;
+        EnumId task_id;
+    };
+
+    template <typename EnumId, typename Parallel, typename Single = detail::empty_callable>
+    task_t(EnumId, Parallel, Single) -> task_t<EnumId, Parallel, Single>;
+
+    template <typename EnumId>
+    class task_builder_t
+    {
+        static_assert(std::is_enum_v<EnumId>, "Enum ID must be of enum type!");
+        using EnumInt = std::underlying_type_t<EnumId>;
+
+    public:
+        task_builder_t() = default;
+
+        template <typename... Tasks>
+        static std::function<void(barrier&, EnumId, size_t)> make_callable(Tasks&&... tasks)
+        {
+            return [&tasks...](barrier& sync_barrier, EnumId task, size_t thread_index)
+            {
+                call_jmp_table(sync_barrier, task, thread_index, tasks...);
+            };
+        }
+
+    private:
+        template <typename Task>
+        static void execute(barrier& sync_barrier, const size_t thread_index, Task&& task)
+        {
+            // sync_barrier.wait();
+            if (task.requires_single_sync)
+            {
+                if (thread_index == 0)
+                    task.call_single();
+                sync_barrier.wait();
+            }
+            task.call_parallel(thread_index);
+            // sync_barrier.wait();
+        }
+
+        template <typename Task>
+        static bool call(barrier& sync_barrier, const EnumId current_task, const size_t thread_index, Task&& task)
+        {
+            if (static_cast<EnumInt>(current_task) == static_cast<EnumInt>(task.get_task_id()))
+            {
+                execute(sync_barrier, thread_index, std::forward<Task>(task));
+                return false;
+            }
+            return true;
+        }
+
+        template <typename... Tasks>
+        static void call_jmp_table(barrier& sync_barrier, const EnumId current_task, const size_t thread_index, Tasks&&... tasks)
+        {
+            if (static_cast<EnumInt>(current_task) >= sizeof...(tasks))
+                BLT_UNREACHABLE;
+            (call(sync_barrier, current_task, thread_index, std::forward<Tasks>(tasks)) && ...);
+        }
+    };
+
+    template <typename EnumId>
+    class thread_manager_t
+    {
+        static_assert(std::is_enum_v<EnumId>, "Enum ID must be of enum type!");
+
+    public:
+        explicit thread_manager_t(const size_t thread_count, std::function<void(barrier&, EnumId, size_t)> task_func,
+                                  const bool will_main_block = true): barrier(thread_count), will_main_block(will_main_block)
+        {
+            thread_callable = [this, task_func = std::move(task_func)](const size_t thread_index)
+            {
+                while (should_run)
+                {
+                    barrier.wait();
+                    if (tasks_remaining > 0)
+                        task_func(barrier, tasks.back(), thread_index);
+                    barrier.wait();
+                    if (thread_index == 0)
+                    {
+                        if (this->will_main_block)
+                        {
+                            tasks.pop_back();
+                            --tasks_remaining;
+                        }
+                        else
+                        {
+                            std::scoped_lock lock{task_lock};
+                            tasks.pop_back();
+                            --tasks_remaining;
+                        }
+                    }
+                }
+            };
+            for (size_t i = 0; i < will_main_block ? thread_count - 1 : thread_count; ++i)
+                threads.emplace_back(thread_callable, will_main_block ? i + 1 : i);
+        }
+
+        void execute() const
+        {
+            BLT_ASSERT(will_main_block &&
+                "You attempted to call this function without specifying that "
+                "you want an external blocking thread (try passing will_main_block = true)");
+            thread_callable(0);
+        }
+
+        void add_task(EnumId task)
+        {
+            if (will_main_block)
+            {
+                tasks.push_back(task);
+                ++tasks_remaining;
+            }
+            else
+            {
+                std::scoped_lock lock(task_lock);
+                tasks.push_back(task);
+                ++tasks_remaining;
+            }
+        }
+
+        bool has_tasks_left()
+        {
+            if (will_main_block)
+            {
+                return !tasks.empty();
+            }
+            std::scoped_lock lock{task_lock};
+            return tasks.empty();
+        }
+
+        ~thread_manager_t()
+        {
+            should_run = false;
+            for (auto& thread : threads)
+            {
+                if (thread.joinable())
+                    thread.join();
+            }
+        }
+
+    private:
+        [[nodiscard]] size_t thread_count() const
+        {
+            return will_main_block ? threads.size() + 1 : threads.size();
+        }
+
+        blt::barrier barrier;
+        std::atomic_bool should_run = true;
+        bool will_main_block;
+        std::vector<EnumId> tasks;
+        std::atomic_uint64_t tasks_remaining = 0;
+        std::vector<std::thread> threads;
+        std::mutex task_lock;
+
+        std::function<void(size_t)> thread_callable;
+    };
+}
+
+#endif //BLT_GP_THREADING_H

include/blt/gp/transformers.h

@@ -30,16 +30,16 @@ namespace blt::gp
 {
     namespace detail
     {
-        template<typename T>
+        template <typename T>
         inline static constexpr double sum(const T& array)
         {
             double init = 0.0;
-            for (double i : array)
+            for (const double i : array)
                 init += i;
             return init;
         }
-        
-        template<blt::size_t size, typename... Args>
+
+        template <size_t size, typename... Args>
         static constexpr std::array<double, size> aggregate_array(Args... list)
         {
             std::array<double, size> data{list...};
@@ -54,140 +54,151 @@ namespace blt::gp
             return data;
         }
     }
-    
+
     class crossover_t
     {
-        public:
-            struct point_info_t
-            {
-                ptrdiff_t point;
-                operator_info_t& type_operator_info;
-            };
-            struct crossover_point_t
-            {
-                ptrdiff_t p1_crossover_point;
-                ptrdiff_t p2_crossover_point;
-            };
-            struct config_t
-            {
-                // number of times crossover will try to pick a valid point in the tree. this is purely based on the return type of the operators
-                u32 max_crossover_tries = 5;
-                // if tree have fewer nodes than this number, they will not be considered for crossover
-                // should be at least 5 as crossover will not select the root node.
-                u32 min_tree_size = 5;
-                // used by the traverse version of get_crossover_point
-                // at each depth level, what chance do we have to exit with this as our point? or in other words what's the chance we continue traversing
-                // this is what this option configures.
-                f32 traverse_chance = 0.5;
-                // how often should we select terminals over functions. By default, we only allow selection of terminals 10% of the time
-                // this applies to both types of crossover point functions. Traversal will use the parent if it should not pick a terminal.
-                f32 terminal_chance = 0.1;
-                // use traversal to select point instead of random selection
-                bool traverse = false;
-            };
-            
-            crossover_t() = default;
-            
-            explicit crossover_t(const config_t& config): config(config)
-            {}
-            
-            std::optional<crossover_point_t> get_crossover_point(gp_program& program, const tree_t& c1, const tree_t& c2) const;
-            
-            std::optional<crossover_point_t> get_crossover_point_traverse(gp_program& program, const tree_t& c1, const tree_t& c2) const;
-            
-            std::optional<point_info_t> get_point_from_traverse_raw(gp_program& program, const tree_t& t, std::optional<type_id> type) const;
-            
-            /**
-             * child1 and child2 are copies of the parents, the result of selecting a crossover point and performing standard subtree crossover.
-             * the parents are not modified during this process
-             * @param program reference to the global program container responsible for managing these trees
-             * @param p1 reference to the first parent
-             * @param p2 reference to the second parent
-             * @return expected pair of child otherwise returns error enum
-             */
-            virtual bool apply(gp_program& program, const tree_t& p1, const tree_t& p2, tree_t& c1, tree_t& c2); // NOLINT
-            
-            virtual ~crossover_t() = default;
-        
-        protected:
-            std::optional<point_info_t> get_point_traverse_retry(gp_program& program, const tree_t& t, std::optional<type_id> type) const;
-            
-            config_t config;
+    public:
+        struct point_info_t
+        {
+            ptrdiff_t point;
+            operator_info_t& type_operator_info;
+        };
+
+        struct crossover_point_t
+        {
+            tree_t::subtree_point_t p1_crossover_point;
+            tree_t::subtree_point_t p2_crossover_point;
+        };
+
+        struct config_t
+        {
+            // number of times crossover will try to pick a valid point in the tree. this is purely based on the return type of the operators
+            u32 max_crossover_tries = 5;
+            // how many times the crossover function can fail before we will skip this operation.
+            u32 max_crossover_iterations = 10;
+            // if tree have fewer nodes than this number, they will not be considered for crossover
+            // should be at least 5 as crossover will not select the root node.
+            u32 min_tree_size = 5;
+            // used by the traverse version of get_crossover_point
+            // at each depth level, what chance do we have to exit with this as our point? or in other words what's the chance we continue traversing
+            // this is what this option configures.
+            f32 depth_multiplier = 0.5;
+            // how often should we select terminals over functions. By default, we only allow selection of terminals 10% of the time
+            // this applies to both types of crossover point functions. Traversal will use the parent if it should not pick a terminal.
+            f32 terminal_chance = 0.1;
+            // use traversal to select point instead of random selection
+            bool traverse = false;
+        };
+
+        crossover_t() = default;
+
+        explicit crossover_t(const config_t& config): config(config)
+        {
+        }
+
+        [[nodiscard]] const config_t& get_config() const
+        {
+            return config;
+        }
+
+        std::optional<crossover_point_t> get_crossover_point(const tree_t& c1, const tree_t& c2) const;
+
+        std::optional<crossover_point_t> get_crossover_point_traverse(const tree_t& c1, const tree_t& c2) const;
+
+        /**
+         * child1 and child2 are copies of the parents, the result of selecting a crossover point and performing standard subtree crossover.
+         * the parents are not modified during this process
+         * @param program reference to the global program container responsible for managing these trees
+         * @param p1 reference to the first parent
+         * @param p2 reference to the second parent
+         * @return expected pair of child otherwise returns error enum
+         */
+        virtual bool apply(gp_program& program, const tree_t& p1, const tree_t& p2, tree_t& c1, tree_t& c2); // NOLINT
+
+        virtual ~crossover_t() = default;
+
+    protected:
+        [[nodiscard]] std::optional<tree_t::subtree_point_t> get_point_traverse_retry(const tree_t& t, std::optional<type_id> type) const;
+
+        config_t config;
     };
-    
+
     class mutation_t
     {
-        public:
-            struct config_t
+    public:
+        struct config_t
+        {
+            blt::size_t replacement_min_depth = 2;
+            blt::size_t replacement_max_depth = 6;
+
+            std::reference_wrapper<tree_generator_t> generator;
+
+            config_t(tree_generator_t& generator): generator(generator) // NOLINT
             {
-                blt::size_t replacement_min_depth = 2;
-                blt::size_t replacement_max_depth = 6;
-                
-                std::reference_wrapper<tree_generator_t> generator;
-                
-                config_t(tree_generator_t& generator): generator(generator) // NOLINT
-                {}
-                
-                config_t();
-            };
-            
-            mutation_t() = default;
-            
-            explicit mutation_t(const config_t& config): config(config)
-            {}
-            
-            virtual bool apply(gp_program& program, const tree_t& p, tree_t& c);
-            
-            // returns the point after the mutation
-            blt::size_t mutate_point(gp_program& program, tree_t& c, blt::size_t node) const;
-            
-            virtual ~mutation_t() = default;
-        
-        protected:
-            config_t config;
+            }
+
+            config_t();
+        };
+
+        mutation_t() = default;
+
+        explicit mutation_t(const config_t& config): config(config)
+        {
+        }
+
+        virtual bool apply(gp_program& program, const tree_t& p, tree_t& c);
+
+        // returns the point after the mutation
+        size_t mutate_point(gp_program& program, tree_t& c, tree_t::subtree_point_t node) const;
+
+        virtual ~mutation_t() = default;
+
+    protected:
+        config_t config;
     };
-    
+
     class advanced_mutation_t : public mutation_t
     {
-        public:
-            enum class mutation_operator : blt::i32
-            {
-                EXPRESSION,     // Generate a new random expression
-                ADJUST,         // adjust the value of the type. (if it is a function it will mutate it to a different one)
-                SUB_FUNC,       // subexpression becomes argument to new random function. Other args are generated.
-                JUMP_FUNC,      // subexpression becomes this new node. Other arguments discarded.
-                COPY,           // node can become copy of another subexpression.
-                END,            // helper
-            };
-            
-            advanced_mutation_t() = default;
-            
-            explicit advanced_mutation_t(const config_t& config): mutation_t(config)
-            {}
-            
-            bool apply(gp_program& program, const tree_t& p, tree_t& c) final;
-            
-            advanced_mutation_t& set_per_node_mutation_chance(double v)
-            {
-                per_node_mutation_chance = v;
-                return *this;
-            }
-        
-        private:
-            static constexpr auto operators_size = static_cast<blt::i32>(mutation_operator::END);
-        private:
-            // this value is adjusted inversely to the size of the tree.
-            double per_node_mutation_chance = 5.0;
-            
-            static constexpr std::array<double, operators_size> mutation_operator_chances = detail::aggregate_array<operators_size>(
-                    0.25,       // EXPRESSION
-                    0.15,       // ADJUST
-                    0.01,       // SUB_FUNC
-                    0.01,       // JUMP_FUNC
-                    0.05        // COPY
-                                                                                                                                   );
+    public:
+        enum class mutation_operator : i32
+        {
+            EXPRESSION, // Generate a new random expression
+            ADJUST, // adjust the value of the type. (if it is a function it will mutate it to a different one)
+            SUB_FUNC, // subexpression becomes argument to new random function. Other args are generated.
+            JUMP_FUNC, // subexpression becomes this new node. Other arguments discarded.
+            COPY, // node can become copy of another subexpression.
+            END, // helper
+        };
+
+        advanced_mutation_t() = default;
+
+        explicit advanced_mutation_t(const config_t& config): mutation_t(config)
+        {
+        }
+
+        bool apply(gp_program& program, const tree_t& p, tree_t& c) final;
+
+        advanced_mutation_t& set_per_node_mutation_chance(double v)
+        {
+            per_node_mutation_chance = v;
+            return *this;
+        }
+
+    private:
+        static constexpr auto operators_size = static_cast<blt::i32>(mutation_operator::END);
+
+    private:
+        // this value is adjusted inversely to the size of the tree.
+        double per_node_mutation_chance = 5.0;
+
+        static constexpr std::array<double, operators_size> mutation_operator_chances = detail::aggregate_array<operators_size>(
+            0.25, // EXPRESSION
+            0.20, // ADJUST
+            0.05, // SUB_FUNC
+            0.15, // JUMP_FUNC
+            0.10 // COPY
+        );
     };
-    
 }
 
 #endif //BLT_GP_TRANSFORMERS_H

include/blt/gp/typesystem.h

@@ -30,108 +30,116 @@
 
 namespace blt::gp
 {
-    struct operator_id : integer_type<blt::u64>
+    struct operator_id : integer_type<u64>
     {
-        using integer_type<blt::u64>::integer_type;
+        using integer_type::integer_type;
     };
-    
-    struct type_id : integer_type<blt::u64>
+
+    struct type_id : integer_type<u64>
     {
-        using integer_type<blt::u64>::integer_type;
+        using integer_type::integer_type;
     };
-    
+
     class type
     {
-        public:
-            type() = default;
-            
-            template<typename T>
-            static type make_type(const type_id id)
-            {
-                return type(stack_allocator::aligned_size<T>(), id, blt::type_string<T>());
-            }
-            
-            [[nodiscard]] inline blt::size_t size() const
-            {
-                return size_;
-            }
-            
-            [[nodiscard]] inline type_id id() const
-            {
-                return id_;
-            }
-            
-            [[nodiscard]] inline std::string_view name() const
-            {
-                return name_;
-            }
-        
-        private:
-            type(size_t size, type_id id, std::string_view name): size_(size), id_(id), name_(name)
-            {}
-            
-            blt::size_t size_{};
-            type_id id_{};
-            std::string name_{};
+    public:
+        type() = default;
+
+        template <typename T>
+        static type make_type(const type_id id)
+        {
+            return type(stack_allocator::aligned_size<T>(), id, blt::type_string<T>(), detail::has_func_drop_v<T>);
+        }
+
+        [[nodiscard]] size_t size() const
+        {
+            return size_;
+        }
+
+        [[nodiscard]] type_id id() const
+        {
+            return id_;
+        }
+
+        [[nodiscard]] std::string_view name() const
+        {
+            return name_;
+        }
+
+        [[nodiscard]] bool has_ephemeral_drop() const
+        {
+            return has_ephemeral_drop_;
+        }
+    private:
+        type(const size_t size, const type_id id, const std::string_view name, const bool has_ephemeral_drop): size_(size), id_(id), name_(name),
+            has_ephemeral_drop_(has_ephemeral_drop)
+        {
+        }
+
+        size_t size_{};
+        type_id id_{};
+        std::string name_{};
+        bool has_ephemeral_drop_ = false;
     };
-    
+
     /**
      * Is a provider for the set of types possible in a GP program
      * also provides a set of functions for converting between C++ types and BLT GP types
      */
     class type_provider
     {
-        public:
-            type_provider() = default;
-            
-            template<typename T>
-            inline void register_type()
-            {
-                if (has_type<T>())
-                    return;
-                auto t = type::make_type<T>(types.size());
-                types.insert({blt::type_string_raw<T>(), t});
-                types_from_id[t.id()] = t;
-            }
-            
-            template<typename T>
-            inline type get_type()
-            {
-                return types[blt::type_string_raw<T>()];
-            }
-            
-            template<typename T>
-            inline bool has_type(){
-                return types.find(blt::type_string_raw<T>()) != types.end();
-            }
-            
-            inline type get_type(type_id id)
-            {
-                return types_from_id[id];
-            }
-            
-            /**
-             * This function is slow btw
-             * @param engine
-             * @return
-             */
-            inline type select_type(std::mt19937_64& engine)
-            {
-                std::uniform_int_distribution dist(0ul, types.size() - 1);
-                auto offset = dist(engine);
-                auto itr = types.begin();
-                for ([[maybe_unused]] auto _ : blt::range(0ul, offset))
-                    itr = itr++;
-                return itr->second;
-            }
-        
-        private:
-            blt::hashmap_t<std::string, type> types;
-            blt::expanding_buffer<type> types_from_id;
+    public:
+        type_provider() = default;
+
+        template <typename T>
+        void register_type()
+        {
+            if (has_type<T>())
+                return;
+            auto t = type::make_type<T>(types.size());
+            types.insert({blt::type_string_raw<T>(), t});
+            types_from_id[t.id()] = t;
+        }
+
+        template <typename T>
+        type get_type()
+        {
+            return types[blt::type_string_raw<T>()];
+        }
+
+        template <typename T>
+        bool has_type()
+        {
+            return types.find(blt::type_string_raw<T>()) != types.end();
+        }
+
+        type get_type(type_id id)
+        {
+            return types_from_id[id];
+        }
+
+        /**
+         * This function is slow btw
+         * @param engine
+         * @return
+         */
+        type select_type(std::mt19937_64& engine)
+        {
+            std::uniform_int_distribution dist(0ul, types.size() - 1);
+            auto offset = dist(engine);
+            auto itr = types.begin();
+            for ([[maybe_unused]] auto _ : blt::range(0ul, offset))
+                itr = itr++;
+            return itr->second;
+        }
+
+    private:
+        hashmap_t<std::string, type> types;
+        expanding_buffer<type> types_from_id;
     };
 }
 
-template<>
+template <>
 struct std::hash<blt::gp::operator_id>
 {
     std::size_t operator()(const blt::gp::operator_id& s) const noexcept
@@ -140,7 +148,7 @@ struct std::hash<blt::gp::operator_id>
     }
 };
 
-template<>
+template <>
 struct std::hash<blt::gp::type_id>
 {
     std::size_t operator()(const blt::gp::type_id& s) const noexcept

include/blt/gp/util/meta.h

@@ -0,0 +1,66 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_GP_UTIL_META_H
+#define BLT_GP_UTIL_META_H
+
+#include <type_traits>
+
+namespace blt::gp::detail
+{
+    template <typename T>
+    using remove_cv_ref = std::remove_cv_t<std::remove_reference_t<T>>;
+
+
+    template <typename...>
+    struct first_arg;
+
+    template <typename First, typename... Args>
+    struct first_arg<First, Args...>
+    {
+        using type = First;
+    };
+
+    template <>
+    struct first_arg<>
+    {
+        using type = void;
+    };
+
+    template <bool b, typename... types>
+    struct is_same;
+
+    template <typename... types>
+    struct is_same<true, types...> : std::false_type
+    {
+    };
+
+    template <typename... types>
+    struct is_same<false, types...> : std::is_same<types...>
+    {
+    };
+
+    template <typename... types>
+    constexpr bool is_same_v = is_same<sizeof...(types) == 0, types...>::value;
+
+    struct empty_t
+    {
+    };
+}
+
+#endif //BLT_GP_UTIL_META_H

lib/blt

@@ -1 +1 @@
-Subproject commit 8133553ed87f705c890c5becda710f72f3ddccb9
+Subproject commit baa5952666594ce0d07a2b013e46c4bc343ba164

main_branch.txt

@@ -1,41 +0,0 @@
- Performance counter stats for './cmake-build-release/blt-symbolic-regression-example' (30 runs):
-
-    81,986,993,284      branches                                                                ( +- 15.89% )  (19.93%)
-       194,632,894      branch-misses                    #    0.24% of all branches             ( +- 21.10% )  (19.84%)
-        32,561,539      cache-misses                     #    0.89% of all cache refs           ( +- 10.21% )  (19.95%)
-     3,645,509,810      cache-references                                                        ( +- 15.93% )  (20.11%)
-   169,957,442,648      cycles                                                                  ( +- 15.85% )  (20.26%)
-   426,558,894,577      instructions                     #    2.51  insn per cycle              ( +- 16.24% )  (20.29%)
-                 0      alignment-faults                                                      
-             9,103      cgroup-switches                                                         ( +- 13.62% )
-            52,586      faults                                                                  ( +-  5.74% )
-     1,823,320,688 ns   duration_time                                                           ( +- 12.76% )
-    41,213,439,537 ns   user_time                                                               ( +-  3.68% )
-       219,435,124 ns   system_time                                                             ( +-  2.44% )
-   132,928,139,347      L1-dcache-loads                                                         ( +- 15.55% )  (20.40%)
-     2,559,138,346      L1-dcache-load-misses            #    1.93% of all L1-dcache accesses   ( +- 15.53% )  (20.37%)
-       852,474,938      L1-dcache-prefetches                                                    ( +- 19.61% )  (20.44%)
-     1,035,909,753      L1-icache-loads                                                         ( +- 11.73% )  (20.45%)
-         1,451,589      L1-icache-load-misses            #    0.14% of all L1-icache accesses   ( +- 13.61% )  (20.50%)
-        37,722,800      dTLB-loads                                                              ( +- 14.93% )  (20.52%)
-         4,119,243      dTLB-load-misses                 #   10.92% of all dTLB cache accesses  ( +- 10.99% )  (20.55%)
-         1,318,136      iTLB-loads                                                              ( +- 20.32% )  (20.51%)
-           367,939      iTLB-load-misses                 #   27.91% of all iTLB cache accesses  ( +- 12.34% )  (20.42%)
-     2,730,214,946      l2_request_g1.all_no_prefetch                                           ( +- 15.32% )  (20.43%)
-            52,586      page-faults                                                             ( +-  5.74% )
-            52,583      page-faults:u                                                           ( +-  5.75% )
-                 3      page-faults:k                                                           ( +-  3.96% )
-   132,786,226,560      L1-dcache-loads                                                         ( +- 15.54% )  (20.33%)
-     2,581,181,694      L1-dcache-load-misses            #    1.94% of all L1-dcache accesses   ( +- 15.34% )  (20.26%)
-   <not supported>      LLC-loads                                                             
-   <not supported>      LLC-load-misses                                                       
-     1,021,814,075      L1-icache-loads                                                         ( +- 11.67% )  (20.19%)
-         1,376,958      L1-icache-load-misses            #    0.13% of all L1-icache accesses   ( +- 13.76% )  (20.09%)
-        38,065,494      dTLB-loads                                                              ( +- 14.76% )  (20.09%)
-         4,174,010      dTLB-load-misses                 #   11.06% of all dTLB cache accesses  ( +- 10.90% )  (20.14%)
-         1,407,386      iTLB-loads                                                              ( +- 20.45% )  (20.09%)
-           338,781      iTLB-load-misses                 #   25.70% of all iTLB cache accesses  ( +- 12.61% )  (20.05%)
-       873,873,406      L1-dcache-prefetches                                                    ( +- 19.41% )  (20.00%)
-   <not supported>      L1-dcache-prefetch-misses                                             
-
-             1.823 +- 0.233 seconds time elapsed  ( +- 12.76% )

src/generators.cpp

@@ -27,8 +27,8 @@ namespace blt::gp
     
     struct stack
     {
-        blt::gp::operator_id id;
-        blt::size_t depth;
+        operator_id id;
+        size_t depth;
     };
     
     inline std::stack<stack> get_initial_stack(gp_program& program, type_id root_type)
@@ -49,10 +49,10 @@ namespace blt::gp
     }
     
     template<typename Func>
-    inline void create_tree(tree_t& tree, Func&& perChild, const generator_arguments& args)
+    void create_tree(tree_t& tree, Func&& perChild, const generator_arguments& args)
     {
         std::stack<stack> tree_generator = get_initial_stack(args.program, args.root_type);
-        blt::size_t max_depth = 0;
+        size_t max_depth = 0;
         
         while (!tree_generator.empty())
         {
@@ -61,17 +61,15 @@ namespace blt::gp
             
             auto& info = args.program.get_operator_info(top.id);
 
-            tree.get_operations().emplace_back(
+            tree.emplace_operator(
                     args.program.get_typesystem().get_type(info.return_type).size(),
                     top.id,
-                    args.program.is_operator_ephemeral(top.id));
+                    args.program.is_operator_ephemeral(top.id),
+                    args.program.get_operator_flags(top.id));
             max_depth = std::max(max_depth, top.depth);
             
             if (args.program.is_operator_ephemeral(top.id))
-            {
-                info.func(nullptr, tree.get_values(), tree.get_values());
                 continue;
-            }
             
             for (const auto& child : info.argument_types)
                 std::forward<Func>(perChild)(args.program, tree_generator, child, top.depth + 1);

src/selection.cpp

@@ -62,7 +62,7 @@ namespace blt::gp
         auto& i_ref = pop.get_individuals();
 
         u64 best = program.get_random().get_u64(0, pop.get_individuals().size());
-        for (size_t i = 0; i < selection_size; i++)
+        for (size_t i = 0; i < std::min(selection_size, pop.get_individuals().size()); i++)
         {
             u64 sel_point;
             do

src/tree.cpp

@@ -24,19 +24,15 @@
 
 namespace blt::gp
 {
-    // this one will copy previous bytes over
-    template<typename T>
-    blt::span<blt::u8> get_pointer_for_size(blt::size_t size)
+    template <typename>
+    static u8* get_thread_pointer_for_size(const size_t bytes)
     {
-        static blt::span<blt::u8> buffer{nullptr, 0};
-        if (buffer.size() < size)
-        {
-            delete[] buffer.data();
-            buffer = {new blt::u8[size], size};
-        }
-        return buffer;
+        thread_local expanding_buffer<u8> buffer;
+        if (bytes > buffer.size())
+            buffer.resize(bytes);
+        return buffer.data();
     }
-    
+
     std::ostream& create_indent(std::ostream& out, blt::size_t amount, bool pretty_print)
     {
         if (!pretty_print)
@@ -45,30 +41,39 @@ namespace blt::gp
             out << '\t';
         return out;
     }
-    
+
     std::string_view end_indent(bool pretty_print)
     {
         return pretty_print ? "\n" : "";
     }
-    
+
     std::string get_return_type(gp_program& program, type_id id, bool use_returns)
     {
         if (!use_returns)
             return "";
         return "(" + std::string(program.get_typesystem().get_type(id).name()) + ")";
     }
-    
-    void tree_t::print(gp_program& program, std::ostream& out, bool print_literals, bool pretty_print, bool include_types) const
+
+    void tree_t::byte_only_transaction_t::move(const size_t bytes_to_move)
+    {
+        bytes = bytes_to_move;
+        data = get_thread_pointer_for_size<struct move_tempoary_bytes>(bytes);
+        tree.values.copy_to(data, bytes);
+        tree.values.pop_bytes(bytes);
+    }
+
+    void tree_t::print(std::ostream& out, const bool print_literals, const bool pretty_print, const bool include_types,
+                       const ptrdiff_t marked_index) const
     {
         std::stack<blt::size_t> arguments_left;
         blt::size_t indent = 0;
-        
+
         stack_allocator reversed;
         if (print_literals)
         {
             // I hate this.
             stack_allocator copy = values;
-            
+
             // reverse the order of the stack
             for (const auto& v : operations)
             {
@@ -76,33 +81,40 @@ namespace blt::gp
                     copy.transfer_bytes(reversed, v.type_size());
             }
         }
-        for (const auto& v : operations)
+        for (const auto& [i, v] : enumerate(operations))
         {
-            auto info = program.get_operator_info(v.id());
-            const auto name = program.get_name(v.id()) ? program.get_name(v.id()).value() : "NULL";
-            auto return_type = get_return_type(program, info.return_type, include_types);
+            auto info = m_program->get_operator_info(v.id());
+            const auto name = m_program->get_name(v.id()) ? m_program->get_name(v.id()).value() : "NULL";
+            auto return_type = get_return_type(*m_program, info.return_type, include_types);
+            if (static_cast<ptrdiff_t>(i) == marked_index)
+            {
+                out << "[ERROR OCCURRED HERE] -> ";
+            }
             if (info.argc.argc > 0)
             {
                 create_indent(out, indent, pretty_print) << "(";
                 indent++;
                 arguments_left.emplace(info.argc.argc);
                 out << name << return_type << end_indent(pretty_print);
-            } else
+            }
+            else
             {
                 if (print_literals)
                 {
                     create_indent(out, indent, pretty_print);
-                    if (program.is_operator_ephemeral(v.id()))
+                    if (m_program->is_operator_ephemeral(v.id()))
                     {
-                        program.get_print_func(v.id())(out, reversed);
+                        m_program->get_print_func(v.id())(out, reversed);
                         reversed.pop_bytes(v.type_size());
-                    } else
+                    }
+                    else
                         out << name;
                     out << return_type << end_indent(pretty_print);
-                } else
+                }
+                else
                     create_indent(out, indent, pretty_print) << name << return_type << end_indent(pretty_print);
             }
-            
+
             while (!arguments_left.empty())
             {
                 auto top = arguments_left.top();
@@ -112,7 +124,8 @@ namespace blt::gp
                     indent--;
                     create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
                     continue;
-                } else
+                }
+                else
                 {
                     if (!pretty_print)
                         out << " ";
@@ -130,20 +143,21 @@ namespace blt::gp
                 indent--;
                 create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
                 continue;
-            } else
+            }
+            else
             {
                 BLT_ERROR("Failed to print tree correctly!");
                 break;
             }
         }
-        
+
         out << '\n';
     }
-    
+
     size_t tree_t::get_depth(gp_program& program) const
     {
         size_t depth = 0;
-        
+
         auto operations_stack = operations;
         thread_local tracked_vector<size_t> values_process;
         thread_local tracked_vector<size_t> value_stack;
@@ -156,7 +170,7 @@ namespace blt::gp
             if (op.is_value())
                 value_stack.push_back(1);
         }
-        
+
         while (!operations_stack.empty())
         {
             auto operation = operations_stack.back();
@@ -177,138 +191,514 @@ namespace blt::gp
                 values_process.pop_back();
             }
             value_stack.push_back(local_depth + 1);
-            operations_stack.emplace_back(operation.type_size(), operation.id(), true);
+            operations_stack.emplace_back(operation.type_size(), operation.id(), true, program.get_operator_flags(operation.id()));
         }
-        
+
         return depth;
     }
-    
-    ptrdiff_t tree_t::find_endpoint(gp_program& program, ptrdiff_t start) const
+
+    tree_t::subtree_point_t tree_t::select_subtree(const double terminal_chance) const
     {
-        i64 children_left = 0;
-        
         do
         {
-            const auto& type = program.get_operator_info(operations[start].id());
+            const auto point = m_program->get_random().get_u64(0, operations.size());
+            const auto& info = m_program->get_operator_info(operations[point].id());
+            if (!info.argc.is_terminal())
+                return {static_cast<ptrdiff_t>(point), info.return_type};
+            if (m_program->get_random().choice(terminal_chance))
+                return {static_cast<ptrdiff_t>(point), info.return_type};
+        }
+        while (true);
+    }
+
+    std::optional<tree_t::subtree_point_t> tree_t::select_subtree(const type_id type, const u32 max_tries, const double terminal_chance) const
+    {
+        for (u32 i = 0; i < max_tries; ++i)
+        {
+            if (const auto tree = select_subtree(terminal_chance); tree.type == type)
+                return tree;
+        }
+        return {};
+    }
+
+    tree_t::subtree_point_t tree_t::select_subtree_traverse(const double terminal_chance, const double depth_multiplier) const
+    {
+        size_t index = 0;
+        double depth = 0;
+        double exit_chance = 0;
+        while (true)
+        {
+            const auto& info = m_program->get_operator_info(operations[index].id());
+            if (info.argc.is_terminal())
+            {
+                if (m_program->get_random().choice(terminal_chance))
+                    return {static_cast<ptrdiff_t>(index), info.return_type};
+                index = 0;
+                depth = 0;
+                exit_chance = 0;
+                continue;
+            }
+            if (m_program->get_random().choice(exit_chance))
+                return {static_cast<ptrdiff_t>(index), info.return_type};
+
+            const auto child = m_program->get_random().get_u32(0, info.argc.argc);
+            index++;
+            for (u32 i = 0; i < child; i++)
+                index = find_endpoint(static_cast<ptrdiff_t>(index));
+
+            ++depth;
+            exit_chance = 1.0 - (1.0 / (1 + depth * depth_multiplier * 0.5));
+        }
+    }
+
+    std::optional<tree_t::subtree_point_t> tree_t::select_subtree_traverse(const type_id type, const u32 max_tries, const double terminal_chance,
+                                                                           const double depth_multiplier) const
+    {
+        for (u32 i = 0; i < max_tries; ++i)
+        {
+            if (const auto tree = select_subtree_traverse(terminal_chance, depth_multiplier); tree.type == type)
+                return tree;
+        }
+        return {};
+    }
+
+    void tree_t::copy_subtree(const subtree_point_t point, const ptrdiff_t extent, tracked_vector<op_container_t>& operators, stack_allocator& stack)
+    {
+        const auto point_begin_itr = operations.begin() + point.pos;
+        const auto point_end_itr = operations.begin() + extent;
+
+        const size_t after_bytes = accumulate_type_sizes(point_end_itr, operations.end());
+
+        const size_t ops = std::distance(point_begin_itr, point_end_itr);
+        operators.reserve(operators.size() + ops);
+        // TODO something better!
+        for (size_t i = 0; i < ops; ++i)
+            operators.emplace_back(0, 0, false, operator_special_flags{});
+        size_t for_bytes = 0;
+        size_t pos = 0;
+        for (auto& it : iterate(point_begin_itr, point_end_itr).rev())
+        {
+            if (it.is_value())
+            {
+                for_bytes += it.type_size();
+                if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                {
+                    auto [_, ptr] = values.access_pointer(for_bytes + after_bytes, it.type_size());
+                    ++*ptr;
+                }
+            }
+            operators[operators.size() - 1 - (pos++)] = it;
+        }
+
+        stack.copy_from(values, for_bytes, after_bytes);
+    }
+
+    void tree_t::swap_subtrees(const subtree_point_t our_subtree, tree_t& other_tree, const subtree_point_t other_subtree)
+    {
+        const auto c1_subtree_begin_itr = operations.begin() + our_subtree.pos;
+        const auto c1_subtree_end_itr = operations.begin() + find_endpoint(our_subtree.pos);
+
+        const auto c2_subtree_begin_itr = other_tree.operations.begin() + other_subtree.pos;
+        const auto c2_subtree_end_itr = other_tree.operations.begin() + other_tree.find_endpoint(other_subtree.pos);
+
+        thread_local tracked_vector<op_container_t> c1_subtree_operators;
+        thread_local tracked_vector<op_container_t> c2_subtree_operators;
+        c1_subtree_operators.clear();
+        c2_subtree_operators.clear();
+
+        c1_subtree_operators.reserve(std::distance(c1_subtree_begin_itr, c1_subtree_end_itr));
+        c2_subtree_operators.reserve(std::distance(c2_subtree_begin_itr, c2_subtree_end_itr));
+
+        // i don't think this is required for swapping values, since the total number of additions is net zero
+        // the tree isn't destroyed at any point.
+
+        size_t c1_subtree_bytes = 0;
+        for (const auto& it : iterate(c1_subtree_begin_itr, c1_subtree_end_itr))
+        {
+            if (it.is_value())
+            {
+                // if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                // {
+                //     auto& ptr = values.access_pointer_forward(for_our_bytes, it.type_size());
+                //     ++*ptr;
+                // }
+                c1_subtree_bytes += it.type_size();
+            }
+            c1_subtree_operators.push_back(it);
+        }
+
+        size_t c2_subtree_bytes = 0;
+        for (const auto& it : iterate(c2_subtree_begin_itr, c2_subtree_end_itr))
+        {
+            if (it.is_value())
+            {
+                // if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                // {
+                //     auto& ptr = values.access_pointer_forward(for_other_bytes, it.type_size());
+                //     ++*ptr;
+                // }
+                c2_subtree_bytes += it.type_size();
+            }
+            c2_subtree_operators.push_back(it);
+        }
+
+        const size_t c1_stack_after_bytes = accumulate_type_sizes(c1_subtree_end_itr, operations.end());
+        const size_t c2_stack_after_bytes = accumulate_type_sizes(c2_subtree_end_itr, other_tree.operations.end());
+        const auto c1_total = static_cast<ptrdiff_t>(c1_stack_after_bytes + c1_subtree_bytes);
+        const auto c2_total = static_cast<ptrdiff_t>(c2_stack_after_bytes + c2_subtree_bytes);
+        const auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
+        const auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
+
+        values.reserve(values.bytes_in_head() - c1_subtree_bytes + c2_subtree_bytes);
+        other_tree.values.reserve(other_tree.values.bytes_in_head() - c2_subtree_bytes + c1_subtree_bytes);
+
+        values.copy_to(copy_ptr_c1, c1_total);
+        values.pop_bytes(c1_total);
+
+        other_tree.values.copy_to(copy_ptr_c2, c2_total);
+        other_tree.values.pop_bytes(c2_total);
+
+        other_tree.values.copy_from(copy_ptr_c1, c1_subtree_bytes);
+        other_tree.values.copy_from(copy_ptr_c2 + c2_subtree_bytes, c2_stack_after_bytes);
+
+        values.copy_from(copy_ptr_c2, c2_subtree_bytes);
+        values.copy_from(copy_ptr_c1 + c1_subtree_bytes, c1_stack_after_bytes);
+
+        // now swap the operators
+        // auto insert_point_c1 = c1_subtree_begin_itr - 1;
+        // auto insert_point_c2 = c2_subtree_begin_itr - 1;
+
+        // invalidates [begin, end()) so the insert points should be fine
+        auto insert_point_c1 = operations.erase(c1_subtree_begin_itr, c1_subtree_end_itr);
+        auto insert_point_c2 = other_tree.operations.erase(c2_subtree_begin_itr, c2_subtree_end_itr);
+
+        operations.insert(insert_point_c1, c2_subtree_operators.begin(), c2_subtree_operators.end());
+        other_tree.operations.insert(insert_point_c2, c1_subtree_operators.begin(), c1_subtree_operators.end());
+    }
+
+    void tree_t::replace_subtree(const subtree_point_t point, const ptrdiff_t extent, tree_t& other_tree)
+    {
+        const auto point_begin_itr = operations.begin() + point.pos;
+        const auto point_end_itr = operations.begin() + extent;
+
+        const size_t after_bytes = accumulate_type_sizes(point_end_itr, operations.end());
+
+        size_t for_bytes = 0;
+        for (auto& it : iterate(point_begin_itr, point_end_itr).rev())
+        {
+            if (it.is_value())
+            {
+                for_bytes += it.type_size();
+                if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                {
+                    auto [val, ptr] = values.access_pointer(for_bytes + after_bytes, it.type_size());
+                    --*ptr;
+                    if (*ptr == 0)
+                        handle_ptr_empty(ptr, val, it.id());
+                }
+            }
+        }
+        auto insert = operations.erase(point_begin_itr, point_end_itr);
+
+        const auto ptr = get_thread_pointer_for_size<struct replace>(after_bytes);
+        values.copy_to(ptr, after_bytes);
+        values.pop_bytes(after_bytes + for_bytes);
+
+        size_t copy_bytes = 0;
+        for (const auto& v : other_tree.operations)
+        {
+            if (v.is_value())
+            {
+                if (v.get_flags().is_ephemeral() && v.has_ephemeral_drop())
+                {
+                    auto [_, pointer] = other_tree.values.access_pointer_forward(copy_bytes, v.type_size());
+                    ++*pointer;
+                }
+                copy_bytes += v.type_size();
+            }
+            insert = ++operations.emplace(insert, v);
+        }
+
+        values.insert(other_tree.values);
+        values.copy_from(ptr, after_bytes);
+    }
+
+    void tree_t::delete_subtree(const subtree_point_t point, const ptrdiff_t extent)
+    {
+        const auto point_begin_itr = operations.begin() + point.pos;
+        const auto point_end_itr = operations.begin() + extent;
+
+        const size_t after_bytes = accumulate_type_sizes(point_end_itr, operations.end());
+
+        size_t for_bytes = 0;
+        for (auto& it : iterate(point_begin_itr, point_end_itr).rev())
+        {
+            if (it.is_value())
+            {
+                for_bytes += it.type_size();
+                if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                {
+                    auto [val, ptr] = values.access_pointer(for_bytes + after_bytes, it.type_size());
+                    --*ptr;
+                    if (*ptr == 0)
+                        handle_ptr_empty(ptr, val, it.id());
+                }
+            }
+        }
+        operations.erase(point_begin_itr, point_end_itr);
+
+        const auto ptr = get_thread_pointer_for_size<struct replace>(after_bytes);
+        values.copy_to(ptr, after_bytes);
+        values.pop_bytes(after_bytes + for_bytes);
+        values.copy_from(ptr, after_bytes);
+    }
+
+    ptrdiff_t tree_t::insert_subtree(const subtree_point_t point, tree_t& other_tree)
+    {
+        const size_t after_bytes = accumulate_type_sizes(operations.begin() + point.pos, operations.end());
+        byte_only_transaction_t transaction{*this, after_bytes};
+
+        auto insert = operations.begin() + point.pos;
+        size_t bytes = 0;
+        for (auto& it : iterate(other_tree.operations).rev())
+        {
+            if (it.is_value())
+            {
+                bytes += it.type_size();
+                if (it.get_flags().is_ephemeral() && it.has_ephemeral_drop())
+                {
+                    auto [_, ptr] = other_tree.values.access_pointer(bytes, it.type_size());
+                    ++*ptr;
+                }
+            }
+            insert = operations.insert(insert, it);
+        }
+        values.insert(other_tree.values);
+
+        return static_cast<ptrdiff_t>(point.pos + other_tree.size());
+    }
+
+
+    ptrdiff_t tree_t::find_endpoint(ptrdiff_t start) const
+    {
+        i64 children_left = 0;
+
+        do
+        {
+            const auto& type = m_program->get_operator_info(operations[start].id());
             // this is a child to someone
             if (children_left != 0)
                 children_left--;
             if (type.argc.argc > 0)
                 children_left += type.argc.argc;
             start++;
-        } while (children_left > 0);
-        
+        }
+        while (children_left > 0);
+
         return start;
     }
-    
-    // this function doesn't work!
-    ptrdiff_t tree_t::find_parent(gp_program& program, ptrdiff_t start) const
+
+    tree_t& tree_t::get_thread_local(gp_program& program)
     {
-        i64 children_left = 0;
-        do
+        thread_local tree_t tree{program};
+        return tree;
+    }
+
+    void tree_t::handle_operator_inserted(const op_container_t& op)
+    {
+        if (m_program->is_operator_ephemeral(op.id()))
         {
-            if (start == 0)
-                return 0;
-            const auto& type = program.get_operator_info(operations[start].id());
-            if (type.argc.argc > 0)
-                children_left -= type.argc.argc;
-            children_left++;
-            if (children_left <= 0)
-                break;
-            --start;
-        } while (true);
-        
-        return start;
+            // Ephemeral values have corresponding insertions into the stack
+            m_program->get_operator_info(op.id()).func(nullptr, values, values);
+            if (m_program->operator_has_ephemeral_drop(op.id()))
+            {
+                auto [_, ptr] = values.access_pointer(op.type_size(), op.type_size());
+                ptr = new std::atomic_uint64_t(1);
+                ptr.bit(0, true);
+            }
+        }
     }
-    
-    bool tree_t::check(gp_program& program, void* context) const
+
+    void tree_t::handle_ptr_empty(const mem::pointer_storage<std::atomic_uint64_t>& ptr, u8* data, const operator_id id) const
     {
-        blt::size_t bytes_expected = 0;
-        auto bytes_size = values.size().total_used_bytes;
-        
-        for (const auto& op : get_operations())
+        m_program->get_destroy_func(id)(detail::destroy_t::RETURN, data);
+        delete ptr.get();
+        // BLT_INFO("Deleting pointer!");
+    }
+
+    evaluation_context& tree_t::evaluate(void* ptr) const
+    {
+        return m_program->get_eval_func()(*this, ptr);
+    }
+
+    bool tree_t::check(void* context) const
+    {
+        size_t bytes_expected = 0;
+        const auto bytes_size = values.size().total_used_bytes;
+
+        for (const auto& op : operations)
         {
             if (op.is_value())
                 bytes_expected += op.type_size();
         }
-        
+
         if (bytes_expected != bytes_size)
         {
-            BLT_WARN_STREAM << "Stack state: " << values.size() << "\n";
-            BLT_WARN("Child tree bytes %ld vs expected %ld, difference: %ld", bytes_size, bytes_expected,
-                     static_cast<blt::ptrdiff_t>(bytes_expected) - static_cast<blt::ptrdiff_t>(bytes_size));
-            BLT_WARN("Amount of bytes in stack doesn't match the number of bytes expected for the operations");
+            BLT_ERROR_STREAM << "Stack state: " << values.size() << "\n";
+            BLT_ERROR("Child tree bytes %ld vs expected %ld, difference: %ld", bytes_size, bytes_expected,
+                      static_cast<ptrdiff_t>(bytes_expected) - static_cast<ptrdiff_t>(bytes_size));
+            BLT_ERROR("Amount of bytes in stack doesn't match the number of bytes expected for the operations");
             return false;
         }
-        
-        // copy the initial values
-        evaluation_context results{};
-        
-        auto value_stack = values;
-        auto& values_process = results.values;
-        
-        blt::size_t total_produced = 0;
-        blt::size_t total_consumed = 0;
 
-        for (const auto& operation : iterate(operations).rev())
+        size_t total_produced = 0;
+        size_t total_consumed = 0;
+        size_t index = 0;
+
+        try
         {
-            if (operation.is_value())
+            // copy the initial values
+            evaluation_context results{};
+
+            auto value_stack = values;
+            auto& values_process = results.values;
+
+            for (const auto& operation : iterate(operations).rev())
             {
-                value_stack.transfer_bytes(values_process, operation.type_size());
-                total_produced += operation.type_size();
-                continue;
+                ++index;
+                if (operation.is_value())
+                {
+                    value_stack.transfer_bytes(values_process, operation.type_size());
+                    total_produced += operation.type_size();
+                    continue;
+                }
+                auto& info = m_program->get_operator_info(operation.id());
+                for (auto& arg : info.argument_types)
+                    total_consumed += m_program->get_typesystem().get_type(arg).size();
+                m_program->get_operator_info(operation.id()).func(context, values_process, values_process);
+                total_produced += m_program->get_typesystem().get_type(info.return_type).size();
+            }
+
+            const auto v1 = results.values.bytes_in_head();
+            const auto v2 = static_cast<ptrdiff_t>(operations.front().type_size());
+
+            // ephemeral don't need to be dropped as there are no copies which matter when checking the tree
+            if (!operations.front().get_flags().is_ephemeral())
+                m_program->get_destroy_func(operations.front().id())(detail::destroy_t::RETURN, results.values.from(operations.front().type_size()));
+            if (v1 != v2)
+            {
+                const auto vd = std::abs(v1 - v2);
+                BLT_ERROR("found %ld bytes expected %ld bytes, total difference: %ld", v1, v2, vd);
+                BLT_ERROR("Total Produced %ld || Total Consumed %ld || Total Difference %ld", total_produced, total_consumed,
+                          std::abs(static_cast<blt::ptrdiff_t>(total_produced) - static_cast<blt::ptrdiff_t>(total_consumed)));
+                return false;
             }
-            auto& info = program.get_operator_info(operation.id());
-            for (auto& arg : info.argument_types)
-                total_consumed += program.get_typesystem().get_type(arg).size();
-            program.get_operator_info(operation.id()).func(context, values_process, values_process);
-            total_produced += program.get_typesystem().get_type(info.return_type).size();
         }
-        
-        const auto v1 = results.values.bytes_in_head();
-        const auto v2 = static_cast<ptrdiff_t>(operations.front().type_size());
-        if (v1 != v2)
+        catch (std::exception& e)
         {
-            const auto vd = std::abs(v1 - v2);
-            BLT_ERROR("found %ld bytes expected %ld bytes, total difference: %ld", v1, v2, vd);
+            BLT_ERROR("Exception occurred \"%s\"", e.what());
             BLT_ERROR("Total Produced %ld || Total Consumed %ld || Total Difference %ld", total_produced, total_consumed,
                       std::abs(static_cast<blt::ptrdiff_t>(total_produced) - static_cast<blt::ptrdiff_t>(total_consumed)));
+            BLT_ERROR("We failed at index %lu", index);
             return false;
         }
         return true;
     }
-    
-    void tree_t::find_child_extends(gp_program& program, tracked_vector<child_t>& vec, const size_t parent_node, const size_t argc) const
+
+    void tree_t::find_child_extends(tracked_vector<child_t>& vec, const size_t parent_node, const size_t argc) const
     {
+        BLT_ASSERT_MSG(vec.empty(), "Vector to find_child_extends should be empty!");
         while (vec.size() < argc)
         {
-            auto current_point = vec.size();
-            child_t prev{};
+            const auto current_point = vec.size();
+            child_t prev; // NOLINT
             if (current_point == 0)
             {
                 // first child.
-                prev = {static_cast<ptrdiff_t>(parent_node + 1),
-                        find_endpoint(program, static_cast<ptrdiff_t>(parent_node + 1))};
+                prev = {
+                    static_cast<ptrdiff_t>(parent_node + 1),
+                    find_endpoint(static_cast<ptrdiff_t>(parent_node + 1))
+                };
                 vec.push_back(prev);
                 continue;
-            } else
-                prev = vec[current_point - 1];
-            child_t next = {prev.end, find_endpoint(program, prev.end)};
+            }
+            prev = vec[current_point - 1];
+            child_t next = {prev.end, find_endpoint(prev.end)};
             vec.push_back(next);
         }
     }
-    
-    tree_t::tree_t(gp_program& program): func(&program.get_eval_func())
-    {
-    
-    }
-    
+
     void tree_t::clear(gp_program& program)
     {
-        auto* f = &program.get_eval_func();
-        if (f != func)
-            func = f;
+        auto* f = &program;
+        if (&program != m_program)
+            m_program = f;
+        size_t total_bytes = 0;
+        for (const auto& op : iterate(operations))
+        {
+            if (op.is_value())
+            {
+                if (op.get_flags().is_ephemeral() && op.has_ephemeral_drop())
+                {
+                    auto [val, ptr] = values.access_pointer_forward(total_bytes, op.type_size());
+                    --*ptr;
+                    if (*ptr == 0)
+                        handle_ptr_empty(ptr, val, op.id());
+                }
+                total_bytes += op.type_size();
+            }
+        }
         operations.clear();
         values.reset();
     }
-}
+
+    void tree_t::insert_operator(const size_t index, const op_container_t& container)
+    {
+        if (container.get_flags().is_ephemeral())
+        {
+            byte_only_transaction_t move{*this, total_value_bytes(index)};
+            handle_operator_inserted(container);
+        }
+        operations.insert(operations.begin() + static_cast<ptrdiff_t>(index), container);
+    }
+
+    tree_t::subtree_point_t tree_t::subtree_from_point(ptrdiff_t point) const
+    {
+        return {point, m_program->get_operator_info(operations[point].id()).return_type};
+    }
+
+    void tree_t::modify_operator(const size_t point, operator_id new_id, std::optional<type_id> return_type)
+    {
+        if (!return_type)
+            return_type = m_program->get_operator_info(new_id).return_type;
+        byte_only_transaction_t move_data{*this};
+        if (operations[point].is_value())
+        {
+            const size_t after_bytes = accumulate_type_sizes(operations.begin() + static_cast<ptrdiff_t>(point) + 1, operations.end());
+            move_data.move(after_bytes);
+            if (operations[point].get_flags().is_ephemeral() && operations[point].has_ephemeral_drop())
+            {
+                auto [val, ptr] = values.access_pointer(operations[point].type_size(), operations[point].type_size());
+                --*ptr;
+                if (*ptr == 0)
+                    handle_ptr_empty(ptr, val, operations[point].id());
+            }
+            values.pop_bytes(operations[point].type_size());
+        }
+        operations[point] = {
+            m_program->get_typesystem().get_type(*return_type).size(),
+            new_id,
+            m_program->is_operator_ephemeral(new_id),
+            m_program->get_operator_flags(new_id)
+        };
+        if (operations[point].get_flags().is_ephemeral())
+        {
+            if (move_data.empty())
+            {
+                const size_t after_bytes = accumulate_type_sizes(operations.begin() + static_cast<ptrdiff_t>(point) + 1, operations.end());
+                move_data.move(after_bytes);
+            }
+            handle_operator_inserted(operations[point]);
+        }
+    }
+}

tests/drop_test.cpp

@@ -0,0 +1,167 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "../examples/symbolic_regression.h"
+#include <blt/gp/program.h>
+#include <blt/std/logging.h>
+
+using namespace blt::gp;
+
+std::atomic_uint64_t normal_construct = 0;
+std::atomic_uint64_t ephemeral_construct = 0;
+std::atomic_uint64_t normal_drop = 0;
+std::atomic_uint64_t ephemeral_drop = 0;
+std::atomic_uint64_t max_allocated = 0;
+
+struct drop_type
+{
+    float* m_value;
+    bool ephemeral = false;
+
+    drop_type() : m_value(new float(0))
+    {
+        ++normal_construct;
+    }
+
+    explicit drop_type(const float silly) : m_value(new float(silly))
+    {
+        ++normal_construct;
+    }
+
+    explicit drop_type(const float silly, bool) : m_value(new float(silly)), ephemeral(true)
+    {
+        // BLT_TRACE("Constructor with value %f", silly);
+        ++ephemeral_construct;
+    }
+
+    [[nodiscard]] float value() const
+    {
+        return *m_value;
+    }
+
+    void drop() const
+    {
+        if (ephemeral)
+        {
+            std::cout << ("Ephemeral drop") << std::endl;
+            ++ephemeral_drop;
+        }else
+            ++normal_drop;
+        delete m_value;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const drop_type& dt)
+    {
+        os << dt.m_value;
+        return os;
+    }
+};
+
+struct context
+{
+    float x, y;
+};
+
+prog_config_t config = prog_config_t()
+                       .set_initial_min_tree_size(2)
+                       .set_initial_max_tree_size(6)
+                       .set_elite_count(2)
+                       .set_crossover_chance(0.8)
+                       .set_mutation_chance(0.0)
+                       .set_reproduction_chance(0.1)
+                       .set_max_generations(50)
+                       .set_pop_size(500)
+                       .set_thread_count(0);
+
+
+example::symbolic_regression_t regression{691ul, config};
+
+operation_t add{[](const drop_type a, const drop_type b) { return drop_type{a.value() + b.value()}; }, "add"};
+operation_t sub([](const drop_type a, const drop_type b) { return drop_type{a.value() - b.value()}; }, "sub");
+operation_t mul([](const drop_type a, const drop_type b) { return drop_type{a.value() * b.value()}; }, "mul");
+operation_t pro_div([](const drop_type a, const drop_type b) { return drop_type{b.value() == 0.0f ? 0.0f : a.value() / b.value()}; }, "div");
+operation_t op_sin([](const drop_type a) { return drop_type{std::sin(a.value())}; }, "sin");
+operation_t op_cos([](const drop_type a) { return drop_type{std::cos(a.value())}; }, "cos");
+operation_t op_exp([](const drop_type a) { return drop_type{std::exp(a.value())}; }, "exp");
+operation_t op_log([](const drop_type a) { return drop_type{a.value() <= 0.0f ? 0.0f : std::log(a.value())}; }, "log");
+auto lit = operation_t([]()
+{
+    return drop_type{regression.get_program().get_random().get_float(-1.0f, 1.0f), true};
+}, "lit").set_ephemeral();
+
+operation_t op_x([](const context& context)
+{
+    return drop_type{context.x};
+}, "x");
+
+bool fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t)
+{
+    if (normal_construct - normal_drop > max_allocated)
+        max_allocated = normal_construct - normal_drop;
+    constexpr static double value_cutoff = 1.e15;
+    for (auto& fitness_case : regression.get_training_cases())
+    {
+        BLT_GP_UPDATE_CONTEXT(fitness_case);
+        auto val = current_tree.get_evaluation_ref<drop_type>(fitness_case);
+        const auto diff = std::abs(fitness_case.y - val.get().value());
+        if (diff < value_cutoff)
+        {
+            fitness.raw_fitness += diff;
+            if (diff <= 0.01)
+                fitness.hits++;
+        }
+        else
+            fitness.raw_fitness += value_cutoff;
+    }
+    fitness.standardized_fitness = fitness.raw_fitness;
+    fitness.adjusted_fitness = (1.0 / (1.0 + fitness.standardized_fitness));
+    return static_cast<size_t>(fitness.hits) == regression.get_training_cases().size();
+}
+
+int main()
+{
+    operator_builder<context> builder{};
+    builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x);
+    regression.get_program().set_operations(builder.grab());
+
+    auto& program = regression.get_program();
+    static auto sel = select_tournament_t{};
+    program.generate_population(program.get_typesystem().get_type<drop_type>().id(), fitness_function, sel, sel, sel);
+    while (!program.should_terminate())
+    {
+        BLT_TRACE("---------------{Begin Generation %lu}---------------", program.get_current_generation());
+        BLT_TRACE("Creating next generation");
+        program.create_next_generation();
+        BLT_TRACE("Move to next generation");
+        program.next_generation();
+        BLT_TRACE("Evaluate Fitness");
+        program.evaluate_fitness();
+    }
+
+    // program.get_best_individuals<1>()[0].get().tree.print(program, std::cout, true, true);
+
+    regression.get_program().get_current_pop().clear();
+    regression.get_program().next_generation();
+    regression.get_program().get_current_pop().clear();
+
+    BLT_TRACE("Created %ld times", normal_construct.load());
+    BLT_TRACE("Dropped %ld times", normal_drop.load());
+    BLT_TRACE("Ephemeral created %ld times", ephemeral_construct.load());
+    BLT_TRACE("Ephemeral dropped %ld times", ephemeral_drop.load());
+    BLT_TRACE("Max allocated %ld times", max_allocated.load());
+
+}

tests/symbolic_regression_test.cpp

@@ -97,7 +97,7 @@ void run(const blt::gp::prog_config_t& config)
     }
 }
 
-int main()
+void do_run()
 {
     std::stringstream results;
     for (const auto crossover_chance : crossover_chances)
@@ -106,6 +106,8 @@ int main()
         {
             for (const auto reproduction_chance : reproduction_chances)
             {
+                if (crossover_chance == 0 && mutation_chance == 0 && reproduction_chance == 0)
+                    continue;
                 for (const auto elite_amount : elite_amounts)
                 {
                     for (const auto population_sizes : population_sizes)
@@ -162,3 +164,47 @@ int main()
     std::cout << "\tPopulation Size: " << best_config.population_size << std::endl;
     std::cout << std::endl;
 }
+
+template <typename What, typename What2>
+auto what(What addr, What2 addr2) -> decltype(addr + addr2)
+{
+    return addr + addr2;
+}
+
+enum class test
+{
+    hello,
+    there
+};
+
+inline void hello(blt::size_t)
+{
+    BLT_TRACE("I did some parallel work!");
+}
+
+inline void there(blt::size_t)
+{
+    BLT_TRACE("Wow there");
+}
+
+int main()
+{
+    // blt::gp::thread_manager_t threads{
+        // std::thread::hardware_concurrency(), blt::gp::task_builder_t<test>::make_callable(
+            // blt::gp::task_t{test::hello, hello},
+            // blt::gp::task_t{test::there, there}
+        // )
+    // };
+
+    // threads.add_task(test::hello);
+    // threads.add_task(test::hello);
+    // threads.add_task(test::hello);
+    // threads.add_task(test::there);
+
+    // while (threads.has_tasks_left())
+        // threads.execute();
+
+    for (int i = 0; i < 1; i++)
+        do_run();
+    return 0;
+}

thread_branch.txt

@@ -1,41 +0,0 @@
- Performance counter stats for './cmake-build-release/blt-symbolic-regression-example' (30 runs):
-
-    35,671,860,546      branches                                                                ( +-  5.05% )  (20.11%)
-       130,603,525      branch-misses                    #    0.37% of all branches             ( +-  4.61% )  (20.67%)
-        43,684,408      cache-misses                     #    9.61% of all cache refs           ( +-  3.08% )  (20.97%)
-       454,604,804      cache-references                                                        ( +-  4.53% )  (21.30%)
-    72,861,649,501      cycles                                                                  ( +-  5.33% )  (22.00%)
-   170,811,735,018      instructions                     #    2.34  insn per cycle              ( +-  5.59% )  (22.84%)
-                 0      alignment-faults                                                      
-            33,002      cgroup-switches                                                         ( +-  1.71% )
-           293,932      faults                                                                  ( +-  4.09% )
-     1,130,322,318 ns   duration_time                                                           ( +-  3.73% )
-    16,750,942,537 ns   user_time                                                               ( +-  1.71% )
-     1,165,192,903 ns   system_time                                                             ( +-  0.87% )
-    57,551,179,178      L1-dcache-loads                                                         ( +-  5.63% )  (22.36%)
-       214,283,064      L1-dcache-load-misses            #    0.37% of all L1-dcache accesses   ( +-  5.58% )  (22.13%)
-        75,685,527      L1-dcache-prefetches                                                    ( +-  7.55% )  (22.07%)
-     1,115,360,458      L1-icache-loads                                                         ( +-  3.91% )  (21.67%)
-         2,868,754      L1-icache-load-misses            #    0.26% of all L1-icache accesses   ( +-  3.34% )  (21.34%)
-        65,107,178      dTLB-loads                                                              ( +-  8.94% )  (21.00%)
-         4,971,480      dTLB-load-misses                 #    7.64% of all dTLB cache accesses  ( +-  3.70% )  (20.90%)
-           452,351      iTLB-loads                                                              ( +-  4.80% )  (20.62%)
-         1,600,933      iTLB-load-misses                 #  353.91% of all iTLB cache accesses  ( +-  3.68% )  (20.62%)
-       332,075,460      l2_request_g1.all_no_prefetch                                           ( +-  4.59% )  (20.73%)
-           293,932      page-faults                                                             ( +-  4.09% )
-           293,928      page-faults:u                                                           ( +-  4.09% )
-                 3      page-faults:k                                                           ( +-  4.92% )
-    58,806,652,381      L1-dcache-loads                                                         ( +-  5.44% )  (20.61%)
-       216,591,223      L1-dcache-load-misses            #    0.38% of all L1-dcache accesses   ( +-  5.39% )  (21.02%)
-   <not supported>      LLC-loads                                                             
-   <not supported>      LLC-load-misses                                                       
-     1,059,748,012      L1-icache-loads                                                         ( +-  4.29% )  (21.55%)
-         2,615,017      L1-icache-load-misses            #    0.23% of all L1-icache accesses   ( +-  3.34% )  (21.85%)
-        65,917,126      dTLB-loads                                                              ( +-  8.89% )  (21.78%)
-         4,717,351      dTLB-load-misses                 #    7.25% of all dTLB cache accesses  ( +-  3.52% )  (22.05%)
-           459,796      iTLB-loads                                                              ( +-  5.92% )  (21.77%)
-         1,512,986      iTLB-load-misses                 #  334.47% of all iTLB cache accesses  ( +-  3.64% )  (21.26%)
-        74,656,433      L1-dcache-prefetches                                                    ( +-  7.94% )  (20.50%)
-   <not supported>      L1-dcache-prefetch-misses                                             
-
-            1.1303 +- 0.0422 seconds time elapsed  ( +-  3.73% )