Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
211 строки
4.3 KiB
211 строки
4.3 KiB
#pragma once
|
|
#include "gp_config.hpp"
|
|
#include "gp/buffer.hpp"
|
|
#include "gp/array.hpp"
|
|
#include "gp/integer_math.hpp"
|
|
#include <type_traits>
|
|
#include <gp/algorithm/tmp_manip.hpp>
|
|
|
|
|
|
|
|
namespace gp{
|
|
template<typename page_allocator, size_t max_msb = 24, size_t align = 8>
|
|
class buddy{
|
|
struct twig {
|
|
bool used : 1;
|
|
bool used_children : 1;
|
|
twig(uint8_t src) {
|
|
used = 1 & src;
|
|
used_children = 2 & src;
|
|
}
|
|
|
|
operator uint8_t() {
|
|
return used + 2 * used_children;
|
|
}
|
|
};
|
|
struct bundle {
|
|
uint8_t a : 2;
|
|
uint8_t b : 2;
|
|
uint8_t c : 2;
|
|
uint8_t d : 2;
|
|
};
|
|
page_allocator allocator;
|
|
gp::buffer<char> data;
|
|
static constexpr size_t max_depth = max_msb - gp::math::msb(align);
|
|
static constexpr size_t required_twigs = (1 << (max_depth + 1)) - 1;
|
|
/**
|
|
* ((max allocatable size - min allocatable size) ** 2 - 1) / 4 twigs in a bundle
|
|
**/
|
|
static constexpr size_t span_size = required_twigs / 4 + (required_twigs % 4 != 0);
|
|
gp::array<bundle, span_size> stack;
|
|
|
|
twig get_twig(size_t idx) {
|
|
auto far = idx / 4;
|
|
auto local = idx % 4;
|
|
auto& group = stack[far];
|
|
switch(local) {
|
|
case 0:
|
|
return group.a;
|
|
case 1:
|
|
return group.b;
|
|
case 2:
|
|
return group.c;
|
|
case 3:
|
|
return group.d;
|
|
}
|
|
}
|
|
|
|
void set_twig(size_t idx, twig v) {
|
|
auto far = idx / 4;
|
|
auto local = idx % 4;
|
|
auto& group = stack[far];
|
|
switch(local) {
|
|
case 0:
|
|
group.a = v;
|
|
return;
|
|
case 1:
|
|
group.b = v;
|
|
return;
|
|
case 2:
|
|
group.c = v;
|
|
return;
|
|
case 3:
|
|
group.d = v;
|
|
return;
|
|
}
|
|
}
|
|
|
|
constexpr size_t size_to_depth(size_t sz) {
|
|
auto pow2 = gp::math::msb(sz);
|
|
return gp::max(max_depth ,max_msb - pow2 - (0 != sz % (1 << pow2)));
|
|
}
|
|
|
|
constexpr size_t depth_to_size(size_t depth) {
|
|
return 1 << (max_depth - depth + gp::math::msb(align));
|
|
}
|
|
|
|
size_t get_left(size_t index) {
|
|
return ((index + 1) << 1) - 1;
|
|
}
|
|
|
|
size_t get_right(size_t index) {
|
|
return ((index + 1) << 1);
|
|
}
|
|
|
|
template<typename function>
|
|
void all_under(size_t index, function func) {
|
|
size_t left = get_left(index);
|
|
size_t right = get_right(index);
|
|
all_under(left, func);
|
|
all_under(right, func);
|
|
func(left);
|
|
func(right);
|
|
}
|
|
|
|
template<typename function>
|
|
void all_over(size_t index, function func) {
|
|
size_t parent = ((index + 1) >> 1) - 1;
|
|
func(parent);
|
|
if(parent != 0)
|
|
all_over(parent, func);
|
|
}
|
|
|
|
template<typename function>
|
|
bool is_any_child(size_t index, function func) {
|
|
size_t left = get_left(index);
|
|
size_t right = get_right(index);
|
|
if(func(left)) return true;
|
|
if(func(right)) return true;
|
|
if(any_child(left, func)) return true;
|
|
if(any_child(right, func)) return true;
|
|
return false;
|
|
}
|
|
|
|
static constexpr size_t no_twig = -1;
|
|
|
|
size_t find_free_twig(size_t depth, size_t root = 0, size_t explored = 0) {
|
|
if(depth == explored) {
|
|
auto v = get_twig(root);
|
|
if(v.used || v.used_children)
|
|
{
|
|
return no_twig;
|
|
} else {
|
|
return root;
|
|
}
|
|
} else {
|
|
++explored;
|
|
auto ret = find_free_twig(depth, get_right(root), explored);
|
|
if(ret != no_twig)
|
|
{
|
|
return ret;
|
|
}
|
|
ret = find_free_twig(depth, get_left(root), explored);
|
|
if(ret != no_twig)
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
return no_twig;
|
|
}
|
|
public:
|
|
buddy()
|
|
: data(gp::buffer<char>(nullptr,nullptr))
|
|
{}
|
|
|
|
buddy(size_t sz)
|
|
: data(nullptr,nullptr)
|
|
{
|
|
if(sz!=0 && (sz & (sz - 1)) == 0)
|
|
{
|
|
auto v=allocator.allocate(sz);
|
|
if(v!=nullptr && (static_cast<intptr_t>(v) % align) ==0)
|
|
{
|
|
data=gp::buffer<char>(reinterpret_cast<char*>(v),reinterpret_cast<char*>(v)+sz);
|
|
}
|
|
}
|
|
}
|
|
|
|
buddy(char* pos,size_t sz)
|
|
: data(pos,pos+sz)
|
|
{
|
|
}
|
|
|
|
void* allocate(size_t sz)
|
|
{
|
|
auto depth = size_to_depth(sz);
|
|
auto index = find_free_twig(depth);
|
|
if(index == no_twig)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
all_over(index, [&](size_t idx){
|
|
auto t = get_twig(idx);
|
|
t.used_children = true;
|
|
set_twig(idx, t);
|
|
});
|
|
auto t = get_twig(index);
|
|
t.used = true;
|
|
set_twig(index, t);
|
|
return reinterpret_cast<void*>(index*depth_to_size(depth)
|
|
+ reinterpret_cast<intptr_t>(&*data.begin()));
|
|
}
|
|
|
|
bool deallocate(void* ptr)
|
|
{
|
|
if(data.contains((char*)ptr))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
~buddy()
|
|
{
|
|
if constexpr(gp::has_allocator_interface<page_allocator>::value)
|
|
{
|
|
allocator.deallocate(&data[0]);
|
|
}
|
|
}
|
|
};
|
|
}
|