tri11paragon
/
blt-gp
mirror of https://github.com/tri11paragon/blt-gp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Begin working on adding drop function, add tests for many symbolic regression configs + performance

dev-func-drop
Brett 2025-01-11 18:25:55 -05:00
parent a497a006ee
commit ca0f10b410
16 changed files with 468 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -27,7 +27,7 @@ macro(compile_options target_name)
sanitizers(${target_name}) sanitizers(${target_name})
endmacro() endmacro()
project(blt-gp VERSION 0.2.10) project(blt-gp VERSION 0.3.0)
include(CTest) include(CTest)
@ -87,9 +87,9 @@ macro(blt_add_project name source type)
target_compile_definitions(${name}-${type} PRIVATE BLT_TRACK_ALLOCATIONS=1) target_compile_definitions(${name}-${type} PRIVATE BLT_TRACK_ALLOCATIONS=1)
endif () endif ()
add_test(NAME ${name} COMMAND ${name}-${type}) add_test(NAME ${name}-${type} COMMAND ${name}-${type})
set_property(TEST ${name} PROPERTY FAIL_REGULAR_EXPRESSION "FAIL;ERROR;FATAL;exception") set_property(TEST ${name}-${type} PROPERTY FAIL_REGULAR_EXPRESSION "FAIL;ERROR;FATAL;exception")
project(blt-gp) project(blt-gp)
endmacro() endmacro()
@ -115,4 +115,6 @@ if (${BUILD_GP_TESTS})
blt_add_project(blt-gp6 tests/old/gp_test_6.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-gp7 tests/old/gp_test_7.cpp test)
blt_add_project(blt-symbolic-regression tests/symbolic_regression_test.cpp test)
endif () endif ()

1
examples/src/rice_classification.cpp
View File

@ -124,6 +124,7 @@ bool blt::gp::example::rice_classification_t::fitness_function(const tree_t& cur
{ {
for (auto& training_case : training_cases) for (auto& training_case : training_cases)
{ {
BLT_GP_UPDATE_CONTEXT(training_case);
const auto v = current_tree.get_evaluation_value<float>(training_case); const auto v = current_tree.get_evaluation_value<float>(training_case);
switch (training_case.type) switch (training_case.type)
{ {

45
examples/src/symbolic_regression.cpp
View File

@ -62,48 +62,3 @@ int main()
return 0; return 0;
} }
bool blt::gp::example::symbolic_regression_t::fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t) const
{
constexpr static double value_cutoff = 1.e15;
for (auto& fitness_case : training_cases)
{
const auto diff = std::abs(fitness_case.y - current_tree.get_evaluation_value<float>(fitness_case));
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) == training_cases.size();
}
void blt::gp::example::symbolic_regression_t::setup_operations()
{
BLT_DEBUG("Setup Types and Operators");
static operation_t add{[](const float a, const float b) { return a + b; }, "add"};
static operation_t sub([](const float a, const float b) { return a - b; }, "sub");
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_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 auto lit = operation_t([this]()
{
return program.get_random().get_float(-1.0f, 1.0f);
}, "lit").set_ephemeral();
static operation_t op_x([](const context& context)
{
return context.x;
}, "x");
operator_builder<context> builder{};
builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x);
program.set_operations(builder.grab());
}

46
examples/symbolic_regression.h
View File

@ -35,7 +35,25 @@ namespace blt::gp::example
}; };
private: private:
bool fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t) const; bool fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t) const
{
constexpr static double value_cutoff = 1.e15;
for (auto& fitness_case : training_cases)
{
const auto diff = std::abs(fitness_case.y - current_tree.get_evaluation_value<float>(fitness_case));
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) == training_cases.size();
}
static float example_function(const float x) static float example_function(const float x)
{ {
@ -63,7 +81,31 @@ namespace blt::gp::example
}; };
} }
void setup_operations(); void setup_operations()
{
BLT_DEBUG("Setup Types and Operators");
static operation_t add{[](const float a, const float b) { return a + b; }, "add"};
static operation_t sub([](const float a, const float b) { return a - b; }, "sub");
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_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 auto lit = operation_t([this]()
{
return program.get_random().get_float(-1.0f, 1.0f);
}, "lit").set_ephemeral();
static operation_t op_x([](const context& context)
{
return context.x;
}, "x");
operator_builder<context> builder{};
builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x);
program.set_operations(builder.grab());
}
void generate_initial_population() void generate_initial_population()
{ {

30
include/blt/gp/allocator.h
View File

@ -20,12 +20,29 @@
#define BLT_GP_ALLOCATOR_H #define BLT_GP_ALLOCATOR_H
#include <blt/std/types.h> #include <blt/std/types.h>
#include <blt/std/logging.h>
#include <blt/gp/util/trackers.h> #include <blt/gp/util/trackers.h>
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>
namespace blt::gp namespace blt::gp
{ {
namespace detail
{
static constexpr inline size_t MAX_ALIGNMENT = 8;
#if BLT_DEBUG_LEVEL > 0
static void check_alignment(const size_t bytes, const std::string& message = "Invalid alignment")
{
if (bytes % MAX_ALIGNMENT != 0)
{
BLT_ABORT((message + ", expected multiple of " + std::to_string(detail::MAX_ALIGNMENT) + " got "
+ std::to_string(bytes)).c_str());
}
}
#endif
}
#ifdef BLT_TRACK_ALLOCATIONS #ifdef BLT_TRACK_ALLOCATIONS
inline allocation_tracker_t tracker; inline allocation_tracker_t tracker;
@ -47,11 +64,14 @@ namespace blt::gp
public: public:
void* allocate(blt::size_t bytes) // NOLINT void* allocate(blt::size_t bytes) // NOLINT
{ {
#ifdef BLT_TRACK_ALLOCATIONS #ifdef BLT_TRACK_ALLOCATIONSS
tracker.allocate(bytes); tracker.allocate(bytes);
// std::cout << "Hey our aligned allocator allocated " << bytes << " bytes!\n"; // std::cout << "Hey our aligned allocator allocated " << bytes << " bytes!\n";
#endif #endif
return std::aligned_alloc(8, bytes); #if (BLT_DEBUG_LEVEL > 0)
detail::check_alignment(bytes);
#endif
return std::aligned_alloc(detail::MAX_ALIGNMENT, bytes);
} }
void deallocate(void* ptr, blt::size_t bytes) // NOLINT void deallocate(void* ptr, blt::size_t bytes) // NOLINT
@ -62,7 +82,7 @@ namespace blt::gp
tracker.deallocate(bytes); tracker.deallocate(bytes);
// std::cout << "[Hey our aligned allocator deallocated " << bytes << " bytes!]\n"; // std::cout << "[Hey our aligned allocator deallocated " << bytes << " bytes!]\n";
#else #else
(void) bytes; (void)bytes;
#endif #endif
std::free(ptr); std::free(ptr);
} }
@ -108,7 +128,7 @@ namespace blt::gp
::blt::gp::tracker.deallocate(n * sizeof(T)); ::blt::gp::tracker.deallocate(n * sizeof(T));
// std::cout << "[Hey our tracked allocator deallocated " << (n * sizeof(T)) << " bytes!]\n"; // std::cout << "[Hey our tracked allocator deallocated " << (n * sizeof(T)) << " bytes!]\n";
#else #else
(void) n; (void)n;
#endif #endif
std::free(p); std::free(p);
} }
@ -147,7 +167,7 @@ namespace blt::gp
template<typename T> template<typename T>
using tracked_vector = std::vector<T, tracked_allocator_t<T>>; using tracked_vector = std::vector<T, tracked_allocator_t<T>>;
#else #else
template<typename T> template <typename T>
using tracked_vector = std::vector<T>; using tracked_vector = std::vector<T>;
#endif #endif
} }

