diff --git a/src/l1/anne/margaret/margaret_misc.h b/src/l1/anne/margaret/margaret_misc.h index d356c9e..5e0b6b2 100644 --- a/src/l1/anne/margaret/margaret_misc.h +++ b/src/l1/anne/margaret/margaret_misc.h @@ -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); diff --git a/src/l1_5/codegen/buff_rbtree_set_map_template_inst.h b/src/l1_5/codegen/buff_rbtree_set_map_template_inst.h index e0db153..c12c916 100644 --- a/src/l1_5/codegen/buff_rbtree_set_map_template_inst.h +++ b/src/l1_5/codegen/buff_rbtree_set_map_template_inst.h @@ -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); diff --git a/src/l1_5/codegen/rbtree_set_map_template_inst.h b/src/l1_5/codegen/rbtree_set_map_template_inst.h index 4409996..9041c3a 100644 --- a/src/l1_5/codegen/rbtree_set_map_template_inst.h +++ b/src/l1_5/codegen/rbtree_set_map_template_inst.h @@ -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, diff --git a/src/l2/margaret/vulkan_memory_claire.h b/src/l2/margaret/vulkan_memory_claire.h index 972c677..3b31bb1 100644 --- a/src/l2/margaret/vulkan_memory_claire.h +++ b/src/l2/margaret/vulkan_memory_claire.h @@ -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);