1076 lines
39 KiB
C++
1076 lines
39 KiB
C++
/*
|
|
* <Short Description>
|
|
* 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/>.
|
|
*/
|
|
#include <lilfbtf/test3.h>
|
|
#include <blt/std/array.h>
|
|
#include "blt/std/utility.h"
|
|
#include "blt/std/logging.h"
|
|
#include "blt/std/allocator.h"
|
|
#include "blt/profiling/profiler_v2.h"
|
|
#include <lilfbtf/test2.h>
|
|
#include <stack>
|
|
#include <any>
|
|
#include <utility>
|
|
#include <variant>
|
|
|
|
namespace fb
|
|
{
|
|
using TYPE = double;
|
|
|
|
class func_base_t
|
|
{
|
|
private:
|
|
blt::size_t argc_ = 0;
|
|
std::function<void(func_base_t& us, blt::span<TYPE> args)> func;
|
|
protected:
|
|
TYPE value = 0;
|
|
public:
|
|
explicit func_base_t(blt::size_t argc, std::function<void(func_base_t& us, blt::span<TYPE> args)> func):
|
|
argc_(argc), func(std::move(func))
|
|
{}
|
|
|
|
[[nodiscard]] inline blt::size_t argc() const
|
|
{ return argc_; }
|
|
|
|
[[nodiscard]] inline TYPE getValue() const
|
|
{
|
|
return value;
|
|
}
|
|
|
|
inline func_base_t setValue(TYPE val)
|
|
{
|
|
this->value = val;
|
|
return *this;
|
|
}
|
|
|
|
inline void call(blt::span<TYPE> args)
|
|
{
|
|
func(*this, args);
|
|
};
|
|
|
|
~func_base_t() = default;
|
|
};
|
|
|
|
class func_ref_base_t
|
|
{
|
|
private:
|
|
blt::size_t argc_ = 0;
|
|
std::function<void(func_ref_base_t& us, blt::span<TYPE> args)>& func;
|
|
protected:
|
|
TYPE value = 0;
|
|
public:
|
|
explicit func_ref_base_t(blt::size_t argc, std::function<void(func_ref_base_t& us, blt::span<TYPE> args)>& func):
|
|
argc_(argc), func(func)
|
|
{}
|
|
|
|
[[nodiscard]] inline blt::size_t argc() const
|
|
{ return argc_; }
|
|
|
|
[[nodiscard]] inline TYPE getValue() const
|
|
{
|
|
return value;
|
|
}
|
|
|
|
inline func_ref_base_t setValue(TYPE val)
|
|
{
|
|
this->value = val;
|
|
return *this;
|
|
}
|
|
|
|
inline void call(blt::span<TYPE> args)
|
|
{
|
|
func(*this, args);
|
|
};
|
|
|
|
~func_ref_base_t() = default;
|
|
};
|
|
using func_ref_t = std::function<void(func_ref_base_t&, blt::span<TYPE>)>;
|
|
|
|
class func_ref_any_base_t
|
|
{
|
|
private:
|
|
blt::size_t argc_ = 0;
|
|
std::function<void(func_ref_any_base_t& us, blt::span<std::any> args)>& func;
|
|
protected:
|
|
std::any value;
|
|
public:
|
|
explicit func_ref_any_base_t(blt::size_t argc, std::function<void(func_ref_any_base_t& us, blt::span<std::any> args)>& func):
|
|
argc_(argc), func(func)
|
|
{}
|
|
|
|
[[nodiscard]] inline blt::size_t argc() const
|
|
{ return argc_; }
|
|
|
|
[[nodiscard]] inline std::any getValue() const
|
|
{
|
|
return value;
|
|
}
|
|
|
|
inline func_ref_any_base_t& setValue(std::any val)
|
|
{
|
|
this->value = std::move(val);
|
|
return *this;
|
|
}
|
|
|
|
inline void call(blt::span<std::any> args)
|
|
{
|
|
func(*this, args);
|
|
};
|
|
|
|
~func_ref_any_base_t() = default;
|
|
};
|
|
using func_ref_any_t = std::function<void(func_ref_any_base_t&, blt::span<std::any>)>;
|
|
|
|
class base_t
|
|
{
|
|
private:
|
|
blt::size_t argc_ = 0;
|
|
protected:
|
|
TYPE value = 0;
|
|
public:
|
|
explicit base_t(blt::size_t argc): argc_(argc)
|
|
{}
|
|
|
|
[[nodiscard]] inline blt::size_t argc() const
|
|
{ return argc_; }
|
|
|
|
[[nodiscard]] inline TYPE getValue() const
|
|
{
|
|
return value;
|
|
}
|
|
|
|
inline virtual void call(blt::span<TYPE> args) = 0;
|
|
|
|
virtual ~base_t() = default;
|
|
};
|
|
|
|
class add_t : public base_t
|
|
{
|
|
public:
|
|
add_t(): base_t(2)
|
|
{}
|
|
|
|
inline void call(blt::span<TYPE> args) final
|
|
{
|
|
value = args[0] + args[1];
|
|
}
|
|
};
|
|
|
|
class sub_t : public base_t
|
|
{
|
|
public:
|
|
sub_t(): base_t(2)
|
|
{}
|
|
|
|
inline void call(blt::span<TYPE> args) final
|
|
{
|
|
value = args[0] - args[1];
|
|
}
|
|
};
|
|
|
|
class mul_t : public base_t
|
|
{
|
|
public:
|
|
mul_t(): base_t(2)
|
|
{}
|
|
|
|
inline void call(blt::span<TYPE> args) final
|
|
{
|
|
value = args[0] * args[1];
|
|
}
|
|
};
|
|
|
|
class div_t : public base_t
|
|
{
|
|
public:
|
|
div_t(): base_t(2)
|
|
{}
|
|
|
|
inline void call(blt::span<TYPE> args) final
|
|
{
|
|
if (args[1] == 0)
|
|
value = 0;
|
|
else
|
|
value = args[0] / args[1];
|
|
}
|
|
};
|
|
|
|
class value_t : public base_t
|
|
{
|
|
public:
|
|
value_t(): base_t(0)
|
|
{
|
|
value = random_value();
|
|
}
|
|
|
|
inline void call(blt::span<TYPE>) final
|
|
{}
|
|
};
|
|
|
|
blt::bump_allocator<blt::BLT_2MB_SIZE, true> alloc;
|
|
|
|
inline func_ref_t add_function = [](func_ref_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] + args[1]);
|
|
};
|
|
inline func_ref_t sub_function = [](func_ref_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] - args[1]);
|
|
};
|
|
inline func_ref_t mul_function = [](func_ref_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] * args[1]);
|
|
};
|
|
inline func_ref_t div_function = [](func_ref_base_t& us, blt::span<TYPE> args) {
|
|
if (args[1] == 0)
|
|
us.setValue(0);
|
|
else
|
|
us.setValue(args[0] / args[1]);
|
|
};
|
|
inline func_ref_t value_function = [](auto&, auto) {};
|
|
|
|
inline func_ref_any_t add_function_any = [](func_ref_any_base_t& us, blt::span<std::any> args) {
|
|
us.setValue(std::any_cast<double>(args[0]) + std::any_cast<double>(args[1]));
|
|
};
|
|
inline func_ref_any_t sub_function_any = [](func_ref_any_base_t& us, blt::span<std::any> args) {
|
|
us.setValue(std::any_cast<double>(args[0]) - std::any_cast<double>(args[1]));
|
|
};
|
|
inline func_ref_any_t mul_function_any = [](func_ref_any_base_t& us, blt::span<std::any> args) {
|
|
us.setValue(std::any_cast<double>(args[0]) * std::any_cast<double>(args[1]));
|
|
};
|
|
inline func_ref_any_t div_function_any = [](func_ref_any_base_t& us, blt::span<std::any> args) {
|
|
if (std::any_cast<double>(args[1]) == 0)
|
|
us.setValue(0.0);
|
|
else
|
|
us.setValue(std::any_cast<double>(args[0]) / std::any_cast<double>(args[1]));
|
|
};
|
|
inline func_ref_any_t value_function_any = [](auto&, auto) {};
|
|
|
|
base_t* create_node_type(type_t i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case type_t::ADD:
|
|
return alloc.emplace<add_t>();
|
|
case type_t::SUB:
|
|
return alloc.emplace<sub_t>();
|
|
case type_t::MUL:
|
|
return alloc.emplace<mul_t>();
|
|
case type_t::DIV:
|
|
return alloc.emplace<div_t>();
|
|
case type_t::VALUE:
|
|
return alloc.emplace<value_t>();
|
|
default:
|
|
BLT_ERROR("Hey maybe something weird is going on here");
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
func_base_t create_node_func_type(type_t i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case type_t::ADD:
|
|
return func_base_t(2, [](func_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] + args[1]);
|
|
});
|
|
case type_t::SUB:
|
|
return func_base_t(2, [](func_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] - args[1]);
|
|
});
|
|
case type_t::MUL:
|
|
return func_base_t(2, [](func_base_t& us, blt::span<TYPE> args) {
|
|
us.setValue(args[0] * args[1]);
|
|
});
|
|
case type_t::DIV:
|
|
return func_base_t(2, [](func_base_t& us, blt::span<TYPE> args) {
|
|
if (args[1] == 0)
|
|
us.setValue(0);
|
|
else
|
|
us.setValue(args[0] / args[1]);
|
|
});
|
|
case type_t::VALUE:
|
|
return func_base_t(0, [](func_base_t&, blt::span<TYPE>) {
|
|
|
|
}).setValue(random_value());
|
|
default:
|
|
BLT_ERROR("Hey maybe something weird is going on here");
|
|
return func_base_t{0, [](auto, auto) {}};
|
|
}
|
|
}
|
|
|
|
func_ref_base_t create_node_func_ref_type(type_t i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case type_t::ADD:
|
|
return func_ref_base_t(2, add_function);
|
|
case type_t::SUB:
|
|
return func_ref_base_t(2, sub_function);
|
|
case type_t::MUL:
|
|
return func_ref_base_t(2, mul_function);
|
|
case type_t::DIV:
|
|
return func_ref_base_t(2, div_function);
|
|
case type_t::VALUE:
|
|
return func_ref_base_t(0, value_function).setValue(random_value());
|
|
default:
|
|
BLT_ERROR("Hey maybe something weird is going on here");
|
|
return func_ref_base_t(0, value_function);
|
|
}
|
|
}
|
|
|
|
func_ref_any_base_t create_node_func_ref_any_type(type_t i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case type_t::ADD:
|
|
return func_ref_any_base_t(2, add_function_any);
|
|
case type_t::SUB:
|
|
return func_ref_any_base_t(2, sub_function_any);
|
|
case type_t::MUL:
|
|
return func_ref_any_base_t(2, mul_function_any);
|
|
case type_t::DIV:
|
|
return func_ref_any_base_t(2, div_function_any);
|
|
case type_t::VALUE:
|
|
return func_ref_any_base_t(0, value_function_any).setValue(random_value());
|
|
default:
|
|
BLT_ERROR("Hey maybe something weird is going on here");
|
|
return func_ref_any_base_t(0, value_function_any);
|
|
}
|
|
}
|
|
|
|
class tree2
|
|
{
|
|
private:
|
|
struct node_t
|
|
{
|
|
base_t* type;
|
|
std::array<node_t*, 2> children{nullptr};
|
|
|
|
explicit node_t(type_t type): type(create_node_type(type))
|
|
{}
|
|
|
|
void evaluate()
|
|
{
|
|
if (type->argc() > 0)
|
|
{
|
|
TYPE v1 = children[0]->type->getValue();
|
|
TYPE v2 = children[1]->type->getValue();
|
|
TYPE d[2]{v1, v2};
|
|
type->call(blt::span{d});
|
|
} else
|
|
type->call({});
|
|
}
|
|
|
|
double evaluate_tree()
|
|
{
|
|
std::stack<node_t*> nodes;
|
|
std::stack<node_t*> node_stack;
|
|
|
|
nodes.push(this);
|
|
|
|
while (!nodes.empty())
|
|
{
|
|
auto* top = nodes.top();
|
|
node_stack.push(top);
|
|
nodes.pop();
|
|
for (blt::size_t i = 0; i < top->type->argc(); i++)
|
|
nodes.push(top->children[i]);
|
|
}
|
|
|
|
while (!node_stack.empty())
|
|
{
|
|
node_stack.top()->evaluate();
|
|
node_stack.pop();
|
|
}
|
|
return type->getValue();
|
|
}
|
|
|
|
~node_t()
|
|
{
|
|
for (blt::size_t i = 0; i < type->argc(); i++)
|
|
{
|
|
alloc.destroy(children[i]);
|
|
alloc.deallocate(children[i]);
|
|
}
|
|
alloc.destroy(type);
|
|
alloc.deallocate(type);
|
|
}
|
|
};
|
|
|
|
node_t* root = nullptr;
|
|
public:
|
|
|
|
void create(blt::u64 size)
|
|
{
|
|
root = alloc.template emplace<node_t>(random_type());
|
|
std::stack<std::pair<node_t*, blt::size_t>> stack;
|
|
stack.emplace(root, 0);
|
|
while (!stack.empty())
|
|
{
|
|
auto top = stack.top();
|
|
auto* node = top.first;
|
|
auto depth = top.second;
|
|
//BLT_WARN("gen type %ld with argc: %ld", node->type, node->argc);
|
|
stack.pop();
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
for (blt::size_t i = 0; i < node->type->argc(); i++)
|
|
{
|
|
if (depth >= size)
|
|
{
|
|
node->children[i] = alloc.template emplace<node_t>(type_t::VALUE);
|
|
//BLT_INFO("Skipping due to size, value %lf", node->children[i]->value);
|
|
continue;
|
|
}
|
|
if (choice())
|
|
node->children[i] = alloc.template emplace<node_t>(random_type());
|
|
else
|
|
node->children[i] = alloc.template emplace<node_t>(random_type_sub());
|
|
//BLT_INFO("child %p to %p has type generated %ld with argc %d, value %lf", node->children[i], node,
|
|
// static_cast<int>(node->children[i]->type), node->children[i]->argc, node->children[i]->value);
|
|
if (depth < size)
|
|
stack.emplace(node->children[i], depth + 1);
|
|
}
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
}
|
|
// BLT_INFO("We have %ld adds, %ld subs, %ld mul, %ld div, %ld val, == %ld", t1_add, t1_sub, t1_mul, t1_div, t1_val,
|
|
// t1_add + t1_sub + t1_mul + t1_val + t1_div);
|
|
}
|
|
|
|
double evaluate()
|
|
{
|
|
return root->evaluate_tree();
|
|
}
|
|
|
|
~tree2()
|
|
{
|
|
BLT_START_INTERVAL("Tree Destruction", "Inheritance Tree");
|
|
alloc.destroy(root);
|
|
alloc.deallocate(root);
|
|
BLT_END_INTERVAL("Tree Destruction", "Inheritance Tree");
|
|
}
|
|
};
|
|
|
|
class tree3
|
|
{
|
|
private:
|
|
struct node_t
|
|
{
|
|
base_t* type = nullptr;
|
|
node_t** children = nullptr;
|
|
|
|
explicit node_t(type_t type): type(create_node_type(type))
|
|
{
|
|
if (this->type == nullptr)
|
|
throw std::bad_alloc();
|
|
else if (reinterpret_cast<blt::size_t>(this->type) % alignof(base_t*) != 0)
|
|
BLT_WARN("type pointer %p is misaligned, expecting alignment of %ld reminder %ld", this->type, alignof(base_t*),
|
|
reinterpret_cast<blt::size_t>(this->type) % alignof(base_t*));
|
|
children = alloc.emplace_many<node_t*>(this->type->argc());
|
|
for (blt::size_t i = 0; i < this->type->argc(); i++)
|
|
children[i] = nullptr;
|
|
if (reinterpret_cast<blt::size_t>(this->children) % alignof(node_t**) != 0)
|
|
BLT_WARN("children pointer is misaligned, expecting alignment of %ld remainder %ld", this->children, alignof(node_t**),
|
|
reinterpret_cast<blt::size_t>(this->children) % alignof(node_t**));
|
|
}
|
|
|
|
void evaluate() const
|
|
{
|
|
if (type->argc() > 0)
|
|
{
|
|
TYPE v1 = children[0]->type->getValue();
|
|
TYPE v2 = children[1]->type->getValue();
|
|
TYPE d[2]{v1, v2};
|
|
type->call(blt::span{d});
|
|
} else
|
|
type->call({});
|
|
}
|
|
|
|
double evaluate_tree()
|
|
{
|
|
std::stack<node_t*> nodes;
|
|
std::stack<node_t*> node_stack;
|
|
|
|
nodes.push(this);
|
|
|
|
while (!nodes.empty())
|
|
{
|
|
auto* top = nodes.top();
|
|
node_stack.push(top);
|
|
nodes.pop();
|
|
for (blt::size_t i = 0; i < top->type->argc(); i++)
|
|
nodes.push(top->children[i]);
|
|
}
|
|
|
|
while (!node_stack.empty())
|
|
{
|
|
node_stack.top()->evaluate();
|
|
node_stack.pop();
|
|
}
|
|
return type->getValue();
|
|
}
|
|
|
|
~node_t()
|
|
{
|
|
for (blt::size_t i = 0; i < type->argc(); i++)
|
|
{
|
|
alloc.destroy(children[i]);
|
|
alloc.deallocate(children[i]);
|
|
}
|
|
alloc.deallocate(children);
|
|
alloc.destroy(type);
|
|
alloc.deallocate(type);
|
|
}
|
|
};
|
|
|
|
node_t* root = nullptr;
|
|
public:
|
|
tree3()
|
|
{
|
|
// BLT_INFO(alignof(node_t*));
|
|
// BLT_TRACE(alignof(node_t*[2]));
|
|
// BLT_DEBUG(alignof(node_t*[3]));
|
|
// BLT_INFO(sizeof(node_t*));
|
|
// std::exit(0);
|
|
}
|
|
|
|
void create(blt::u64 size)
|
|
{
|
|
root = alloc.template emplace<node_t>(random_type());
|
|
std::stack<std::pair<node_t*, blt::size_t>> stack;
|
|
stack.emplace(root, 0);
|
|
while (!stack.empty())
|
|
{
|
|
auto top = stack.top();
|
|
auto* node = top.first;
|
|
auto depth = top.second;
|
|
//BLT_WARN("gen type %ld with argc: %ld", node->type, node->argc);
|
|
stack.pop();
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
for (blt::size_t i = 0; i < node->type->argc(); i++)
|
|
{
|
|
if (depth >= size)
|
|
{
|
|
node->children[i] = alloc.template emplace<node_t>(type_t::VALUE);
|
|
//BLT_INFO("Skipping due to size, value %lf", node->children[i]->value);
|
|
continue;
|
|
}
|
|
if (choice())
|
|
node->children[i] = alloc.template emplace<node_t>(random_type());
|
|
else
|
|
node->children[i] = alloc.template emplace<node_t>(random_type_sub());
|
|
//BLT_INFO("child %p to %p has type generated %ld with argc %d, value %lf", node->children[i], node,
|
|
// static_cast<int>(node->children[i]->type), node->children[i]->argc, node->children[i]->value);
|
|
if (depth < size)
|
|
stack.emplace(node->children[i], depth + 1);
|
|
}
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
}
|
|
// BLT_INFO("We have %ld adds, %ld subs, %ld mul, %ld div, %ld val, == %ld", t1_add, t1_sub, t1_mul, t1_div, t1_val,
|
|
// t1_add + t1_sub + t1_mul + t1_val + t1_div);
|
|
}
|
|
|
|
double evaluate()
|
|
{
|
|
return root->evaluate_tree();
|
|
}
|
|
|
|
~tree3()
|
|
{
|
|
BLT_START_INTERVAL("Tree Destruction", "Inheritance Tree v2");
|
|
alloc.destroy(root);
|
|
alloc.deallocate(root);
|
|
BLT_END_INTERVAL("Tree Destruction", "Inheritance Tree v2");
|
|
}
|
|
};
|
|
|
|
class tree4
|
|
{
|
|
private:
|
|
struct node_t
|
|
{
|
|
func_base_t type;
|
|
node_t** children = nullptr;
|
|
|
|
explicit node_t(type_t type): type(create_node_func_type(type))
|
|
{
|
|
children = alloc.emplace_many<node_t*>(this->type.argc());
|
|
for (blt::size_t i = 0; i < this->type.argc(); i++)
|
|
children[i] = nullptr;
|
|
}
|
|
|
|
void evaluate()
|
|
{
|
|
if (type.argc() > 0)
|
|
{
|
|
TYPE v1 = children[0]->type.getValue();
|
|
TYPE v2 = children[1]->type.getValue();
|
|
TYPE d[2]{v1, v2};
|
|
type.call(blt::span{d});
|
|
} else
|
|
type.call({});
|
|
}
|
|
|
|
double evaluate_tree()
|
|
{
|
|
std::stack<node_t*> nodes;
|
|
std::stack<node_t*> node_stack;
|
|
|
|
nodes.push(this);
|
|
|
|
while (!nodes.empty())
|
|
{
|
|
auto* top = nodes.top();
|
|
node_stack.push(top);
|
|
nodes.pop();
|
|
for (blt::size_t i = 0; i < top->type.argc(); i++)
|
|
nodes.push(top->children[i]);
|
|
}
|
|
|
|
while (!node_stack.empty())
|
|
{
|
|
node_stack.top()->evaluate();
|
|
node_stack.pop();
|
|
}
|
|
return type.getValue();
|
|
}
|
|
|
|
~node_t()
|
|
{
|
|
for (blt::size_t i = 0; i < type.argc(); i++)
|
|
{
|
|
alloc.destroy(children[i]);
|
|
alloc.deallocate(children[i]);
|
|
}
|
|
alloc.deallocate(children);
|
|
}
|
|
};
|
|
|
|
node_t* root = nullptr;
|
|
public:
|
|
tree4()
|
|
{}
|
|
|
|
void create(blt::u64 size)
|
|
{
|
|
root = alloc.template emplace<node_t>(random_type());
|
|
std::stack<std::pair<node_t*, blt::size_t>> stack;
|
|
stack.emplace(root, 0);
|
|
while (!stack.empty())
|
|
{
|
|
auto top = stack.top();
|
|
auto* node = top.first;
|
|
auto depth = top.second;
|
|
//BLT_WARN("gen type %ld with argc: %ld", node->type, node->argc);
|
|
stack.pop();
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
for (blt::size_t i = 0; i < node->type.argc(); i++)
|
|
{
|
|
if (depth >= size)
|
|
{
|
|
node->children[i] = alloc.template emplace<node_t>(type_t::VALUE);
|
|
//BLT_INFO("Skipping due to size, value %lf", node->children[i]->value);
|
|
continue;
|
|
}
|
|
if (choice())
|
|
node->children[i] = alloc.template emplace<node_t>(random_type());
|
|
else
|
|
node->children[i] = alloc.template emplace<node_t>(random_type_sub());
|
|
//BLT_INFO("child %p to %p has type generated %ld with argc %d, value %lf", node->children[i], node,
|
|
// static_cast<int>(node->children[i]->type), node->children[i]->argc, node->children[i]->value);
|
|
if (depth < size)
|
|
stack.emplace(node->children[i], depth + 1);
|
|
}
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
}
|
|
// BLT_INFO("We have %ld adds, %ld subs, %ld mul, %ld div, %ld val, == %ld", t1_add, t1_sub, t1_mul, t1_div, t1_val,
|
|
// t1_add + t1_sub + t1_mul + t1_val + t1_div);
|
|
}
|
|
|
|
double evaluate()
|
|
{
|
|
return root->evaluate_tree();
|
|
}
|
|
|
|
~tree4()
|
|
{
|
|
BLT_START_INTERVAL("Tree Destruction", "Inheritance Tree v3");
|
|
alloc.destroy(root);
|
|
alloc.deallocate(root);
|
|
BLT_END_INTERVAL("Tree Destruction", "Inheritance Tree v3");
|
|
}
|
|
};
|
|
|
|
class tree5
|
|
{
|
|
private:
|
|
struct node_t
|
|
{
|
|
func_ref_base_t type;
|
|
node_t** children = nullptr;
|
|
|
|
explicit node_t(type_t type): type(create_node_func_ref_type(type))
|
|
{
|
|
children = alloc.emplace_many<node_t*>(this->type.argc());
|
|
for (blt::size_t i = 0; i < this->type.argc(); i++)
|
|
children[i] = nullptr;
|
|
}
|
|
|
|
void evaluate()
|
|
{
|
|
if (type.argc() > 0)
|
|
{
|
|
TYPE v1 = children[0]->type.getValue();
|
|
TYPE v2 = children[1]->type.getValue();
|
|
TYPE d[2]{v1, v2};
|
|
type.call(blt::span{d});
|
|
} else
|
|
type.call({});
|
|
}
|
|
|
|
double evaluate_tree()
|
|
{
|
|
std::stack<node_t*> nodes;
|
|
std::stack<node_t*> node_stack;
|
|
|
|
nodes.push(this);
|
|
|
|
while (!nodes.empty())
|
|
{
|
|
auto* top = nodes.top();
|
|
node_stack.push(top);
|
|
nodes.pop();
|
|
for (blt::size_t i = 0; i < top->type.argc(); i++)
|
|
nodes.push(top->children[i]);
|
|
}
|
|
|
|
while (!node_stack.empty())
|
|
{
|
|
node_stack.top()->evaluate();
|
|
node_stack.pop();
|
|
}
|
|
return type.getValue();
|
|
}
|
|
|
|
~node_t()
|
|
{
|
|
for (blt::size_t i = 0; i < type.argc(); i++)
|
|
{
|
|
alloc.destroy(children[i]);
|
|
alloc.deallocate(children[i]);
|
|
}
|
|
alloc.deallocate(children);
|
|
}
|
|
};
|
|
|
|
node_t* root = nullptr;
|
|
public:
|
|
tree5()
|
|
{}
|
|
|
|
void create(blt::u64 size)
|
|
{
|
|
root = alloc.template emplace<node_t>(random_type());
|
|
std::stack<std::pair<node_t*, blt::size_t>> stack;
|
|
stack.emplace(root, 0);
|
|
while (!stack.empty())
|
|
{
|
|
auto top = stack.top();
|
|
auto* node = top.first;
|
|
auto depth = top.second;
|
|
//BLT_WARN("gen type %ld with argc: %ld", node->type, node->argc);
|
|
stack.pop();
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
for (blt::size_t i = 0; i < node->type.argc(); i++)
|
|
{
|
|
if (depth >= size)
|
|
{
|
|
node->children[i] = alloc.template emplace<node_t>(type_t::VALUE);
|
|
//BLT_INFO("Skipping due to size, value %lf", node->children[i]->value);
|
|
continue;
|
|
}
|
|
if (choice())
|
|
node->children[i] = alloc.template emplace<node_t>(random_type());
|
|
else
|
|
node->children[i] = alloc.template emplace<node_t>(random_type_sub());
|
|
//BLT_INFO("child %p to %p has type generated %ld with argc %d, value %lf", node->children[i], node,
|
|
// static_cast<int>(node->children[i]->type), node->children[i]->argc, node->children[i]->value);
|
|
if (depth < size)
|
|
stack.emplace(node->children[i], depth + 1);
|
|
}
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
}
|
|
// BLT_INFO("We have %ld adds, %ld subs, %ld mul, %ld div, %ld val, == %ld", t1_add, t1_sub, t1_mul, t1_div, t1_val,
|
|
// t1_add + t1_sub + t1_mul + t1_val + t1_div);
|
|
}
|
|
|
|
double evaluate()
|
|
{
|
|
return root->evaluate_tree();
|
|
}
|
|
|
|
~tree5()
|
|
{
|
|
BLT_START_INTERVAL("Tree Destruction", "Inheritance Tree v4");
|
|
alloc.destroy(root);
|
|
alloc.deallocate(root);
|
|
BLT_END_INTERVAL("Tree Destruction", "Inheritance Tree v4");
|
|
}
|
|
};
|
|
|
|
class tree6
|
|
{
|
|
private:
|
|
struct node_t
|
|
{
|
|
func_ref_any_base_t type;
|
|
node_t** children = nullptr;
|
|
|
|
explicit node_t(type_t type): type(create_node_func_ref_any_type(type))
|
|
{
|
|
children = alloc.emplace_many<node_t*>(this->type.argc());
|
|
for (blt::size_t i = 0; i < this->type.argc(); i++)
|
|
children[i] = nullptr;
|
|
}
|
|
|
|
void evaluate()
|
|
{
|
|
if (type.argc() > 0)
|
|
{
|
|
std::any v1 = children[0]->type.getValue();
|
|
std::any v2 = children[1]->type.getValue();
|
|
std::any d[2]{v1, v2};
|
|
type.call(blt::span{d});
|
|
} else
|
|
type.call({});
|
|
}
|
|
|
|
double evaluate_tree()
|
|
{
|
|
std::stack<node_t*> nodes;
|
|
std::stack<node_t*> node_stack;
|
|
|
|
nodes.push(this);
|
|
|
|
while (!nodes.empty())
|
|
{
|
|
auto* top = nodes.top();
|
|
node_stack.push(top);
|
|
nodes.pop();
|
|
for (blt::size_t i = 0; i < top->type.argc(); i++)
|
|
nodes.push(top->children[i]);
|
|
}
|
|
|
|
while (!node_stack.empty())
|
|
{
|
|
node_stack.top()->evaluate();
|
|
node_stack.pop();
|
|
}
|
|
return std::any_cast<double>(type.getValue());
|
|
}
|
|
|
|
~node_t()
|
|
{
|
|
for (blt::size_t i = 0; i < type.argc(); i++)
|
|
{
|
|
alloc.destroy(children[i]);
|
|
alloc.deallocate(children[i]);
|
|
}
|
|
alloc.deallocate(children);
|
|
}
|
|
};
|
|
|
|
node_t* root = nullptr;
|
|
public:
|
|
tree6()
|
|
{}
|
|
|
|
void create(blt::u64 size)
|
|
{
|
|
root = alloc.template emplace<node_t>(random_type());
|
|
std::stack<std::pair<node_t*, blt::size_t>> stack;
|
|
stack.emplace(root, 0);
|
|
while (!stack.empty())
|
|
{
|
|
auto top = stack.top();
|
|
auto* node = top.first;
|
|
auto depth = top.second;
|
|
//BLT_WARN("gen type %ld with argc: %ld", node->type, node->argc);
|
|
stack.pop();
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
for (blt::size_t i = 0; i < node->type.argc(); i++)
|
|
{
|
|
if (depth >= size)
|
|
{
|
|
node->children[i] = alloc.template emplace<node_t>(type_t::VALUE);
|
|
//BLT_INFO("Skipping due to size, value %lf", node->children[i]->value);
|
|
continue;
|
|
}
|
|
if (choice())
|
|
node->children[i] = alloc.template emplace<node_t>(random_type());
|
|
else
|
|
node->children[i] = alloc.template emplace<node_t>(random_type_sub());
|
|
//BLT_INFO("child %p to %p has type generated %ld with argc %d, value %lf", node->children[i], node,
|
|
// static_cast<int>(node->children[i]->type), node->children[i]->argc, node->children[i]->value);
|
|
if (depth < size)
|
|
stack.emplace(node->children[i], depth + 1);
|
|
}
|
|
//BLT_TRACE0_STREAM << "Size: " << stack.size() << "\n";
|
|
}
|
|
// BLT_INFO("We have %ld adds, %ld subs, %ld mul, %ld div, %ld val, == %ld", t1_add, t1_sub, t1_mul, t1_div, t1_val,
|
|
// t1_add + t1_sub + t1_mul + t1_val + t1_div);
|
|
}
|
|
|
|
double evaluate()
|
|
{
|
|
return root->evaluate_tree();
|
|
}
|
|
|
|
~tree6()
|
|
{
|
|
BLT_START_INTERVAL("Tree Destruction", "Inheritance Tree v5");
|
|
alloc.destroy(root);
|
|
alloc.deallocate(root);
|
|
BLT_END_INTERVAL("Tree Destruction", "Inheritance Tree v5");
|
|
}
|
|
};
|
|
|
|
void run()
|
|
{
|
|
constexpr auto size = 512;
|
|
constexpr auto tree_size = 17;
|
|
engine.reset();
|
|
tree2 love[size];
|
|
BLT_START_INTERVAL("Tree Construction", "Inheritance Tree");
|
|
for (auto& i : love)
|
|
i.create(tree_size);
|
|
BLT_END_INTERVAL("Tree Construction", "Inheritance Tree");
|
|
BLT_START_INTERVAL("Tree Evaluation", "Inheritance Tree");
|
|
for (auto& i : love)
|
|
blt::black_box(i.evaluate());
|
|
BLT_END_INTERVAL("Tree Evaluation", "Inheritance Tree");
|
|
}
|
|
|
|
void run2()
|
|
{
|
|
constexpr auto size = 512;
|
|
constexpr auto tree_size = 17;
|
|
engine.reset();
|
|
tree3 love[size];
|
|
BLT_START_INTERVAL("Tree Construction", "Inheritance Tree v2");
|
|
for (auto& i : love)
|
|
i.create(tree_size);
|
|
BLT_END_INTERVAL("Tree Construction", "Inheritance Tree v2");
|
|
BLT_START_INTERVAL("Tree Evaluation", "Inheritance Tree v2");
|
|
for (auto& i : love)
|
|
blt::black_box(i.evaluate());
|
|
BLT_END_INTERVAL("Tree Evaluation", "Inheritance Tree v2");
|
|
}
|
|
|
|
void run3()
|
|
{
|
|
constexpr auto size = 512;
|
|
constexpr auto tree_size = 17;
|
|
engine.reset();
|
|
tree4 love[size];
|
|
BLT_START_INTERVAL("Tree Construction", "Inheritance Tree v3");
|
|
for (auto& i : love)
|
|
i.create(tree_size);
|
|
BLT_END_INTERVAL("Tree Construction", "Inheritance Tree v3");
|
|
BLT_START_INTERVAL("Tree Evaluation", "Inheritance Tree v3");
|
|
for (auto& i : love)
|
|
blt::black_box(i.evaluate());
|
|
BLT_END_INTERVAL("Tree Evaluation", "Inheritance Tree v3");
|
|
}
|
|
|
|
void run4()
|
|
{
|
|
constexpr auto size = 512;
|
|
constexpr auto tree_size = 17;
|
|
engine.reset();
|
|
tree5 love[size];
|
|
BLT_START_INTERVAL("Tree Construction", "Inheritance Tree v4");
|
|
for (auto& i : love)
|
|
i.create(tree_size);
|
|
BLT_END_INTERVAL("Tree Construction", "Inheritance Tree v4");
|
|
BLT_START_INTERVAL("Tree Evaluation", "Inheritance Tree v4");
|
|
for (auto& i : love)
|
|
blt::black_box(i.evaluate());
|
|
BLT_END_INTERVAL("Tree Evaluation", "Inheritance Tree v4");
|
|
}
|
|
|
|
void run5()
|
|
{
|
|
constexpr auto size = 512;
|
|
constexpr auto tree_size = 17;
|
|
engine.reset();
|
|
tree6 love[size];
|
|
BLT_START_INTERVAL("Tree Construction", "Inheritance Tree v5");
|
|
for (auto& i : love)
|
|
i.create(tree_size);
|
|
BLT_END_INTERVAL("Tree Construction", "Inheritance Tree v5");
|
|
BLT_START_INTERVAL("Tree Evaluation", "Inheritance Tree v5");
|
|
for (auto& i : love)
|
|
blt::black_box(i.evaluate());
|
|
BLT_END_INTERVAL("Tree Evaluation", "Inheritance Tree v5");
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
auto cum = new blt::u8[512];
|
|
auto v = blt::array<int>::construct(cum, 512);
|
|
auto& vr = *v;
|
|
|
|
BLT_TRACE("%p", cum);
|
|
BLT_TRACE(v);
|
|
BLT_TRACE(*vr);
|
|
vr[0] = 0;
|
|
BLT_TRACE(*vr);
|
|
vr[1] = 0;
|
|
BLT_TRACE(*vr);
|
|
vr[5] = 50;
|
|
BLT_DEBUG(vr[5]);
|
|
BLT_TRACE(*vr);
|
|
|
|
blt::black_box(v);
|
|
|
|
delete[] cum;
|
|
|
|
run();
|
|
run2();
|
|
run3();
|
|
run4();
|
|
run5();
|
|
|
|
// using testing = blt::size_t;
|
|
// constexpr blt::size_t INT_SIZE = blt::BLT_2MB_SIZE * 8 / sizeof(testing);
|
|
// auto** data = new testing*[INT_SIZE];
|
|
//
|
|
// for (blt::size_t i = 0; i < INT_SIZE; i++)
|
|
// {
|
|
// data[i] = alloc.emplace<testing>();
|
|
// *data[i] = 256;
|
|
// }
|
|
//
|
|
// for (blt::size_t i = 0; i < INT_SIZE; i++)
|
|
// {
|
|
// alloc.deallocate(data[i]);
|
|
// auto* blk = alloc.blk(data[i]);
|
|
// if (*data[i] != 256)
|
|
// BLT_WARN("Data is not 256 (%d)! %ld || %ld || 0x%lx || 0x%lx pointer %p part of block %p", *data[i], i % blt::BLT_2MB_SIZE, i, i, i % blt::BLT_2MB_SIZE, data[i], blk);
|
|
// }
|
|
|
|
// delete[] data;
|
|
}
|
|
} |