12
include/blt/gp/fwdecl.h
View File

@ -85,6 +85,18 @@ namespace blt::gp
using const_op_iter_t = tracked_vector<op_container_t>::const_iterator; using const_op_iter_t = tracked_vector<op_container_t>::const_iterator;
using op_iter_t = tracked_vector<op_container_t>::iterator; using op_iter_t = tracked_vector<op_container_t>::iterator;
} }
#if BLT_DEBUG_LEVEL > 0
namespace detail::debug
{
inline void* context_ptr;
}
#define BLT_GP_UPDATE_CONTEXT(context) blt::gp::detail::debug::context_ptr = const_cast<void*>(static_cast<const void*>(&context))
#else
#define BLT_GP_UPDATE_CONTEXT(context)
#endif
} }

12
include/blt/gp/program.h
View File

@ -143,13 +143,13 @@ namespace blt::gp
for (const auto& operation : iterate(ops).rev()) for (const auto& operation : iterate(ops).rev())
{ {
op_pos++; op_pos++;
if (operation.is_value) if (operation.is_value())
{ {
total_so_far += stack_allocator::aligned_size(operation.type_size); total_so_far += operation.type_size();
results.values.copy_from(vals.from(total_so_far), stack_allocator::aligned_size(operation.type_size)); results.values.copy_from(vals.from(total_so_far), operation.type_size());
continue; continue;
} }
call_jmp_table(operation.id, context, results.values, results.values, operators...); call_jmp_table(operation.id(), context, results.values, results.values, operators...);
} }
return results; return results;
@ -258,9 +258,9 @@ namespace blt::gp
operator_metadata_t meta; operator_metadata_t meta;
if constexpr (sizeof...(Args) != 0) if constexpr (sizeof...(Args) != 0)
{ {
meta.arg_size_bytes = (stack_allocator::aligned_size(sizeof(Args)) + ...); meta.arg_size_bytes = (stack_allocator::aligned_size<Args>() + ...);
} }
meta.return_size_bytes = sizeof(Return); meta.return_size_bytes = stack_allocator::aligned_size<Return>();
meta.argc = info.argc; meta.argc = info.argc;
storage.operator_metadata.push_back(meta); storage.operator_metadata.push_back(meta);

8
include/blt/gp/selection.h
View File

