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

thread_local stats

pages
Brett 2024-09-02 01:55:15 -04:00
parent ddcad0cbdb
commit 55f5b5bc05
9 changed files with 149 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.25)
project(blt-gp VERSION 0.1.40)
project(blt-gp VERSION 0.1.41)
include(CTest)

6
examples/symbolic_regression.cpp
View File

@ -148,9 +148,9 @@ int main()
auto mutation_allocations_v = blt::gp::mutation_allocations.get_calls();
auto reproduction_calls_v = blt::gp::reproduction_calls.get_calls();
auto reproduction_allocations_v = blt::gp::reproduction_allocations.get_calls();
BLT_TRACE("Total Crossover Calls: %ld Bytes %s", crossover_calls_v, blt::byte_convert_t(blt::gp::crossover_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
BLT_TRACE("Total Mutation Calls: %ld Bytes %s", mutation_calls_v, blt::byte_convert_t(blt::gp::mutation_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
BLT_TRACE("Total Reproduction Calls: %ld Bytes %s", reproduction_calls_v, blt::byte_convert_t(blt::gp::reproduction_calls.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
BLT_TRACE("Total Crossover Calls: %ld", crossover_calls_v);
BLT_TRACE("Total Mutation Calls: %ld", mutation_calls_v);
BLT_TRACE("Total Reproduction Calls: %ld", reproduction_calls_v);
BLT_TRACE("Total Crossover Allocations: %ld Bytes %s", crossover_allocations_v, blt::byte_convert_t(blt::gp::crossover_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
BLT_TRACE("Total Mutation Allocations: %ld Bytes %s", mutation_allocations_v, blt::byte_convert_t(blt::gp::mutation_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());
BLT_TRACE("Total Reproduction Allocations: %ld Bytes %s", reproduction_allocations_v, blt::byte_convert_t(blt::gp::reproduction_allocations.get_value()).convert_to_nearest_type().to_pretty_string().c_str());

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

@ -76,7 +76,7 @@ namespace blt::gp
template<typename T>
using tracked_vector = std::vector<T>;
#endif
// using operation_vector_t = tracked_vector<op_container_t>;
// using individual_vector_t = tracked_vector<individual_t, tracked_allocator_t<individual_t>>;
// using tree_vector_t = tracked_vector<tree_t>;

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

@ -367,8 +367,7 @@ namespace blt::gp
(*thread_execution_service)(0);
#ifdef BLT_TRACK_ALLOCATIONS
blt::gp::tracker.stop_measurement(gen_alloc);
BLT_TRACE("Generation Allocated %ld times with a total of %s", gen_alloc.getAllocationDifference(),
blt::byte_convert_t(gen_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
gen_alloc.pretty_print("Generation");
#endif
}
@ -386,8 +385,7 @@ namespace blt::gp
evaluate_fitness_internal();
#ifdef BLT_TRACK_ALLOCATIONS
blt::gp::tracker.stop_measurement(fitness_alloc);
BLT_TRACE("Fitness Allocated %ld times with a total of %s", fitness_alloc.getAllocationDifference(),
blt::byte_convert_t(fitness_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
fitness_alloc.pretty_print("Fitness");
#endif
}

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

@ -89,7 +89,7 @@ namespace blt::gp
if (random.choice(config.crossover_chance))
{
#ifdef BLT_TRACK_ALLOCATIONS
auto state = tracker.start_measurement();
auto state = tracker.start_measurement_thread_local();
#endif
// crossover
const tree_t* p1;
@ -100,10 +100,12 @@ namespace blt::gp
p2 = &crossover_selection.select(program, current_pop);
} while (!config.crossover.get().apply(program, *p1, *p2, c1, *c2));
#ifdef BLT_TRACK_ALLOCATIONS
tracker.stop_measurement(state);
crossover_calls.call(state.getAllocatedByteDifference());
if (state.getAllocationDifference() != 0)
tracker.stop_measurement_thread_local(state);
crossover_calls.call();
if (state.getAllocatedByteDifference() != 0)
{
crossover_allocations.call(state.getAllocatedByteDifference());
}
#endif
return 2;
}
@ -112,7 +114,7 @@ namespace blt::gp
if (random.choice(config.mutation_chance))
{
#ifdef BLT_TRACK_ALLOCATIONS
auto state = tracker.start_measurement();
auto state = tracker.start_measurement_thread_local();
#endif
// mutation
const tree_t* p;
@ -121,8 +123,8 @@ namespace blt::gp
p = &mutation_selection.select(program, current_pop);
} while (!config.mutator.get().apply(program, *p, c1));
#ifdef BLT_TRACK_ALLOCATIONS
tracker.stop_measurement(state);
mutation_calls.call(state.getAllocatedByteDifference());
tracker.stop_measurement_thread_local(state);
mutation_calls.call();
if (state.getAllocationDifference() != 0)
{
mutation_allocations.call(state.getAllocatedByteDifference());
@ -135,13 +137,13 @@ namespace blt::gp
if (config.reproduction_chance > 0 && random.choice(config.reproduction_chance))
{
#ifdef BLT_TRACK_ALLOCATIONS
auto state = tracker.start_measurement();
auto state = tracker.start_measurement_thread_local();
#endif
// reproduction
c1 = reproduction_selection.select(program, current_pop);
#ifdef BLT_TRACK_ALLOCATIONS
tracker.stop_measurement(state);
reproduction_calls.call(state.getAllocatedByteDifference());
tracker.stop_measurement_thread_local(state);
reproduction_calls.call();
if (state.getAllocationDifference() != 0)
{
reproduction_allocations.call(state.getAllocatedByteDifference());

125
include/blt/gp/stats.h
View File

@ -20,15 +20,60 @@
#define BLT_GP_STATS_H
#include <blt/std/types.h>
#include <atomic>
#include <blt/std/hashmap.h>
#include <blt/std/assert.h>
#include <thread>
#include <cmath>
#include <string>
#include <mutex>
#include <atomic>
namespace blt::gp
{
class allocation_tracker_t
{
public:
class tl_t
{
friend allocation_tracker_t;
public:
[[nodiscard]] blt::u64 getAllocations() const
{
return get_map(allocations);
}
[[nodiscard]] blt::u64 getDeallocations() const
{
return get_map(deallocations);
}
[[nodiscard]] blt::u64 getAllocatedBytes() const
{
return get_map(allocated_bytes);
}
[[nodiscard]] blt::u64 getDeallocatedBytes() const
{
return get_map(deallocated_bytes);
}
[[nodiscard]] blt::u64 getAllocationDifference() const
{
return std::abs(static_cast<blt::i64>(getAllocations()) - static_cast<blt::i64>(getDeallocations()));
}
[[nodiscard]] blt::u64 getCurrentlyAllocatedBytes() const
{
return getAllocatedBytes() - getDeallocatedBytes();
}
private:
blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> allocations;
blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> deallocations;
blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> allocated_bytes;
blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>> deallocated_bytes;
};
struct allocation_data_t
{
blt::u64 start_allocations = 0;
@ -60,18 +105,33 @@ namespace blt::gp
{
return end_deallocated_bytes - start_deallocated_bytes;
}
void pretty_print(const std::string& name) const;
};
void reserve()
{
std::scoped_lock lock(mutex);
tl.allocations[std::this_thread::get_id()] = std::make_unique<blt::u64>();
tl.deallocations[std::this_thread::get_id()] = std::make_unique<blt::u64>();
tl.allocated_bytes[std::this_thread::get_id()] = std::make_unique<blt::u64>();
tl.deallocated_bytes[std::this_thread::get_id()] = std::make_unique<blt::u64>();
}
void allocate(blt::size_t bytes)
{
allocations++;
allocated_bytes += bytes;
add_map(tl.allocations, 1);
add_map(tl.allocated_bytes, bytes);
}
void deallocate(blt::size_t bytes)
{
deallocations++;
deallocated_bytes += bytes;
add_map(tl.deallocations, 1);
add_map(tl.deallocated_bytes, bytes);
}
[[nodiscard]] blt::u64 getAllocations() const
@ -104,29 +164,73 @@ namespace blt::gp
return getAllocatedBytes() - getDeallocatedBytes();
}
allocation_tracker_t::tl_t& get_thread_local()
{
return tl;
}
[[nodiscard]] allocation_data_t start_measurement() const
{
allocation_data_t data{};
data.start_allocations = allocations;
data.start_deallocations = deallocations;
data.start_allocated_bytes = allocated_bytes;
data.start_deallocated_bytes = deallocated_bytes;
data.start_allocations = getAllocations();
data.start_deallocations = getDeallocations();
data.start_allocated_bytes = getAllocatedBytes();
data.start_deallocated_bytes = getDeallocatedBytes();
return data;
}
[[nodiscard]] allocation_data_t start_measurement_thread_local() const
{
allocation_data_t data{};
data.start_allocations = tl.getAllocations();
data.start_deallocations = tl.getDeallocations();
data.start_allocated_bytes = tl.getAllocatedBytes();
data.start_deallocated_bytes = tl.getDeallocatedBytes();
return data;
}
void stop_measurement(allocation_data_t& data) const
{
data.end_allocations = allocations;
data.end_deallocations = deallocations;
data.end_allocated_bytes = allocated_bytes;
data.end_deallocated_bytes = deallocated_bytes;
data.end_allocations = getAllocations();
data.end_deallocations = getDeallocations();
data.end_allocated_bytes = getAllocatedBytes();
data.end_deallocated_bytes = getDeallocatedBytes();
}
void stop_measurement_thread_local(allocation_data_t& data) const
{
data.end_allocations = tl.getAllocations();
data.end_deallocations = tl.getDeallocations();
data.end_allocated_bytes = tl.getAllocatedBytes();
data.end_deallocated_bytes = tl.getDeallocatedBytes();
}
private:
static void add_map(blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>>& map, blt::u64 value)
{
auto l = map.find(std::this_thread::get_id());
if (l == map.end())
BLT_ABORT("Thread doesn't exist inside this map!");
auto& v = *l->second;
v += value;
}
static blt::u64 get_map(const blt::hashmap_t<std::thread::id, std::unique_ptr<blt::u64>>& map)
{
auto l = map.find(std::this_thread::get_id());
if (l == map.end())
BLT_ABORT("Thread doesn't exist inside this map!");
return *l->second;
}
tl_t tl;
std::atomic_uint64_t allocations = 0;
std::atomic_uint64_t deallocations = 0;
std::atomic_uint64_t allocated_bytes = 0;
std::atomic_uint64_t deallocated_bytes = 0;
std::mutex mutex;
};
class call_tracker_t
@ -190,7 +294,6 @@ namespace blt::gp
std::atomic_uint64_t primary_calls = 0;
std::atomic_uint64_t secondary_value = 0;
};
}
#endif //BLT_GP_STATS_H

6
src/program.cpp
View File

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

8
src/stats.cpp
View File

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

3
src/transformers.cpp
View File

@ -105,6 +105,9 @@ namespace blt::gp
auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
c1_stack.reserve(c1_stack.bytes_in_head() - c1_stack_for_bytes + c2_stack_for_bytes);
c2_stack.reserve(c2_stack.bytes_in_head() - c2_stack_for_bytes + c1_stack_for_bytes);
c1_stack.copy_to(copy_ptr_c1, c1_total);
c1_stack.pop_bytes(c1_total);