pub/prototype1
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

I just realized that subbuffering is entirely useless waste of time. I wasterd more then 3 weeks pn that nonsense. It made MMA super overcomplicated. I am deleting ALLL of this in the next commit

Browse Source
This commit is contained in:
Андреев Григорий 2025-11-22 00:41:42 +03:00
parent 8a2e8b48ad
commit cd6777a3b6
4 changed files with 143 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/l1/anne/margaret/margaret_misc.h
View File

@ -60,8 +60,8 @@ void generate_margaret_eve_for_vulkan_utils() {
.T = cstr("RefMutMargaretBufferOccupationSubBuffer"), .t_ptr = true});
generate_eve_span_company_for_primitive(l, ns, cstr("MargaretFreeMemSegment"), true, false);
// generate_Option_templ_inst_eve_header(l, ns, (option_template_instantiation_op){
// .T = cstr("MargaretFreeMemSegment"), .t_primitive = true});
generate_Option_templ_inst_eve_header(l, ns, (option_template_instantiation_op){
.T = cstr("MargaretFreeMemSegment"), .t_primitive = true});
generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestFreeSubBuffer"), true, false);
generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestFreeImage"), true, false);

65
src/l1_5/codegen/buff_rbtree_set_map_template_inst.h
View File

@ -338,6 +338,9 @@ void codegen_append_buff_rbtree_map__structure_and_simplest_methods(
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(key);\n", op.K),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(value);\n", op.V)));
// todo: write _erase_by_iter method
// todo: rewrite _erase using _erase_by_it
VecU8_append_vec(res, VecU8_fmt(
"bool %s_erase(%s* self, %v key) {\n" /* set, set, taking_ref_k_argument */
SPACE "U64 v = %s_find(self, key);\n" /* set */
@ -490,36 +493,42 @@ NODISCARD VecU8 generate_buf_rbtree_Map_template_instantiation(map_instantiation
// todo: write erase_substitute (only if v is not primitive) using try_insert
// todo: write pop_substitute using try_insert
if (!op.v_primitive) {
VecU8_append_vec(&res, VecU8_fmt(
"bool %s_erase_substitute(%s* self, %s key, %s value) {\n" /* map, map, op.K, op.V */
SPACE "U64 col = %s_try_insert(self, key, value);\n" /* map */
SPACE "if (col == 0)\n"
SPACE SPACE "return true;\n"
"%v" "%v" /* "" / drop col->key, "" / drop col->value */
SPACE "self->el.buf[col - 1].key = key;\n"
SPACE "self->el.buf[col - 1].value = value;\n"
SPACE "return false;\n"
"}\n\n",
map, map, op.K, op.V, map,
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(self->el.buf[col - 1].key);\n", op.K),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(self->el.buf[col - 1].value);\n", op.V)));
}
// codegen_append_buf_rbtree_map__insert_kind_method(&res, op, map, cstr("erase_substitute"), vcstr("bool"),
// vcstr("return true;\n"),
// VecU8_fmt("%v%v"
// "self->el.buf[cur - 1].key = key;\n"
// "self->el.buf[cur - 1].value = value;\n"
// "return false;\n",
// op.k_primitive ? vcstr("") : VecU8_fmt("%s_drop(self->el.buf[cur - 1].key);\n", op.K),
// op.k_primitive ? vcstr("") : VecU8_fmt("%s_drop(self->el.buf[cur - 1].value);\n", op.V)
// ));
//
// codegen_append_buf_rbtree_map__insert_kind_method(&res, op, map, cstr("pop_substitute"),
// VecU8_fmt("Option%s", op.V),
// VecU8_fmt("return None_%s();\n", op.V),
// VecU8_fmt(
// "%v" "self->el.buf[cur - 1].key = key;\n" /**/
// "%s saved = self->el.buf[cur - 1].value;\n" /* op.V */
// "self->el.buf[cur - 1].value = value;\n"
// "return Some_%s(saved);\n", /* op.V */
// op.k_primitive ? vcstr("") : VecU8_fmt("%s_drop(self->el.buf[cur - 1].key);\n", op.K),
// op.V, op.V));
VecU8_append_vec(&res, VecU8_fmt(
"Option%s %s_pop_substitute(%s* self, %s key, %s value) {\n" /* op.V, map, map, op.K, op.V */
SPACE "U64 col = %s_try_insert(self, key, value);\n" /* map */
SPACE "if (col == 0)\n"
SPACE SPACE "return None_%s();\n" /* op.V */
"%s saved = self->el.buf[col - 1].value;\n" /* op.V */
"%v" /* "" / drop col->key */
SPACE "self->el.buf[col - 1].key = key;\n"
SPACE "self->el.buf[col - 1].value = value;\n"
SPACE "return Some_%s(saved);\n" /* op.V */
"}\n\n",
op.V, map, map, op.K, op.V,
map, op.V,
op.V,
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(self->el.buf[col - 1].key);\n", op.K),
op.V));
// todo: write _pop() using _erase_empty_by_index()
// codegen_append_buff_rbtree_map__erase_kind_method(&res, op, map, cstr("pop"),
// VecU8_fmt("Option%s", op.V),
// VecU8_fmt("return None_%s();\n", op.V),
// VecU8_fmt("%v" "%s saved = self->el.buf[cur - 1].value;\n",
// op.k_primitive ? vcstr("") : VecU8_fmt("%s_drop(self->el.buf[cur - 1].key);\n", op.K),
// op.V),
// VecU8_fmt("return Some_%s(saved);\n", op.V));
// todo: write _pop_by_iter method
// todo: write _pop method
codegen_append_buf_rbtree_map__method_at(&res, op, map, false);
codegen_append_buf_rbtree_map__method_at(&res, op, map, true);

39
src/l1_5/codegen/rbtree_set_map_template_inst.h
View File

@ -15,7 +15,7 @@ NODISCARD VecU8 codegen_rbtree__node_structure(map_instantiation_op op){
"typedef struct {\n"
SPACE "RBTreeNode base;\n"
SPACE "%s key;\n" /* op.K*/
"" /* "" / op.V value; */
"%v" /* "" / op.V value; */
"} %s;\n\n", /* node */
op.K, op.V.len > 0 ? VecU8_fmt(SPACE "%s value;\n", op.V) : vcstr(""),
node);
@ -99,8 +99,8 @@ void codegen_append_rbtree_map__structure_and_simplest_methods(
SPACE "}\n"
SPACE "free(self.NIL);\n"
"}\n\n", set, set,
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE SPACE "%s_drop(((RBTreeNode_TT*)cur)->key);\n", op.K, TT),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE SPACE "%s_drop(((RBTreeNode_TT*)cur)->value);\n", op.V, TT)
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE SPACE "%s_drop(((RBTreeNode_%s*)cur)->key);\n", op.K, TT),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE SPACE "%s_drop(((RBTreeNode_%s*)cur)->value);\n", op.V, TT)
));
VecU8_append_vec(res, VecU8_fmt(
@ -253,7 +253,7 @@ void codegen_append_rbtree_map__structure_and_simplest_methods(
codegen_rbtree_map__less(op, codegen_rbtree_map__exp_passing_cur_key(op), codegen_rbtree_map__exp_passing_key_val(op)),
TT,
TT, TT, TT,
TT, op.v_primitive ? cstr("") : cstr(", .value = value")));
TT, op.V.len == 0 ? cstr("") : cstr(", .value = value")));
VecU8_append_vec(res, VecU8_fmt(
"bool %s_insert(%s* self, %v){\n" /* set, set, taking_t_argument */
@ -268,19 +268,27 @@ void codegen_append_rbtree_map__structure_and_simplest_methods(
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(key);\n", op.K),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(value);\n", op.V)));
VecU8_append_vec(res, VecU8_fmt(
"void %s_erase_by_iter(%s* self, RBTreeNode_%s* it) {\n" /* set, set, TT */
SPACE "assert(it != NULL);\n"
"%v" /* "" / op.K_drop(it->key) */
"%v" /* "" / op.V_drop(it->value) */
SPACE "RBTree_erase_empty_by_iter(&self->root, self->NIL, (RBTreeNode*)it);\n"
"}\n\n",
set, set, TT,
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(it->key);\n", op.K),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(it->value);\n", op.V)));
VecU8_append_vec(res, VecU8_fmt(
"bool %s_erase(%s* self, %v key) {\n" /* set, set, taking_ref_k_argument */
SPACE "RBTreeNode_%s* v = %s_find(self, key);\n" /* TT, set */
SPACE "if (v == NULL)\n"
SPACE SPACE "return false;\n"
"%v" /* "" / op.K_drop(v->key) */
"%v" /* "" / op.V_drop(v->value) */
SPACE "RBTree_erase_empty_by_iter(&self->root, self->NIL, (RBTreeNode*)v);\n"
SPACE "%s_erase_by_iter(self, v);\n" /* set */
SPACE "return true;\n"
"}\n\n", set, set, codegen_rbtree_map__taking_ref_k_argument(op),
TT, set,
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(v->key);\n", op.K),
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(v->value);\n", op.V)));
"}\n\n",
set, set, codegen_rbtree_map__taking_ref_k_argument(op),
TT, set, set));
}
@ -360,7 +368,7 @@ NODISCARD VecU8 generate_rbtree_Map_template_instantiation(map_instantiation_op
"}\n\n",
op.v_primitive ? cstr("") : cstr("NODISCARD "), op.V, map, map, op.K, op.V,
kvp, map, op.V,
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE"%s_drop(col->key);\n", op.K),
op.k_primitive ? vcstr("") : VecU8_fmt(SPACE SPACE"%s_drop(col->key);\n", op.K),
op.V, op.V));
if (!op.v_primitive) {
@ -379,6 +387,9 @@ NODISCARD VecU8 generate_rbtree_Map_template_instantiation(map_instantiation_op
op.v_primitive ? vcstr("") : VecU8_fmt(SPACE "%s_drop(col->value);\n", op.V)));
}
// todo: write _pop_by_it
// todo: rewrite pop using _pop_by_it
VecU8_append_vec(&res, VecU8_fmt(
"Option%s %s_pop(%s* self, %v key) {\n" /* op.V, map, map, taking_ref_k_argument */
SPACE "RBTreeNode_%s* v = %s_find(self, key);\n" /* kvp, map */
@ -386,8 +397,8 @@ NODISCARD VecU8 generate_rbtree_Map_template_instantiation(map_instantiation_op
SPACE SPACE "return None_%s();\n" /* op.V */
"%v" /* "" / op.K_drop(v->key) */
"%s saved = v->value;\n" /* op.V */
SPACE "RBTree_erase_empty_by_iter(&self->root, self->NIL, v);\n"
SPACE "return Some_%s();\n" /* op.V */
SPACE "RBTree_erase_empty_by_iter(&self->root, self->NIL, (RBTreeNode*)v);\n"
SPACE "return Some_%s(saved);\n" /* op.V */
"}\n\n",
op.V, map, map, codegen_rbtree_map__taking_ref_k_argument(op),
kvp, map, op.V,

167
src/l2/margaret/vulkan_memory_claire.h
View File

@ -332,7 +332,7 @@ typedef struct {
#include "../../../gen/l1/eve/margaret/OptionMargaretBufferOccupationSubBuffer.h"
#include "../../../gen/l1/eve/margaret/OptionRefMargaretBufferOccupationSubBuffer.h"
#include "../../../gen/l1/eve/margaret/OptionRefMutMargaretBufferOccupationSubBuffer.h"
#include "../../../gen/l1_5/eve/margaret/BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer.h"
#include "../../../gen/l1_5/eve/margaret/RBTree_MapU64ToMargaretBufferOccupationSubBuffer.h"
/* Not primitive */
@ -340,7 +340,7 @@ typedef struct {
U16 kind;
VkBuffer buffer;
U64 capacity;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer subbuffers;
RBTree_MapU64ToMargaretBufferOccupationSubBuffer subbuffers;
} MargaretMemoryOccupationBuffer;
typedef enum {
@ -359,7 +359,7 @@ typedef struct {
void MargaretMemoryOccupation_drop(MargaretMemoryOccupation self){
if (self.variant == MargaretMemoryOccupation_Buffer) {
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_drop(self.buf.subbuffers);
RBTree_MapU64ToMargaretBufferOccupationSubBuffer_drop(self.buf.subbuffers);
}
}
@ -376,10 +376,10 @@ typedef struct{
#include "../../../gen/l1/eve/margaret/OptionMargaretMemoryOccupation.h"
#include "../../../gen/l1/eve/margaret/OptionRefMargaretMemoryOccupation.h"
#include "../../../gen/l1/eve/margaret/OptionRefMutMargaretMemoryOccupation.h"
#include "../../../gen/l1_5/eve/margaret/BuffRBTree_MapU64ToMargaretMemoryOccupation.h"
#include "../../../gen/l1_5/eve/margaret/RBTree_MapU64ToMargaretMemoryOccupation.h"
typedef struct {
BuffRBTree_MapU64ToMargaretMemoryOccupation occupied_memory;
RBTree_MapU64ToMargaretMemoryOccupation occupied_memory;
U64 length;
/* I am 100% sure that this fields is useless rn. You might use it to show cool infographics on F3 screen */
U64 occupation_counter;
@ -388,7 +388,7 @@ typedef struct {
} MargaretMemAllocatorOneBlock;
void MargaretMemAllocatorOneBlock_drop(MargaretMemAllocatorOneBlock self){
BuffRBTree_MapU64ToMargaretMemoryOccupation_drop(self.occupied_memory);
RBTree_MapU64ToMargaretMemoryOccupation_drop(self.occupied_memory);
}
#include "../../../gen/l1/eve/margaret/VecMargaretMemAllocatorOneBlock.h"
@ -429,6 +429,7 @@ bool MargaretFreeMemSegment_less_resp_align(
}
#include "../../../gen/l1/eve/margaret/VecMargaretFreeMemSegment.h"
#include "../../../gen/l1/eve/margaret/OptionMargaretFreeMemSegment.h"
#include "../../../gen/l1_5/eve/margaret/BufRBTreeByLen_SetMargaretFreeMemSegment.h"
#include "../../../gen/l1_5/eve/margaret/BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment.h"
#include "../../../gen/l1/eve/margaret/OptionBufRBTreeByLenRespAlign_SetMargaretFreeMemSegment.h"
@ -481,14 +482,14 @@ MargaretMemFreeSpaceManager MargaretMemFreeSpaceManager_new(){
void MargaretMemFreeSpaceManager_drop(MargaretMemFreeSpaceManager self){
for (U8 alignment_exp = 0; alignment_exp < MARGARET_ALLOC_LIMIT_ALIGNMENT_EXP; alignment_exp++)
OptionBuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_drop(self.free_space_in_memory[alignment_exp]);
OptionBufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_drop(self.free_space_in_memory[alignment_exp]);
VecU8_drop(self.set_present);
}
void MargaretMemFreeSpaceManager_sink(MargaretMemFreeSpaceManager* self){
for (U8 ae = 0; ae < MARGARET_ALLOC_LIMIT_ALIGNMENT_EXP; ae++)
if (self->free_space_in_memory[ae].variant == Option_Some)
BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_sink(&self->free_space_in_memory[ae].some);
BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_sink(&self->free_space_in_memory[ae].some);
}
void MargaretMemFreeSpaceManager_erase(MargaretMemFreeSpaceManager* man, U64 start, U64 len, U32 dev_mem_block){
@ -499,7 +500,7 @@ void MargaretMemFreeSpaceManager_erase(MargaretMemFreeSpaceManager* man, U64 sta
U8 alignment = man->set_present.buf[aj];
assert(alignment < MARGARET_ALLOC_LIMIT_ALIGNMENT_EXP);
assert(man->free_space_in_memory[alignment].variant == Option_Some);
bool eret = BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_erase(&
bool eret = BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_erase(&
man->free_space_in_memory[alignment].some, &(MargaretFreeMemSegment){start, len, dev_mem_block});
assert(eret);
}
@ -512,7 +513,7 @@ void MargaretMemFreeSpaceManager_insert(MargaretMemFreeSpaceManager* man, U64 st
U8 alignment = man->set_present.buf[aj];
assert(alignment < MARGARET_ALLOC_LIMIT_ALIGNMENT_EXP);
assert(man->free_space_in_memory[alignment].variant == Option_Some);
bool iret = BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_insert(&
bool iret = BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_insert(&
man->free_space_in_memory[alignment].some, (MargaretFreeMemSegment){start, len, dev_mem_block});
assert(iret);
}
@ -523,21 +524,20 @@ OptionMargaretFreeMemSegment MargaretMemFreeSpaceManager_search(MargaretMemFreeS
if (man->free_space_in_memory[alignment_exp].variant == Option_None) {
assert(man->set_present.len > 0);
assert(man->free_space_in_memory[man->set_present.buf[0]].variant == Option_Some);
BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment* have = &man->free_space_in_memory[man->set_present.buf[0]].some;
man->free_space_in_memory[alignment_exp] = Some_BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment(
BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_new_reserved(alignment_exp, have->el.len));
BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment* have = &man->free_space_in_memory[man->set_present.buf[0]].some;
man->free_space_in_memory[alignment_exp] = Some_BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment(
BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_new_reserved(alignment_exp, have->el.len));
for (size_t i = 0; i < have->el.len; i++) {
// MargaretFreeMemSegment
BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_insert(&man->free_space_in_memory[alignment_exp].some,
BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_insert(&man->free_space_in_memory[alignment_exp].some,
*VecMargaretFreeMemSegment_at(&have->el, i));
}
}
assert(man->free_space_in_memory[alignment_exp].variant == Option_Some);
U64 sit = BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_find_min_grtr_or_eq(&man->free_space_in_memory[alignment_exp].some,
U64 sit = BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_find_min_grtr_or_eq(&man->free_space_in_memory[alignment_exp].some,
&(MargaretFreeMemSegment){.start = 0, .len = len, .dev_mem_block = 0});
if (sit == 0)
return None_MargaretFreeMemSegment();
return Some_MargaretFreeMemSegment(*BuffRBTreeByLenRespAlign_SetMargaretFreeMemSegment_at_iter(
return Some_MargaretFreeMemSegment(*BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment_at_iter(
&man->free_space_in_memory[alignment_exp].some, sit));
}
@ -547,17 +547,17 @@ typedef struct {
bool preserve_at_quiet;
U64 total_occupation;
BuffRBTreeByLen_SetMargaretFreeMemSegment free_space_inside_buffers;
BufRBTreeByLen_SetMargaretFreeMemSegment free_space_inside_buffers;
} MargaretBufferKindInfo;
void MargaretBufferKindInfo_drop(MargaretBufferKindInfo self){
BuffRBTreeByLen_SetMargaretFreeMemSegment_drop(self.free_space_inside_buffers);
BufRBTreeByLen_SetMargaretFreeMemSegment_drop(self.free_space_inside_buffers);
}
void MargaretBufferKindInfo_erase_free_space(MargaretBufferKindInfo* self, U64 start, U64 len, U32 dev_mem_block){
if (len == 0)
return;
bool eret = BuffRBTreeByLen_SetMargaretFreeMemSegment_erase(&self->free_space_inside_buffers,
bool eret = BufRBTreeByLen_SetMargaretFreeMemSegment_erase(&self->free_space_inside_buffers,
&(MargaretFreeMemSegment){.start = start, .len = len, .dev_mem_block = dev_mem_block});
assert(eret);
}
@ -565,7 +565,7 @@ void MargaretBufferKindInfo_erase_free_space(MargaretBufferKindInfo* self, U64 s
void MargaretBufferKindInfo_insert_free_space(MargaretBufferKindInfo* self, U64 start, U64 len, U32 dev_mem_block){
if (len == 0)
return;
bool iret = BuffRBTreeByLen_SetMargaretFreeMemSegment_insert(&self->free_space_inside_buffers,
bool iret = BufRBTreeByLen_SetMargaretFreeMemSegment_insert(&self->free_space_inside_buffers,
(MargaretFreeMemSegment){start, len, dev_mem_block});
assert(iret);
}
@ -620,7 +620,7 @@ MargaretMemAllocator MargaretMemAllocator_new(
.inner_alignment_exp = U64_2pow_log(desc->inner_alignment),
.preserve_at_quiet = desc->preserve_at_quiet,
.total_occupation = 0,
.free_space_inside_buffers = BuffRBTreeByLen_SetMargaretFreeMemSegment_new()
.free_space_inside_buffers = BufRBTreeByLen_SetMargaretFreeMemSegment_new()
});
}
return self;
@ -628,53 +628,50 @@ MargaretMemAllocator MargaretMemAllocator_new(
void MargaretMemAllocator__sink_memory(MargaretMemAllocator* self){
for (size_t i = 0; i < self->buffer_types.len; i++)
BuffRBTreeByLen_SetMargaretFreeMemSegment_sink(&self->buffer_types.buf[i].free_space_inside_buffers);
BufRBTreeByLen_SetMargaretFreeMemSegment_sink(&self->buffer_types.buf[i].free_space_inside_buffers);
MargaretMemFreeSpaceManager_sink(&self->mem_free_space);
}
U64Segment MargaretMemAllocatorOneBlock_get_left_free_space(const MargaretMemAllocatorOneBlock* self, U64 occ_it){
U64 occ_start;
const MargaretMemoryOccupation* occ;
BuffRBTree_MapU64ToMargaretMemoryOccupation_at_iter(&self->occupied_memory, occ_it, &occ_start, &occ);
U64Segment MargaretMemAllocatorOneBlock_get_left_free_space(
const MargaretMemAllocatorOneBlock* self, RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it){
U64 occ_start = occ_it->key;
U64 prev_occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find_prev(&self->occupied_memory, occ_it);
if (prev_occ_it != 0) {
U64 prev_occ_start;
const MargaretMemoryOccupation* prev_occ;
BuffRBTree_MapU64ToMargaretMemoryOccupation_at_iter(&self->occupied_memory, prev_occ_it, &prev_occ_start, &prev_occ);
assert(prev_occ_start + prev_occ->taken_size <= occ_start);
return (U64Segment){.start = prev_occ_start + prev_occ->taken_size, .len = occ_start - (prev_occ_start + prev_occ->taken_size)};
RBTreeNode_KVPU64ToMargaretMemoryOccupation* prev_occ_it =
RBTree_MapU64ToMargaretMemoryOccupation_find_prev(&self->occupied_memory, occ_it);
if (prev_occ_it != NULL) {
U64 prev_occ_start = prev_occ_it->key;
U64 prev_occ_taken_size = prev_occ_it->value.taken_size;
assert(prev_occ_start + prev_occ_taken_size <= occ_start);
return (U64Segment){.start = prev_occ_start + prev_occ_taken_size,
.len = occ_start - (prev_occ_start + prev_occ_taken_size)};
}
return (U64Segment){.start = 0, .len = occ_start};
}
U64Segment MargaretMemAllocatorOneBlock_get_right_free_space(const MargaretMemAllocatorOneBlock* self, U64 occ_it){
U64 occ_start;
const MargaretMemoryOccupation* occ;
BuffRBTree_MapU64ToMargaretMemoryOccupation_at_iter(&self->occupied_memory, occ_it, &occ_start, &occ);
U64Segment MargaretMemAllocatorOneBlock_get_right_free_space(
const MargaretMemAllocatorOneBlock* self, RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it){
U64 occ_start = occ_it->key;
U64 occ_taken_size = occ_it->value.taken_size;
U64 next_occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find_next(&self->occupied_memory, occ_it);
if (next_occ_it != 0) {
U64 next_occ_start;
const MargaretMemoryOccupation* next_occ;
BuffRBTree_MapU64ToMargaretMemoryOccupation_at_iter(&self->occupied_memory, next_occ_it, &next_occ_start, &next_occ);
assert(occ_start + occ->taken_size <= next_occ_start);
return (U64Segment){.start = occ_start + occ->taken_size, .len = next_occ_start - (occ_start + occ->taken_size)};
RBTreeNode_KVPU64ToMargaretMemoryOccupation* next_occ_it =
RBTree_MapU64ToMargaretMemoryOccupation_find_next(&self->occupied_memory, occ_it);
if (next_occ_it != NULL) {
U64 next_occ_start = next_occ_it->key;
assert(occ_start + occ_taken_size <= next_occ_start);
return (U64Segment){.start = occ_start + occ_taken_size, .len = next_occ_start - (occ_start + occ_taken_size)};
}
return (U64Segment){.start = occ_start + occ->taken_size, .len = self->length - (occ_start + occ->taken_size)};
return (U64Segment){.start = occ_start + occ_taken_size, .len = self->length - (occ_start + occ_taken_size)};
}
/* If mem occupant in question is VkBuffer, it won't delete anything from the set of available free mem segments
* for that buffer kindred. It is your job to remove free buffer subsegments from this set*/
void MargaretMemAllocator__get_rid_of_memory_occupant(
MargaretMemAllocator* self, U32 mem_block_id, U64 occ_it){
MargaretMemAllocator* self, U32 mem_block_id, RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it){
MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, mem_block_id);
U64 occ_start;
const MargaretMemoryOccupation* occ;
BuffRBTree_MapU64ToMargaretMemoryOccupation_at_iter(&block->occupied_memory, occ_it, &occ_start, &occ);
const MargaretMemoryOccupation* occ = &occ_it->value;
/* Updating block usage counter */
/* Updating block usage counter TODO: do it everywhere */
block->occupation_counter -= occ->taken_size;
U64Segment left_free_space = MargaretMemAllocatorOneBlock_get_left_free_space(block, occ_it);
@ -686,10 +683,7 @@ void MargaretMemAllocator__get_rid_of_memory_occupant(
vkDestroyImage(self->device, occ->img.image, NULL);
}
/* All these iterators and pointers will get invalidated */
MargaretMemoryOccupation_drop(*occ); // yes, this is illegal, but it works. Don't do it again, please
BuffRBTree_MapU64ToMargaretMemoryOccupation_empty_index_erase(&block->occupied_memory, occ_it);
/* All these iterators and pointers just got invalidated */
RBTree_MapU64ToMargaretMemoryOccupation_erase_by_iter(&block->occupied_memory, occ_it);
MargaretMemFreeSpaceManager_erase(&self->mem_free_space, left_free_space.start, left_free_space.len, mem_block_id);
MargaretMemFreeSpaceManager_erase(&self->mem_free_space, right_free_space.start, right_free_space.len, mem_block_id);
@ -700,60 +694,57 @@ void MargaretMemAllocator__get_rid_of_memory_occupant(
/* Given a subbuffer inside given buffer, returns segment of free space on the left */
U64Segment MargaretMemoryOccupationBuffer_get_left_free_space(
MargaretMemoryOccupationBuffer* buf, U64 subbuf_it){
U64 subbuf_start;
const MargaretBufferOccupationSubBuffer* subbuf;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_at_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf);
assert(subbuf_start + subbuf->length <= buf->capacity);
MargaretMemoryOccupationBuffer* buf, RBTreeNode_KVPU64ToMargaretBufferOccupationSubBuffer* subbuf_it){
U64 subbuf_start = subbuf_it->key;
assert(subbuf_start + subbuf_it->value.length <= buf->capacity);
U64 prev_subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find_prev(&buf->subbuffers, subbuf_it);
if (prev_subbuf_it != 0) {
U64 prev_subbuf_start;
const MargaretBufferOccupationSubBuffer* prev_subbuf;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_at_iter(&buf->subbuffers, prev_subbuf_it, &prev_subbuf_start, &prev_subbuf);
assert(prev_subbuf_start + prev_subbuf->length <= subbuf_start);
return (U64Segment){.start = prev_subbuf_start + prev_subbuf->length, .len = subbuf_start - (prev_subbuf_start + prev_subbuf->length)};
RBTreeNode_KVPU64ToMargaretBufferOccupationSubBuffer* prev_subbuf_it =
RBTree_MapU64ToMargaretBufferOccupationSubBuffer_find_prev(&buf->subbuffers, subbuf_it);
if (prev_subbuf_it != NULL) {
U64 prev_subbuf_start = prev_subbuf_it->key;
U64 prev_subbuf_length = prev_subbuf_it->value.length;
assert(prev_subbuf_start + prev_subbuf_length <= subbuf_start);
return (U64Segment){.start = prev_subbuf_start + prev_subbuf_length,
.len = subbuf_start - (prev_subbuf_start + prev_subbuf_length)};
}
return (U64Segment){.start = 0, .len = subbuf_start};
}
/* Given a subbuffer inside this buffer, return segment of free space on the right */
U64Segment MargaretMemoryOccupationBuffer_get_right_free_space(
MargaretMemoryOccupationBuffer* buf, U64 subbuf_it){
U64 subbuf_start;
const MargaretBufferOccupationSubBuffer* subbuf;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_at_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf);
assert(subbuf_start + subbuf->length <= buf->capacity);
MargaretMemoryOccupationBuffer* buf, RBTreeNode_KVPU64ToMargaretBufferOccupationSubBuffer* subbuf_it){
U64 subbuf_start = subbuf_it->key;
U64 subbuf_length = subbuf_it->value.length;
assert(subbuf_start + subbuf_length <= buf->capacity);
U64 next_subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find_next(&buf->subbuffers, subbuf_it);
if (next_subbuf_it != 0) {
U64 next_subbuf_start;
const MargaretBufferOccupationSubBuffer* next_subbuf;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_at_iter(&buf->subbuffers, next_subbuf_it, &next_subbuf_start, &next_subbuf);
assert(subbuf_start + subbuf->length <= next_subbuf_start);
return (U64Segment){.start = subbuf_start + subbuf->length, .len = next_subbuf_start - (subbuf_start + subbuf->length)};
RBTreeNode_KVPU64ToMargaretBufferOccupationSubBuffer* next_subbuf_it =
RBTree_MapU64ToMargaretBufferOccupationSubBuffer_find_next(&buf->subbuffers, subbuf_it);
if (next_subbuf_it != NULL) {
U64 next_subbuf_start = next_subbuf_it->key;
assert(subbuf_start + subbuf_length <= next_subbuf_start);
return (U64Segment){.start = subbuf_start + subbuf_length,
.len = next_subbuf_start - (subbuf_start + subbuf_length)};
}
return (U64Segment){.start = subbuf_start + subbuf->length, .len = buf->capacity - (subbuf_start + subbuf->length)};
return (U64Segment){.start = subbuf_start + subbuf_length, .len = buf->capacity - (subbuf_start + subbuf_length)};
}
/* Don't forget that all the iterators for MMA maps for buffers and sets for free space just got invalidated */
void MargaretMemAllocator__get_rid_of_sub_buffer(MargaretMemAllocator* self, U32 mem_block_id, U64 start){
void MargaretMemAllocator__get_rid_of_sub_buffer(MargaretMemAllocator* self,
U32 mem_block_id, RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it,
RBTreeNode_KVPU64ToMargaretBufferOccupationSubBuffer* subbuf_it
){
MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, mem_block_id);
U64 occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find_max_less_or_eq(&block->occupied_memory, 2);
U64 occ_start;
MargaretMemoryOccupation* occ_buf;
BuffRBTree_MapU64ToMargaretMemoryOccupation_mat_iter(&block->occupied_memory, occ_it, &occ_start, &occ_buf);
U64 occ_start = occ_it->key;
MargaretMemoryOccupation* occ_buf = &occ_it->value;
assert(occ_buf->variant == MargaretMemoryOccupation_Buffer);
MargaretMemoryOccupationBuffer* buf = &occ_buf->buf;
assert(occ_start <= start);
MargaretBufferKindInfo* kindred = VecMargaretBufferKindInfo_mat(&self->buffer_types, buf->kind);
U64 subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find(&buf->subbuffers, start - occ_start);
U64 subbuf_start;
const MargaretBufferOccupationSubBuffer* subbuf;
BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_at_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf);
assert(occ_start <= start);
assert(subbuf_start == start - occ_start);
assert(subbuf_start + subbuf->length <= buf->capacity);
assert(start + subbuf->length <= occ_start + buf->capacity);