@ -43,6 +43,10 @@ namespace blt::gp
{ {
auto& [program, current_pop, current_stats, config, random] = args; 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) if (config.elites > 0 && current_pop.get_individuals().size() >= config.elites)
{ {
static thread_local tracked_vector<std::pair<std::size_t, double>> values; static thread_local tracked_vector<std::pair<std::size_t, double>> values;
@ -132,13 +136,13 @@ namespace blt::gp
// auto old_parent_val = parent_fitness.load(std::memory_order_relaxed); // 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, // while (!parent_fitness.compare_exchange_weak(old_parent_val, old_parent_val + parent_val, std::memory_order_relaxed,
// std::memory_order_relaxed)) // std::memory_order_relaxed))
// { // {
// } // }
// auto old_child_val = child_fitness.load(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, // while (!child_fitness.compare_exchange_weak(old_child_val, old_child_val + child_val, std::memory_order_relaxed,
// std::memory_order_relaxed)) // std::memory_order_relaxed))
// { // {
// } // }

133
include/blt/gp/stack.h
View File

@ -28,6 +28,7 @@
#include <blt/meta/meta.h> #include <blt/meta/meta.h>
#include <blt/gp/fwdecl.h> #include <blt/gp/fwdecl.h>
#include <blt/gp/util/trackers.h> #include <blt/gp/util/trackers.h>
#include <blt/gp/allocator.h>
#include <utility> #include <utility>
#include <stdexcept> #include <stdexcept>
#include <cstdlib> #include <cstdlib>
@ -46,11 +47,19 @@ namespace blt::gp
class stack_allocator class stack_allocator
{ {
constexpr static blt::size_t PAGE_SIZE = 0x100; constexpr static blt::size_t PAGE_SIZE = 0x100;
constexpr static blt::size_t MAX_ALIGNMENT = 8;
template <typename T> template <typename T>
using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>; using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
using Allocator = aligned_allocator; using Allocator = aligned_allocator;
// todo remove this once i fix all the broken references
struct detail
{
static constexpr size_t aligned_size(const size_t size) noexcept
{
return (size + (gp::detail::MAX_ALIGNMENT - 1)) & ~(gp::detail::MAX_ALIGNMENT - 1);
}
};
public: public:
static Allocator& get_allocator(); static Allocator& get_allocator();
@ -74,19 +83,14 @@ namespace blt::gp
}; };
template <typename T> template <typename T>
static inline constexpr size_t aligned_size() noexcept static constexpr size_t aligned_size() noexcept
{ {
const auto bytes = aligned_size(sizeof(NO_REF_T<T>)); const auto bytes = detail::aligned_size(sizeof(NO_REF_T<T>));
if constexpr (blt::gp::detail::has_func_drop_v<T>) if constexpr (blt::gp::detail::has_func_drop_v<T>)
return bytes + sizeof(size_t*); return bytes + aligned_size<size_t*>();
return bytes; return bytes;
} }
static inline constexpr blt::size_t aligned_size(blt::size_t size) noexcept
{
return (size + (MAX_ALIGNMENT - 1)) & ~(MAX_ALIGNMENT - 1);
}
stack_allocator() = default; stack_allocator() = default;
stack_allocator(const stack_allocator& copy) stack_allocator(const stack_allocator& copy)
@ -138,7 +142,7 @@ namespace blt::gp
bytes_stored += bytes; bytes_stored += bytes;
} }
void copy_from(blt::u8* data, blt::size_t bytes) void copy_from(const u8* data, const size_t bytes)
{ {
if (bytes == 0 || data == nullptr) if (bytes == 0 || data == nullptr)
return; return;
@ -148,7 +152,7 @@ namespace blt::gp
bytes_stored += bytes; bytes_stored += bytes;
} }
void copy_to(blt::u8* data, blt::size_t bytes) void copy_to(u8* data, const size_t bytes) const
{ {
if (bytes == 0 || data == nullptr) if (bytes == 0 || data == nullptr)
return; return;
@ -158,64 +162,65 @@ namespace blt::gp
template <typename T, typename NO_REF = NO_REF_T<T>> template <typename T, typename NO_REF = NO_REF_T<T>>
void push(const T& t) void push(const T& t)
{ {
static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!"); static_assert(std::is_trivially_copyable_v<NO_REF>, "Type must be bitwise copyable!");
static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!"); static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT, "Type alignment must not be greater than the max alignment!");
auto ptr = allocate_bytes_for_size(sizeof(NO_REF)); const auto ptr = allocate_bytes_for_size(aligned_size<NO_REF>());
std::memcpy(ptr, &t, sizeof(NO_REF)); std::memcpy(ptr, &t, sizeof(NO_REF));
} }
template <typename T, typename NO_REF = NO_REF_T<T>> template <typename T, typename NO_REF = NO_REF_T<T>>
T pop() T pop()
{ {
static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!"); static_assert(std::is_trivially_copyable_v<NO_REF>, "Type must be bitwise copyable!");
static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!"); static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT, "Type alignment must not be greater than the max alignment!");
constexpr auto size = aligned_size(sizeof(NO_REF)); constexpr auto size = aligned_size<NO_REF>();
#if BLT_DEBUG_LEVEL > 0 #if BLT_DEBUG_LEVEL > 0
if (bytes_stored < size) if (bytes_stored < size)
BLT_ABORT("Not enough bytes left to pop!"); BLT_ABORT("Not enough bytes left to pop!");
#endif #endif
bytes_stored -= size; bytes_stored -= size;
return *reinterpret_cast<T*>(data_ + bytes_stored); return *reinterpret_cast<T*>(data_ + bytes_stored);
} }
[[nodiscard]] blt::u8* from(blt::size_t bytes) const [[nodiscard]] u8* from(const size_t bytes) const
{ {
#if BLT_DEBUG_LEVEL > 0 #if BLT_DEBUG_LEVEL > 0
if (bytes_stored < bytes) if (bytes_stored < bytes)
BLT_ABORT(("Not enough bytes in stack to reference " + std::to_string(bytes) + " bytes requested but " + std::to_string(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()); " bytes stored!").c_str());
#endif #endif
return data_ + (bytes_stored - bytes); return data_ + (bytes_stored - bytes);
} }
template <typename T, typename NO_REF = NO_REF_T<T>> template <typename T, typename NO_REF = NO_REF_T<T>>
T& from(blt::size_t bytes) T& from(const size_t bytes)
{ {
static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!"); static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!"); 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(sizeof(NO_REF)) + bytes)); return *reinterpret_cast<NO_REF*>(from(aligned_size<NO_REF>() + bytes));
} }
void pop_bytes(blt::size_t bytes) void pop_bytes(const size_t bytes)
{ {
#if BLT_DEBUG_LEVEL > 0 #if BLT_DEBUG_LEVEL > 0
if (bytes_stored < bytes) if (bytes_stored < bytes)
BLT_ABORT(("Not enough bytes in stack to pop " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) + BLT_ABORT(("Not enough bytes in stack to pop " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
" bytes stored!").c_str()); " bytes stored!").c_str());
gp::detail::check_alignment(bytes);
#endif #endif
bytes_stored -= bytes; bytes_stored -= bytes;
} }
void transfer_bytes(stack_allocator& to, blt::size_t bytes) void transfer_bytes(stack_allocator& to, const size_t aligned_bytes)
{ {
#if BLT_DEBUG_LEVEL > 0 #if BLT_DEBUG_LEVEL > 0
if (bytes_stored < bytes) if (bytes_stored < aligned_bytes)
BLT_ABORT(("Not enough bytes in stack to transfer " + std::to_string(bytes) + " bytes requested but " + std::to_string(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()); " bytes stored!").c_str());
gp::detail::check_alignment(aligned_bytes);
#endif #endif
auto alg = aligned_size(bytes); to.copy_from(*this, aligned_bytes);
to.copy_from(*this, alg); pop_bytes(aligned_bytes);
pop_bytes(alg);
} }
template <typename... Args> template <typename... Args>
@ -223,9 +228,8 @@ namespace blt::gp
{ {
if constexpr (sizeof...(Args) > 0) if constexpr (sizeof...(Args) > 0)
{ {
blt::size_t offset = (stack_allocator::aligned_size(sizeof(NO_REF_T<Args>)) + ...) - size_t offset = (aligned_size<NO_REF_T<Args>>() + ...) - aligned_size<NO_REF_T<typename meta::arg_helper<Args...>::First>>();
stack_allocator::aligned_size(sizeof(NO_REF_T<typename blt::meta::arg_helper<Args...>::First>)); ((call_drop<Args>(offset), offset -= aligned_size<NO_REF_T<Args>>()), ...);
((call_drop<Args>(offset), offset -= stack_allocator::aligned_size(sizeof(NO_REF_T<Args>))), ...);
} }
} }
@ -234,14 +238,14 @@ namespace blt::gp
return bytes_stored == 0; return bytes_stored == 0;
} }
[[nodiscard]] blt::ptrdiff_t remaining_bytes_in_block() const noexcept [[nodiscard]] ptrdiff_t remaining_bytes_in_block() const noexcept
{ {
return static_cast<blt::ptrdiff_t>(size_ - bytes_stored); return static_cast<ptrdiff_t>(size_ - bytes_stored);
} }
[[nodiscard]] blt::ptrdiff_t bytes_in_head() const noexcept [[nodiscard]] ptrdiff_t bytes_in_head() const noexcept
{ {
return static_cast<blt::ptrdiff_t>(bytes_stored); return static_cast<ptrdiff_t>(bytes_stored);
} }
[[nodiscard]] size_data_t size() const noexcept [[nodiscard]] size_data_t size() const noexcept
@ -255,18 +259,18 @@ namespace blt::gp
return data; return data;
} }
void reserve(blt::size_t bytes) void reserve(const size_t bytes)
{ {
if (bytes > size_) if (bytes > size_)
expand_raw(bytes); expand_raw(bytes);
} }
[[nodiscard]] blt::size_t stored() const [[nodiscard]] size_t stored() const
{ {
return bytes_stored; return bytes_stored;
} }
[[nodiscard]] blt::size_t internal_storage_size() const [[nodiscard]] size_t internal_storage_size() const
{ {
return size_; return size_;
} }
@ -277,15 +281,16 @@ namespace blt::gp
} }
private: private:
void expand(blt::size_t bytes) void expand(const size_t bytes)
{ {
//bytes = to_nearest_page_size(bytes); //bytes = to_nearest_page_size(bytes);
expand_raw(bytes); expand_raw(bytes);
} }
void expand_raw(blt::size_t bytes) void expand_raw(const size_t bytes)
{ {
auto new_data = static_cast<blt::u8*>(get_allocator().allocate(bytes)); // auto aligned = detail::aligned_size(bytes);
const auto new_data = static_cast<u8*>(get_allocator().allocate(bytes));
if (bytes_stored > 0) if (bytes_stored > 0)
std::memcpy(new_data, data_, bytes_stored); std::memcpy(new_data, data_, bytes_stored);
get_allocator().deallocate(data_, size_); get_allocator().deallocate(data_, size_);
@ -293,40 +298,42 @@ namespace blt::gp
size_ = bytes; size_ = bytes;
} }
static size_t to_nearest_page_size(blt::size_t bytes) noexcept static size_t to_nearest_page_size(const size_t bytes) noexcept
{ {
constexpr static blt::size_t MASK = ~(PAGE_SIZE - 1); constexpr static size_t MASK = ~(PAGE_SIZE - 1);
return (bytes & MASK) + PAGE_SIZE; return (bytes & MASK) + PAGE_SIZE;
} }
void* get_aligned_pointer(blt::size_t bytes) noexcept [[nodiscard]] void* get_aligned_pointer(const size_t bytes) const noexcept
{ {
if (data_ == nullptr) if (data_ == nullptr)
return nullptr; return nullptr;
blt::size_t remaining_bytes = remaining_bytes_in_block(); size_t remaining_bytes = remaining_bytes_in_block();
auto* pointer = static_cast<void*>(data_ + bytes_stored); auto* pointer = static_cast<void*>(data_ + bytes_stored);
return std::align(MAX_ALIGNMENT, bytes, pointer, remaining_bytes); return std::align(gp::detail::MAX_ALIGNMENT, bytes, pointer, remaining_bytes);
} }
void* allocate_bytes_for_size(blt::size_t bytes) void* allocate_bytes_for_size(const size_t aligned_bytes)
{ {
auto used_bytes = aligned_size(bytes); #if BLT_DEBUG_LEVEL > 0
auto aligned_ptr = get_aligned_pointer(used_bytes); gp::detail::check_alignment(aligned_bytes);
#endif
auto aligned_ptr = get_aligned_pointer(aligned_bytes);
if (aligned_ptr == nullptr) if (aligned_ptr == nullptr)
{ {
expand(size_ + used_bytes); expand(size_ + aligned_bytes);
aligned_ptr = get_aligned_pointer(used_bytes); aligned_ptr = get_aligned_pointer(aligned_bytes);
} }
if (aligned_ptr == nullptr) if (aligned_ptr == nullptr)
throw std::bad_alloc(); throw std::bad_alloc();
bytes_stored += used_bytes; bytes_stored += aligned_bytes;
return aligned_ptr; return aligned_ptr;
} }
template <typename T> template <typename T>
inline void call_drop(blt::size_t offset) void call_drop(const size_t offset)
{ {
if constexpr (detail::has_func_drop_v<T>) if constexpr (blt::gp::detail::has_func_drop_v<T>)
{ {
from<NO_REF_T<T>>(offset).drop(); from<NO_REF_T<T>>(offset).drop();
} }

117
include/blt/gp/tree.h
View File

@ -35,17 +35,37 @@ namespace blt::gp
struct op_container_t struct op_container_t
{ {
op_container_t(const size_t type_size, const operator_id id, const bool is_value): op_container_t(const size_t type_size, const operator_id id, const bool is_value):
type_size(type_size), id(id), is_value(is_value), has_drop(false) m_type_size(type_size), m_id(id), m_is_value(is_value), m_has_drop(false)
{} {}
op_container_t(const size_t type_size, const operator_id id, const bool is_value, const bool has_drop): op_container_t(const size_t type_size, const operator_id id, const bool is_value, const bool has_drop):
type_size(type_size), id(id), is_value(is_value), has_drop(has_drop) m_type_size(type_size), m_id(id), m_is_value(is_value), m_has_drop(has_drop)
{} {}
size_t type_size; [[nodiscard]] auto type_size() const
operator_id id; {
bool is_value; return m_type_size;
bool has_drop; }
[[nodiscard]] auto id() const
{
return m_id;
}
[[nodiscard]] auto is_value() const
{
return m_is_value;
}
[[nodiscard]] bool has_drop() const
{
return m_has_drop;
}
private:
size_t m_type_size;
operator_id m_id;
bool m_is_value;
bool m_has_drop;
}; };
class evaluation_context class evaluation_context
@ -83,42 +103,37 @@ namespace blt::gp
values.reset(); values.reset();
values.insert(copy.values); values.insert(copy.values);
// operations.reserve(copy.operations.size());
//
// auto copy_it = copy.operations.begin();
// auto op_it = operations.begin();
//
// for (; op_it != operations.end(); ++op_it)
// {
// if (op_it->has_drop)
// {
//
// }
// if (copy_it == copy.operations.end())
// break;
// *op_it = *copy_it;
// if (copy_it->has_drop)
// {
//
// }
// ++copy_it;
// }
// const auto op_it_cpy = op_it;
// for (;op_it != operations.end(); ++op_it)
// {
// if (op_it->has_drop)
// {
//
// }
// }
// operations.erase(op_it_cpy, operations.end());
// for (; copy_it != copy.operations.end(); ++copy_it)
// operations.emplace_back(*copy_it);
operations.clear();
operations.reserve(copy.operations.size()); operations.reserve(copy.operations.size());
operations.insert(operations.begin(), copy.operations.begin(), copy.operations.end());
auto copy_it = copy.operations.begin();
auto op_it = operations.begin();
for (; op_it != operations.end(); ++op_it)
{
if (op_it->has_drop())
{
}
if (copy_it == copy.operations.end())
break;
*op_it = *copy_it;
if (copy_it->has_drop())
{
}
++copy_it;
}
const auto op_it_cpy = op_it;
for (;op_it != operations.end(); ++op_it)
{
if (op_it->has_drop())
{
}
}
operations.erase(op_it_cpy, operations.end());
for (; copy_it != copy.operations.end(); ++copy_it)
operations.emplace_back(*copy_it);
} }
tree_t(tree_t&& move) = default; tree_t(tree_t&& move) = default;
@ -213,36 +228,36 @@ namespace blt::gp
blt::ptrdiff_t find_parent(blt::gp::gp_program& program, blt::ptrdiff_t start) const; blt::ptrdiff_t find_parent(blt::gp::gp_program& program, blt::ptrdiff_t start) const;
// valid for [begin, end) // valid for [begin, end)
static blt::size_t total_value_bytes(detail::const_op_iter_t begin, detail::const_op_iter_t end) static size_t total_value_bytes(const detail::const_op_iter_t begin, const detail::const_op_iter_t end)
{ {
blt::size_t total = 0; size_t total = 0;
for (auto it = begin; it != end; it++) for (auto it = begin; it != end; ++it)
{ {
if (it->is_value) if (it->is_value())
total += stack_allocator::aligned_size(it->type_size); total += it->type_size();
} }
return total; return total;
} }
[[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin, blt::size_t end) const [[nodiscard]] size_t total_value_bytes(const size_t begin, const size_t end) const
{ {
return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin), return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin),
operations.begin() + static_cast<blt::ptrdiff_t>(end)); operations.begin() + static_cast<blt::ptrdiff_t>(end));
} }
[[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin) const [[nodiscard]] size_t total_value_bytes(const size_t begin) const
{ {
return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin), operations.end()); return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin), operations.end());
} }
[[nodiscard]] blt::size_t total_value_bytes() const [[nodiscard]] size_t total_value_bytes() const
{ {
return total_value_bytes(operations.begin(), operations.end()); return total_value_bytes(operations.begin(), operations.end());
} }
private: private:
tracked_vector<op_container_t> operations; tracked_vector<op_container_t> operations;
blt::gp::stack_allocator values; stack_allocator values;
detail::eval_func_t* func; detail::eval_func_t* func;
}; };

4
include/blt/gp/typesystem.h
View File

@ -46,9 +46,9 @@ namespace blt::gp
type() = default; type() = default;
template<typename T> template<typename T>
static type make_type(type_id id) static type make_type(const type_id id)
{ {
return type(sizeof(T), id, blt::type_string<T>()); return type(stack_allocator::aligned_size<T>(), id, blt::type_string<T>());
} }
[[nodiscard]] inline blt::size_t size() const [[nodiscard]] inline blt::size_t size() const

2
lib/blt

@ -1 +1 @@
Subproject commit 1798980ac6829d5d79c162325a2162aa42917958 Subproject commit 8133553ed87f705c890c5becda710f72f3ddccb9

2
src/generators.cpp
View File

@ -60,7 +60,7 @@ namespace blt::gp
tree_generator.pop(); tree_generator.pop();
auto& info = args.program.get_operator_info(top.id); auto& info = args.program.get_operator_info(top.id);
tree.get_operations().emplace_back( tree.get_operations().emplace_back(
args.program.get_typesystem().get_type(info.return_type).size(), args.program.get_typesystem().get_type(info.return_type).size(),
top.id, top.id,

56
src/transformers.cpp
View File

@ -40,8 +40,8 @@ namespace blt::gp
size_t total = 0; size_t total = 0;
for (auto it = begin; it != end; ++it) for (auto it = begin; it != end; ++it)
{ {
if (it->is_value) if (it->is_value())
total += stack_allocator::aligned_size(it->type_size); total += it->type_size();
} }
return total; return total;
} }
@ -157,14 +157,14 @@ namespace blt::gp
blt::size_t c2_found_bytes = c2.get_values().size().total_used_bytes; blt::size_t c2_found_bytes = c2.get_values().size().total_used_bytes;
blt::size_t c1_expected_bytes = std::accumulate(c1.get_operations().begin(), c1.get_operations().end(), 0ul, blt::size_t c1_expected_bytes = std::accumulate(c1.get_operations().begin(), c1.get_operations().end(), 0ul,
[](const auto& v1, const auto& v2) { [](const auto& v1, const auto& v2) {
if (v2.is_value) if (v2.is_value())
return v1 + stack_allocator::aligned_size(v2.type_size); return v1 + v2.type_size();
return v1; return v1;
}); });
blt::size_t c2_expected_bytes = std::accumulate(c2.get_operations().begin(), c2.get_operations().end(), 0ul, blt::size_t c2_expected_bytes = std::accumulate(c2.get_operations().begin(), c2.get_operations().end(), 0ul,
[](const auto& v1, const auto& v2) { [](const auto& v1, const auto& v2) {
if (v2.is_value) if (v2.is_value())
return v1 + stack_allocator::aligned_size(v2.type_size); return v1 + v2.type_size();
return v1; return v1;
}); });
if (c1_found_bytes != c1_expected_bytes || c2_found_bytes != c2_expected_bytes) if (c1_found_bytes != c1_expected_bytes || c2_found_bytes != c2_expected_bytes)
@ -191,7 +191,7 @@ namespace blt::gp
const bool allow_terminal_selection = program.get_random().choice(config.terminal_chance); const bool allow_terminal_selection = program.get_random().choice(config.terminal_chance);
blt::size_t counter = 0; blt::size_t counter = 0;
while (!allow_terminal_selection && program.get_operator_info(c1_ops[crossover_point].id).argc.is_terminal()) while (!allow_terminal_selection && program.get_operator_info(c1_ops[crossover_point].id()).argc.is_terminal())
{ {
if (counter >= config.max_crossover_tries) if (counter >= config.max_crossover_tries)
return {}; return {};
@ -201,13 +201,13 @@ namespace blt::gp
size_t attempted_point = 0; size_t attempted_point = 0;
const auto& crossover_point_type = program.get_operator_info(c1_ops[crossover_point].id); const auto& crossover_point_type = program.get_operator_info(c1_ops[crossover_point].id());
const operator_info_t* attempted_point_type = nullptr; const operator_info_t* attempted_point_type = nullptr;
for (counter = 0; counter < config.max_crossover_tries; counter++) for (counter = 0; counter < config.max_crossover_tries; counter++)
{ {
attempted_point = program.get_random().get_size_t(1ul, c2_ops.size()); attempted_point = program.get_random().get_size_t(1ul, c2_ops.size());
attempted_point_type = &program.get_operator_info(c2_ops[attempted_point].id); attempted_point_type = &program.get_operator_info(c2_ops[attempted_point].id());
if (!allow_terminal_selection && attempted_point_type->argc.is_terminal()) if (!allow_terminal_selection && attempted_point_type->argc.is_terminal())
continue; continue;
if (crossover_point_type.return_type == attempted_point_type->return_type) if (crossover_point_type.return_type == attempted_point_type->return_type)
@ -239,14 +239,14 @@ namespace blt::gp
ptrdiff_t point = 0; ptrdiff_t point = 0;
while (true) while (true)
{ {
auto& current_op_type = program.get_operator_info(t.get_operations()[point].id); auto& current_op_type = program.get_operator_info(t.get_operations()[point].id());
if (current_op_type.argc.is_terminal()) if (current_op_type.argc.is_terminal())
{ {
if (!should_select_terminal) if (!should_select_terminal)
{ {
if (parent == -1) if (parent == -1)
return {}; return {};
auto& parent_type = program.get_operator_info(t.get_operations()[parent].id); auto& parent_type = program.get_operator_info(t.get_operations()[parent].id());
if (type && *type != parent_type.return_type) if (type && *type != parent_type.return_type)
return {}; return {};
return {{parent, parent_type}}; return {{parent, parent_type}};
@ -299,7 +299,7 @@ namespace blt::gp
auto begin_point = static_cast<blt::ptrdiff_t>(node); auto begin_point = static_cast<blt::ptrdiff_t>(node);
auto end_point = c.find_endpoint(program, begin_point); auto end_point = c.find_endpoint(program, begin_point);
auto begin_operator_id = ops_r[begin_point].id; auto begin_operator_id = ops_r[begin_point].id();
const auto& type_info = program.get_operator_info(begin_operator_id); const auto& type_info = program.get_operator_info(begin_operator_id);
auto begin_itr = ops_r.begin() + begin_point; auto begin_itr = ops_r.begin() + begin_point;
@ -337,8 +337,8 @@ namespace blt::gp
for (const auto& op : c.get_operations()) for (const auto& op : c.get_operations())
{ {
if (op.is_value) if (op.is_value())
bytes_expected += stack_allocator::aligned_size(op.type_size); bytes_expected += op.type_size();
} }
if (bytes_expected != bytes_size) if (bytes_expected != bytes_size)
@ -352,14 +352,14 @@ namespace blt::gp
auto copy = c; auto copy = c;
try try
{ {
const auto& result = copy.evaluate(); const auto& result = copy.evaluate(*static_cast<char*>(detail::debug::context_ptr));
blt::black_box(result); blt::black_box(result);
} catch (...) } catch (...)
{ {
std::cout << "This occurred at point " << begin_point << " ending at (old) " << end_point << "\n"; std::cout << "This occurred at point " << begin_point << " ending at (old) " << end_point << "\n";
std::cout << "our root type is " << ops_r[begin_point].id << " with size " << stack_allocator::aligned_size(ops_r[begin_point].type_size) std::cout << "our root type is " << ops_r[begin_point].id() << " with size " << ops_r[begin_point].type_size()
<< "\n"; << "\n";
std::cout << "now Named: " << (program.get_name(ops_r[begin_point].id) ? *program.get_name(ops_r[begin_point].id) : "Unnamed") << "\n"; std::cout << "now Named: " << (program.get_name(ops_r[begin_point].id()) ? *program.get_name(ops_r[begin_point].id()) : "Unnamed") << "\n";
std::cout << "Was named: " << (program.get_name(begin_operator_id) ? *program.get_name(begin_operator_id) : "Unnamed") << "\n"; std::cout << "Was named: " << (program.get_name(begin_operator_id) ? *program.get_name(begin_operator_id) : "Unnamed") << "\n";
//std::cout << "Parent:" << std::endl; //std::cout << "Parent:" << std::endl;
//p.print(program, std::cout, false, true); //p.print(program, std::cout, false, true);
@ -422,9 +422,9 @@ namespace blt::gp
{ {
// this is going to be evil >:3 // this is going to be evil >:3
const auto& node = ops[c_node]; const auto& node = ops[c_node];
if (!node.is_value) if (!node.is_value())
{ {
auto& current_func_info = program.get_operator_info(ops[c_node].id); auto& current_func_info = program.get_operator_info(ops[c_node].id());
operator_id random_replacement = program.get_random().select( operator_id random_replacement = program.get_random().select(
program.get_type_non_terminals(current_func_info.return_type.id)); program.get_type_non_terminals(current_func_info.return_type.id));
auto& replacement_func_info = program.get_operator_info(random_replacement); auto& replacement_func_info = program.get_operator_info(random_replacement);
@ -483,8 +483,8 @@ namespace blt::gp
blt::size_t expected_bytes = std::accumulate(ops.begin(), blt::size_t expected_bytes = std::accumulate(ops.begin(),
ops.end(), 0ul, ops.end(), 0ul,
[](const auto& v1, const auto& v2) { [](const auto& v1, const auto& v2) {
if (v2.is_value) if (v2.is_value())
return v1 + stack_allocator::aligned_size(v2.type_size); return v1 + v2.type_size();
return v1; return v1;
}); });
if (found_bytes != expected_bytes) if (found_bytes != expected_bytes)
@ -545,7 +545,7 @@ namespace blt::gp
}; };
} }
#if BLT_DEBUG_LEVEL >= 2 #if BLT_DEBUG_LEVEL >= 2
if (!c.check(program, nullptr)) if (!c.check(program, detail::debug::context_ptr))
{ {
std::cout << "Parent: " << std::endl; std::cout << "Parent: " << std::endl;
c_copy.print(program, std::cout, false, true); c_copy.print(program, std::cout, false, true);
@ -559,7 +559,7 @@ namespace blt::gp
break; break;
case mutation_operator::SUB_FUNC: case mutation_operator::SUB_FUNC:
{ {
auto& current_func_info = program.get_operator_info(ops[c_node].id); auto& current_func_info = program.get_operator_info(ops[c_node].id());
// need to: // need to:
// mutate the current function. // mutate the current function.
@ -640,7 +640,7 @@ namespace blt::gp
}); });
#if BLT_DEBUG_LEVEL >= 2 #if BLT_DEBUG_LEVEL >= 2
if (!c.check(program, nullptr)) if (!c.check(program, detail::debug::context_ptr))
{ {
std::cout << "Parent: " << std::endl; std::cout << "Parent: " << std::endl;
p.print(program, std::cout, false, true); p.print(program, std::cout, false, true);
@ -656,7 +656,7 @@ namespace blt::gp
break; break;
case mutation_operator::JUMP_FUNC: case mutation_operator::JUMP_FUNC:
{ {
auto& info = program.get_operator_info(ops[c_node].id); auto& info = program.get_operator_info(ops[c_node].id());
blt::size_t argument_index = -1ul; blt::size_t argument_index = -1ul;
for (const auto& [index, v] : blt::enumerate(info.argument_types)) for (const auto& [index, v] : blt::enumerate(info.argument_types))
{ {
@ -703,7 +703,7 @@ namespace blt::gp
vals.copy_from(storage_ptr, for_bytes + after_bytes); vals.copy_from(storage_ptr, for_bytes + after_bytes);
#if BLT_DEBUG_LEVEL >= 2 #if BLT_DEBUG_LEVEL >= 2
if (!c.check(program, nullptr)) if (!c.check(program, detail::debug::context_ptr))
{ {
std::cout << "Parent: " << std::endl; std::cout << "Parent: " << std::endl;
p.print(program, std::cout, false, true); p.print(program, std::cout, false, true);
@ -717,7 +717,7 @@ namespace blt::gp
break; break;
case mutation_operator::COPY: case mutation_operator::COPY:
{ {
auto& info = program.get_operator_info(ops[c_node].id); auto& info = program.get_operator_info(ops[c_node].id());
blt::size_t pt = -1ul; blt::size_t pt = -1ul;
blt::size_t pf = -1ul; blt::size_t pf = -1ul;
for (const auto& [index, v] : blt::enumerate(info.argument_types)) for (const auto& [index, v] : blt::enumerate(info.argument_types))
@ -803,7 +803,7 @@ namespace blt::gp
} }
#if BLT_DEBUG_LEVEL >= 2 #if BLT_DEBUG_LEVEL >= 2
if (!c.check(program, nullptr)) if (!c.check(program, detail::debug::context_ptr))
{ {
std::cout << "Parent: " << std::endl; std::cout << "Parent: " << std::endl;
p.print(program, std::cout, false, true); p.print(program, std::cout, false, true);

74
src/tree.cpp
View File

@ -72,14 +72,14 @@ namespace blt::gp
// reverse the order of the stack // reverse the order of the stack
for (const auto& v : operations) for (const auto& v : operations)
{ {
if (v.is_value) if (v.is_value())
copy.transfer_bytes(reversed, v.type_size); copy.transfer_bytes(reversed, v.type_size());
} }
} }
for (const auto& v : operations) for (const auto& v : operations)
{ {
auto info = program.get_operator_info(v.id); auto info = program.get_operator_info(v.id());
auto name = program.get_name(v.id) ? program.get_name(v.id).value() : "NULL"; 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 return_type = get_return_type(program, info.return_type, include_types);
if (info.argc.argc > 0) if (info.argc.argc > 0)
{ {
@ -92,10 +92,10 @@ namespace blt::gp
if (print_literals) if (print_literals)
{ {
create_indent(out, indent, pretty_print); create_indent(out, indent, pretty_print);
if (program.is_operator_ephemeral(v.id)) if (program.is_operator_ephemeral(v.id()))
{ {
program.get_print_func(v.id)(out, reversed); program.get_print_func(v.id())(out, reversed);
reversed.pop_bytes(stack_allocator::aligned_size(v.type_size)); reversed.pop_bytes(v.type_size());
} else } else
out << name; out << name;
out << return_type << end_indent(pretty_print); out << return_type << end_indent(pretty_print);
@ -153,7 +153,7 @@ namespace blt::gp
for (const auto& op : operations_stack) for (const auto& op : operations_stack)
{ {
if (op.is_value) if (op.is_value())
value_stack.push_back(1); value_stack.push_back(1);
} }
@ -162,7 +162,7 @@ namespace blt::gp
auto operation = operations_stack.back(); auto operation = operations_stack.back();
// keep the last value in the stack on the process stack stored in the eval context, this way it can be accessed easily. // keep the last value in the stack on the process stack stored in the eval context, this way it can be accessed easily.
operations_stack.pop_back(); operations_stack.pop_back();
if (operation.is_value) if (operation.is_value())
{ {
auto d = value_stack.back(); auto d = value_stack.back();
depth = std::max(depth, d); depth = std::max(depth, d);
@ -171,54 +171,54 @@ namespace blt::gp
continue; continue;
} }
size_t local_depth = 0; size_t local_depth = 0;
for (size_t i = 0; i < program.get_operator_info(operation.id).argc.argc; i++) for (size_t i = 0; i < program.get_operator_info(operation.id()).argc.argc; i++)
{ {
local_depth = std::max(local_depth, values_process.back()); local_depth = std::max(local_depth, values_process.back());
values_process.pop_back(); values_process.pop_back();
} }
value_stack.push_back(local_depth + 1); 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);
} }
return depth; return depth;
} }
blt::ptrdiff_t tree_t::find_endpoint(gp_program& program, blt::ptrdiff_t index) const ptrdiff_t tree_t::find_endpoint(gp_program& program, ptrdiff_t start) const
{ {
blt::i64 children_left = 0; i64 children_left = 0;
do do
{ {
const auto& type = program.get_operator_info(operations[index].id); const auto& type = program.get_operator_info(operations[start].id());
// this is a child to someone // this is a child to someone
if (children_left != 0) if (children_left != 0)
children_left--; children_left--;
if (type.argc.argc > 0) if (type.argc.argc > 0)
children_left += type.argc.argc; children_left += type.argc.argc;
index++; start++;
} while (children_left > 0); } while (children_left > 0);
return index; return start;
} }
// this function doesn't work! // this function doesn't work!
blt::ptrdiff_t tree_t::find_parent(gp_program& program, blt::ptrdiff_t index) const ptrdiff_t tree_t::find_parent(gp_program& program, ptrdiff_t start) const
{ {
blt::i64 children_left = 0; i64 children_left = 0;
do do
{ {
if (index == 0) if (start == 0)
return 0; return 0;
const auto& type = program.get_operator_info(operations[index].id); const auto& type = program.get_operator_info(operations[start].id());
if (type.argc.argc > 0) if (type.argc.argc > 0)
children_left -= type.argc.argc; children_left -= type.argc.argc;
children_left++; children_left++;
if (children_left <= 0) if (children_left <= 0)
break; break;
--index; --start;
} while (true); } while (true);
return index; return start;
} }
bool tree_t::check(gp_program& program, void* context) const bool tree_t::check(gp_program& program, void* context) const
@ -228,8 +228,8 @@ namespace blt::gp
for (const auto& op : get_operations()) for (const auto& op : get_operations())
{ {
if (op.is_value) if (op.is_value())
bytes_expected += stack_allocator::aligned_size(op.type_size); bytes_expected += op.type_size();
} }
if (bytes_expected != bytes_size) if (bytes_expected != bytes_size)
@ -252,24 +252,24 @@ namespace blt::gp
for (const auto& operation : iterate(operations).rev()) for (const auto& operation : iterate(operations).rev())
{ {
if (operation.is_value) if (operation.is_value())
{ {
value_stack.transfer_bytes(values_process, operation.type_size); value_stack.transfer_bytes(values_process, operation.type_size());
total_produced += stack_allocator::aligned_size(operation.type_size); total_produced += operation.type_size();
continue; continue;
} }
auto& info = program.get_operator_info(operation.id); auto& info = program.get_operator_info(operation.id());
for (auto& arg : info.argument_types) for (auto& arg : info.argument_types)
total_consumed += stack_allocator::aligned_size(program.get_typesystem().get_type(arg).size()); total_consumed += program.get_typesystem().get_type(arg).size();
program.get_operator_info(operation.id).func(context, values_process, values_process); program.get_operator_info(operation.id()).func(context, values_process, values_process);
total_produced += stack_allocator::aligned_size(program.get_typesystem().get_type(info.return_type).size()); total_produced += program.get_typesystem().get_type(info.return_type).size();
} }
auto v1 = results.values.bytes_in_head(); const auto v1 = results.values.bytes_in_head();
auto v2 = static_cast<blt::ptrdiff_t>(stack_allocator::aligned_size(operations.front().type_size)); const auto v2 = static_cast<ptrdiff_t>(operations.front().type_size());
if (v1 != v2) if (v1 != v2)
{ {
auto vd = std::abs(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("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, 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))); std::abs(static_cast<blt::ptrdiff_t>(total_produced) - static_cast<blt::ptrdiff_t>(total_consumed)));
@ -278,7 +278,7 @@ namespace blt::gp
return true; return true;
} }
void tree_t::find_child_extends(gp_program& program, tracked_vector<child_t>& vec, blt::size_t parent_node, blt::size_t argc) const void tree_t::find_child_extends(gp_program& program, tracked_vector<child_t>& vec, const size_t parent_node, const size_t argc) const
{ {
while (vec.size() < argc) while (vec.size() < argc)
{ {
@ -287,8 +287,8 @@ namespace blt::gp
if (current_point == 0) if (current_point == 0)
{ {
// first child. // first child.
prev = {static_cast<blt::ptrdiff_t>(parent_node + 1), prev = {static_cast<ptrdiff_t>(parent_node + 1),
find_endpoint(program, static_cast<blt::ptrdiff_t>(parent_node + 1))}; find_endpoint(program, static_cast<ptrdiff_t>(parent_node + 1))};
vec.push_back(prev); vec.push_back(prev);
continue; continue;
} else } else

164
tests/symbolic_regression_test.cpp Normal file
View File

@ -0,0 +1,164 @@
/*
* <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 <fstream>
#include <array>
#include <blt/profiling/profiler_v2.h>
static const auto SEED_FUNC = [] { return std::random_device()(); };
std::array crossover_chances = {1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0};
std::array mutation_chances = {0.0, 0.1, 0.2, 0.9, 1.0};
std::array reproduction_chances = {0.0, 1.0, 0.1, 0.9};
std::array elite_amounts = {0, 2, 10, 50};
std::array population_sizes = {50, 500, 5000};
blt::gp::prog_config_t best_config;
double best_fitness = 0;
void run(const blt::gp::prog_config_t& config)
{
// the config is copied into the gp_system so changing the config will not change the runtime of the program.
blt::gp::example::symbolic_regression_t regression{SEED_FUNC, config};
BLT_START_INTERVAL("Symbolic Regression", "Setup Operations");
regression.setup_operations();
BLT_END_INTERVAL("Symbolic Regression", "Setup Operations");
BLT_START_INTERVAL("Symbolic Regression", "Generate Initial Population");
regression.generate_initial_population();
BLT_END_INTERVAL("Symbolic Regression", "Generate Initial Population");
BLT_START_INTERVAL("Symbolic Regression", "Total Generation Loop");
BLT_DEBUG("Begin Generation Loop");
auto& program = regression.get_program();
while (!program.should_terminate())
{
#ifdef BLT_TRACK_ALLOCATIONS
auto cross = crossover_calls.start_measurement();
auto mut = mutation_calls.start_measurement();
auto repo = reproduction_calls.start_measurement();
#endif
BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
BLT_TRACE("Creating next generation");
BLT_START_INTERVAL("Symbolic Regression", "Create Next Generation");
program.create_next_generation();
BLT_END_INTERVAL("Symbolic Regression", "Create Next Generation");
BLT_TRACE("Move to next generation");
BLT_START_INTERVAL("Symbolic Regress", "Move Next Generation");
program.next_generation();
BLT_END_INTERVAL("Symbolic Regress", "Move Next Generation");
BLT_TRACE("Evaluate Fitness");
BLT_START_INTERVAL("Symbolic Regress", "Evaluate Fitness");
program.evaluate_fitness();
BLT_END_INTERVAL("Symbolic Regress", "Evaluate Fitness");
BLT_START_INTERVAL("Symbolic Regress", "Fitness Print");
const auto& stats = program.get_population_stats();
BLT_TRACE("Avg Fit: %lf, Best Fit: %lf, Worst Fit: %lf, Overall Fit: %lf",
stats.average_fitness.load(std::memory_order_relaxed), stats.best_fitness.load(std::memory_order_relaxed),
stats.worst_fitness.load(std::memory_order_relaxed), stats.overall_fitness.load(std::memory_order_relaxed));
BLT_END_INTERVAL("Symbolic Regress", "Fitness Print");
#ifdef BLT_TRACK_ALLOCATIONS
crossover_calls.stop_measurement(cross);
mutation_calls.stop_measurement(mut);
reproduction_calls.stop_measurement(repo);
const auto total = (cross.get_call_difference() * 2) + mut.get_call_difference() + repo.get_call_difference();
BLT_TRACE("Calls Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_call_difference(), mut.get_call_difference(), repo.get_call_difference(), total);
BLT_TRACE("Value Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_value_difference(), mut.get_value_difference(), repo.get_value_difference(), (cross.get_value_difference() * 2 + mut.get_value_difference() + repo.get_value_difference()) - total);
#endif
BLT_TRACE("----------------------------------------------");
std::cout << std::endl;
}
BLT_END_INTERVAL("Symbolic Regression", "Total Generation Loop");
const auto best = program.get_best_individuals<1>();
if (best[0].get().fitness.adjusted_fitness > best_fitness)
{
best_fitness = best[0].get().fitness.adjusted_fitness;
best_config = config;
}
}
int main()
{
std::stringstream results;
for (const auto crossover_chance : crossover_chances)
{
for (const auto mutation_chance : mutation_chances)
{
for (const auto reproduction_chance : reproduction_chances)
{
for (const auto elite_amount : elite_amounts)
{
for (const auto population_sizes : population_sizes)
{
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(elite_amount)
.set_crossover_chance(crossover_chance)
.set_mutation_chance(mutation_chance)
.set_reproduction_chance(reproduction_chance)
.set_max_generations(50)
.set_pop_size(population_sizes)
.set_thread_count(0);
BLT_INFO_STREAM << "Run: Crossover (";
BLT_INFO_STREAM << crossover_chance;
BLT_INFO_STREAM << ") Mutation (";
BLT_INFO_STREAM << mutation_chance;
BLT_INFO_STREAM << ") Reproduction (";
BLT_INFO_STREAM << reproduction_chance;
BLT_INFO_STREAM << ") Elite (";
BLT_INFO_STREAM << elite_amount;
BLT_INFO_STREAM << ") Population Size (";
BLT_INFO_STREAM << population_sizes;
BLT_INFO_STREAM << ")" << "\n";
run(config);
results << "Run: Crossover (";
results << crossover_chance;
results << ") Mutation (";
results << mutation_chance;
results << ") Reproduction (";
results << reproduction_chance;
results << ") Elite (";
results << elite_amount;
results << ") Population Size (";
results << population_sizes;
results << ")" << std::endl;
BLT_WRITE_PROFILE(results, "Symbolic Regression");
results << std::endl;
}
}
}
}
}
std::cout << results.str() << std::endl;
std::cout << "Best Configuration is: " << std::endl;
std::cout << "\tCrossover: " << best_config.crossover_chance << std::endl;
std::cout << "\tMutation: " << best_config.mutation_chance << std::endl;
std::cout << "\tReproduction: " << best_config.reproduction_chance << std::endl;
std::cout << "\tElites: " << best_config.elites << std::endl;
std::cout << "\tPopulation Size: " << best_config.population_size << std::endl;
std::cout << std::endl;
}