diff --git a/src/l1/anne/margaret/margaret_misc.h b/src/l1/anne/margaret/margaret_misc.h index 662a839..cea6d12 100644 --- a/src/l1/anne/margaret/margaret_misc.h +++ b/src/l1/anne/margaret/margaret_misc.h @@ -32,7 +32,9 @@ void generate_margaret_eve_for_vulkan_utils() { generate_eve_span_company_for_non_primitive_non_clonable(l, ns, cstr("MargaretMemAllocatorOneBlock"), true, false); generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestFreeOccupant"), true, false); - generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestResizeBuffer"), true, false); + generate_util_templ_inst_eve_header(l, ns, (util_templates_instantiation_options){ + .T = cstr("MargaretMemAllocatorRequestResizeBuffer"), .t_primitive = true, + .vec_extended = true /* We need unordered_pop to do some tomfoolery */}); generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestAllocBuffer"), true, false); generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMemAllocatorRequestAllocImage"), true, false); @@ -43,6 +45,9 @@ void generate_margaret_eve_for_vulkan_utils() { generate_Option_templ_inst_eve_header(l, ns, (option_template_instantiation_op){ .T = cstr("BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment")}); + generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMABufferExpansionRecord"), true, false); + generate_eve_span_company_for_primitive(l, ns, cstr("MargaretMANewMovedBufRecord"), true, false); + // generate_eve_span_company_for_primitive(l, ns, cstr("MargaretOldBufferResizeRecord"), true, false); // generate_eve_span_company_for_primitive(l, ns, cstr("MargaretBufRelocationRequest"), true, false); // diff --git a/src/l2/margaret/vulkan_memory_claire.h b/src/l2/margaret/vulkan_memory_claire.h index 8436d6d..2e0d2db 100644 --- a/src/l2/margaret/vulkan_memory_claire.h +++ b/src/l2/margaret/vulkan_memory_claire.h @@ -218,7 +218,7 @@ typedef struct { VkBufferUsageFlags usage_flags; bool preserve_at_quiet; VkBuffer buffer; - U64 capacity; /* Needed only for debugging purposes */ + U64 capacity; } MargaretMemoryOccupationBuffer; typedef enum { @@ -338,31 +338,18 @@ bool MargaretFreeMemSegment_less_resp_align( #include "../../../gen/l1_5/eve/margaret/BufRBTreeByLenRespAlign_SetMargaretFreeMemSegment.h" #include "../../../gen/l1/eve/margaret/OptionBufRBTreeByLenRespAlign_SetMargaretFreeMemSegment.h" -// typedef struct{ -// U32 old_mem_block_id; -// U64 old_start; -// U64 old_len; -// U32 new_mem_block_id; -// U64 new_start; -// U64 new_len; -// } MargaretOldBufferResizeRecord; -// #include "../../../gen/l1/eve/margaret/VecMargaretOldBufferResizeRecord.h" -// -// typedef struct { -// U32 old_mem_block_id; -// U64 old_start; -// U64 old_len; -// U64 offset_in_nascent_buffer; -// } MargaretResizeToNascentRecord; -// #include "../../../gen/l1/eve/margaret/VecMargaretResizeToNascentRecord.h" -// -// /* This is not a request from a user to MMA, this is a request from MMA to MMA-defragmentation subroutine */ -// typedef struct{ -// U64 old_size; /* in buffer in old VkDeviceMemory */ -// U64 new_size; /* in buffer in new VkDeviceMemory */ -// MargaretMemAllocatorSubBufferPosition* ans; -// } MargaretSubBufRelocationRequest; -// #include "../../../gen/l1/eve/margaret/VecMargaretSubBufRelocationRequest.h" +typedef struct { + U64 mem_block_ind; + U64 old_capacity; + RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it; +} MargaretMABufferExpansionRecord; +#include "../../../gen/l1/eve/margaret/VecMargaretMABufferExpansionRecord.h" + +typedef struct { + MargaretMemAllocatorOccupantPosition old_pos; + MargaretMemAllocatorOccupantPosition* ans; +} MargaretMANewMovedBufRecord; +#include "../../../gen/l1/eve/margaret/VecMargaretMANewMovedBufRecord.h" #include "../../../gen/l1/VecAndSpan_U8.h" @@ -454,6 +441,7 @@ typedef struct { * that MargaretMemAllocator_carry_out_request generates, you can (and should) wipe out old blocks */ VecMargaretMemAllocatorOneBlock old_blocks; + VecMargaretMANewMovedBufRecord old_moved_buffers; MargaretMemFreeSpaceManager mem_free_space; @@ -469,7 +457,7 @@ MargaretMemAllocator MargaretMemAllocator_new( MargaretMemAllocator self = { .blocks = VecMargaretMemAllocatorOneBlock_new(), .old_blocks = VecMargaretMemAllocatorOneBlock_new(), - // .old_buff_resize_record = VecMargaretOldBufferResizeRecord_new(), + .old_moved_buffers = VecMargaretMANewMovedBufRecord_new(), .mem_free_space = MargaretMemFreeSpaceManager_new(), .memory_type_id = memory_type_id, .mem_properties = mem_properties, @@ -480,10 +468,6 @@ MargaretMemAllocator MargaretMemAllocator_new( return self; } -// void MargaretMemAllocator__sink_memory(MargaretMemAllocator* self){ -// MargaretMemFreeSpaceManager_sink(&self->mem_free_space); -// } - U64Segment MargaretMemAllocatorOneBlock_get_left_free_space( const MargaretMemAllocatorOneBlock* self, RBTreeNode_KVPU64ToMargaretMemoryOccupation* occ_it){ U64 occ_start = occ_it->key; @@ -578,62 +562,69 @@ void MargaretMemAllocator_drop(MargaretMemAllocator self){ } void MargaretMemAllocator_wipe_old(MargaretMemAllocator* self){ - assert(!self->old_blocks.len || !self->old_buff_resize_record.len); + assert(!self->old_blocks.len || !self->old_moved_buffers.len); for (size_t blind = 0; blind < self->old_blocks.len; blind++) { MargaretMemAllocator__clean_handlers_in_block(self, &self->old_blocks.buf[blind]); } VecMargaretMemAllocatorOneBlock_sink(&self->old_blocks, 0); - for (U64 ri = 0; ri < self->old_buff_resize_record.len; ri++) { - const MargaretOldBufferResizeRecord* resize = &self->old_buff_resize_record.buf[ri]; - if (resize->old_mem_block_id != resize->new_mem_block_id || resize->old_start != resize->new_start) { - MargaretMemAllocator__get_rid_of_sub_buffer(self, resize->old_mem_block_id, resize->old_start); - } + for (U64 ri = 0; ri < self->old_moved_buffers.len; ri++) { + MargaretMANewMovedBufRecord moved = self->old_moved_buffers.buf[ri]; + assert(moved.old_pos.occ_it->value.variant == MargaretMemoryOccupation_Buffer); + MargaretMemAllocator__get_rid_of_memory_occupant(self, moved.old_pos.device_mem_ind, moved.old_pos.occ_it); } - VecMargaretOldBufferResizeRecord_sink(&self->old_buff_resize_record, 0); + VecMargaretMANewMovedBufRecord_sink(&self->old_moved_buffers, 0); } MargaretMemAllocatorDemands MargaretMemAllocator_carry_out_request( MargaretMemAllocator* self, VkCommandBuffer cmd_buff, MargaretMemAllocatorRequests* requests ){ MargaretMemAllocator_wipe_old(self); - assert(request->expand_alloc_buffer.len == self->buffer_types.len); - for (size_t i = 0; i < request->free_subbuffer.len; i++) { - MargaretMemAllocatorSubBufferPosition* req = request->free_subbuffer.buf[i]; - MargaretMemAllocator__get_rid_of_sub_buffer(self, req->memory_allocation_id, req->offset_in_device_memory_nubble); + for (size_t i = 0; i < requests->free_buf.len; i++) { + MargaretMemAllocatorOccupantPosition pos = *(requests->free_buf.buf[i]); + assert(pos.occ_it->value.variant == MargaretMemoryOccupation_Buffer); + MargaretMemAllocator__get_rid_of_memory_occupant(self, pos.device_mem_ind, pos.occ_it); } - for (size_t i = 0; i < request->free_image.len; i++) { - MargaretMemAllocatorImagePosition* req = request->free_image.buf[i]; - MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, req->memory_allocation_id); - U64 occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find(&block->occupied_memory, req->offset_in_device_memory_nubble); - MargaretMemAllocator__get_rid_of_memory_occupant(self, req->memory_allocation_id, occ_it); + for (size_t i = 0; i < requests->free_image.len; i++) { + MargaretMemAllocatorOccupantPosition pos = *(requests->free_buf.buf[i]); + assert(pos.occ_it->value.variant == MargaretMemoryOccupation_Image); + MargaretMemAllocator__get_rid_of_memory_occupant(self, pos.device_mem_ind, pos.occ_it); } - // todo: fix alignment issues here too - for (size_t shr = 0; shr < request->shrink_subbuffer.len; shr++) { - U64 new_size = request->shrink_subbuffer.buf[shr].new_size; - assert(new_size > 0); - MargaretMemAllocatorSubBufferPosition* ans = request->shrink_subbuffer.buf[shr].prev_ans; - MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, ans->memory_allocation_id); - OptionRefMutMargaretMemoryOccupation Oocc = BuffRBTree_MapU64ToMargaretMemoryOccupation_mat(&block->occupied_memory, - ans->offset_in_device_memory_nubble - ans->offset); - MargaretMemoryOccupation* occ = OptionRefMutMargaretMemoryOccupation_expect(Oocc); - assert(occ->variant == MargaretMemoryOccupation_Buffer); - MargaretMemoryOccupationBuffer* buf = &occ->buf; + for (size_t i = 0; i < requests->shrink_buf.len; i++) { + MargaretMemAllocatorRequestResizeBuffer req = (requests->shrink_buf.buf[i]); + MargaretMemAllocatorOccupantPosition pos = *req.ans; + assert(pos.occ_it->value.ans == req.ans); + assert(pos.occ_it->value.variant == MargaretMemoryOccupation_Buffer); + assert(pos.occ_it->value.buf.capacity >= req.new_size); + U64 buf_start = pos.occ_it->key; + U64 buf_taken_size = buf_taken_size; + MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, pos.device_mem_ind); - MargaretBufferKindInfo* kindred = VecMargaretBufferKindInfo_mat(&self->buffer_types, buf->kind); + VkBuffer shorter_buf; + VkBufferCreateInfo shorter_buf_crinfo = { + .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + .size = req.new_size, + .usage = pos.occ_it->value.buf.usage_flags, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + }; + if (vkCreateBuffer(self->device, &shorter_buf_crinfo, NULL, &shorter_buf) != VK_SUCCESS) + abortf("vkCreateBuffer\n"); + VkMemoryRequirements shorter_buf_req; + vkGetBufferMemoryRequirements(&self->device, shorter_buf, &shorter_buf_req); + check(U64_is_2pow(shorter_buf_req.alignment)); + check((shorter_buf_req.memoryTypeBits & self->memory_type_id)); + check((buf_start & (shorter_buf_req.alignment - 1)) == 0) + check(shorter_buf_req.size <= buf_taken_size); - U64 subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find(&buf->subbuffers, ans->offset); - U64 subbuf_start; - MargaretBufferOccupationSubBuffer* subbuf; - BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_mat_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf); - assert(new_size <= subbuf->length); - if (new_size == subbuf->length) - continue; + U64Segment right_free_space = MargaretMemAllocatorOneBlock_get_right_free_space(block, pos.occ_it); + MargaretMemFreeSpaceManager_erase(&self->mem_free_space, right_free_space.start, right_free_space.len, pos.device_mem_ind); + MargaretMemFreeSpaceManager_insert(&self->mem_free_space, + buf_start + shorter_buf_req.size, + right_free_space.len + (buf_taken_size - shorter_buf_req.size), pos.device_mem_ind); - U64Segment right_free_space = MargaretMemoryOccupationBuffer_get_right_free_space(buf, subbuf_it); - MargaretBufferKindInfo_erase_free_space(kindred, right_free_space.start, right_free_space.len, ans->memory_allocation_id); - MargaretBufferKindInfo_insert_free_space(kindred, right_free_space.start - (subbuf->length - new_size), - right_free_space.len + (subbuf->length - new_size), ans->memory_allocation_id); - subbuf->length = new_size; + vkDestroyBuffer(self->device, pos.occ_it->value.buf.buffer, NULL); + pos.occ_it->value.taken_size = shorter_buf_req.size; + pos.occ_it->value.buf.buffer = shorter_buf; + pos.occ_it->value.buf.capacity = req.new_size; } VkPhysicalDeviceMaintenance4Properties maintenance4_properties = { @@ -649,148 +640,77 @@ MargaretMemAllocatorDemands MargaretMemAllocator_carry_out_request( }; vkGetPhysicalDeviceProperties2(self->physical_device, &properties); - // todo: resize requests for buffer kinds with preserve_at_quiet = false is a ridiculous thing, ban it + VecMargaretMABufferExpansionRecord buffer_expansion_record = VecMargaretMABufferExpansionRecord_new(); + assert(self->old_moved_buffers.len == 0); - // todo: fix alignment on all buffer requests + /* We first try to do all the resize requests, that COULD be done using method 1 */ + for (U64 rr = 0; rr < requests->expand_buf.len;) { + U64 new_size = requests->expand_buf.buf[rr].new_size; + MargaretMemAllocatorOccupantPosition* ans = requests->expand_buf.buf[rr].ans; + assert(ans->occ_it->value.ans == ans); + // todo: I may actually want to store blocks in a linked list + MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, ans->device_mem_ind); - VecMargaretOldBufferResizeRecord old_buf_resize_record = VecMargaretOldBufferResizeRecord_new(); - /* We iterate even over those buffer kinds, that we don't use. It is okay, there won't be alot of buffer kinds - * + and we tend to use all of them */ - for (U16 bk = 0; bk < (U16)self->buffer_types.len;) { - MargaretBufferKindInfo* kindred = &self->buffer_types.buf[bk]; - MargaretMemAllocatorRequestsForCertainBufferKindAllocation* buf_requests = &request->expand_alloc_buffer.buf[bk]; + U64 occ_start = ans->occ_it->key; + assert(ans->occ_it->value.variant == MargaretMemoryOccupation_Buffer); + MargaretMemoryOccupationBuffer* buf = &ans->occ_it->value.buf; - /* We first try to do all the resize requests, that COULD be done using method 1 and 2. */ - for (U64 rr = 0; rr < buf_requests->expand.len;) { - U64 new_size = buf_requests->expand.buf[rr].new_size; - MargaretMemAllocatorSubBufferPosition* ans = buf_requests->expand.buf[rr].prev_ans; + /* Method 1 */ + U64Segment right_free_space = MargaretMemAllocatorOneBlock_get_right_free_space(block, ans->occ_it); - MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, ans->memory_allocation_id); - U64 occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find(&block->occupied_memory, - ans->offset_in_device_memory_nubble - ans->offset); - U64 occ_start; - MargaretMemoryOccupation* occ; - BuffRBTree_MapU64ToMargaretMemoryOccupation_mat_iter(&block->occupied_memory, occ_it, &occ_start, &occ); - assert(occ->variant == MargaretMemoryOccupation_Buffer); - MargaretMemoryOccupationBuffer* buf = &occ->buf; - assert(ans->offset_in_device_memory_nubble == occ_start + ans->offset); - - U64 subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find(&buf->subbuffers, ans->offset); - U64 subbuf_start; - MargaretBufferOccupationSubBuffer* subbuf; - BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_mat_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf); - assert(subbuf->length <= new_size); - - /* Method 1 */ - U64Segment right_free_space = MargaretMemoryOccupationBuffer_get_right_free_space(buf, subbuf_it); - if (new_size - subbuf->length <= right_free_space.len) { - MargaretBufferKindInfo_erase_free_space(kindred, right_free_space.start, right_free_space.len, ans->memory_allocation_id); - MargaretBufferKindInfo_insert_free_space(kindred, right_free_space.start + (new_size - subbuf->length), - right_free_space.len - (new_size - subbuf->length), ans->memory_allocation_id); - VecMargaretOldBufferResizeRecord_append(&old_buf_resize_record, (MargaretOldBufferResizeRecord){ - .old_mem_block_id = ans->memory_allocation_id, .old_start = ans->offset, .old_len = subbuf->length, - .new_mem_block_id = ans->memory_allocation_id, .new_start = ans->offset, .new_len = new_size}); - subbuf->length = new_size; /* Success */ - - VecMargaretMemAllocatorRequestResizeSubBuffer_unordered_pop(&buf_requests->expand, rr); - continue; - } - /* Method 2 */ - U64Segment RIGHT_FREE_SPACE = MargaretMemAllocatorOneBlock_get_right_free_space(block, occ_it); - if ( - (RIGHT_FREE_SPACE.start + RIGHT_FREE_SPACE.len < buf->capacity) || - (ans->offset_in_device_memory_nubble + new_size > RIGHT_FREE_SPACE.start + RIGHT_FREE_SPACE.len) || - (subbuf_start + new_size > maintenance4_properties.maxBufferSize)) { - rr++; - continue; - } - - VkBuffer temp_buf_extension; - VkBufferCreateInfo temp_buf_extension_crinfo = { - .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - .size = subbuf_start + new_size, - .usage = kindred->usage, - .sharingMode = VK_SHARING_MODE_EXCLUSIVE, - }; - if (vkCreateBuffer(self->device, &temp_buf_extension_crinfo, NULL, &temp_buf_extension) != VK_SUCCESS) - abortf("vkCreateBuffer"); - VkMemoryRequirements temp_buf_extension_req; - vkGetBufferMemoryRequirements(self->device, temp_buf_extension, &temp_buf_extension_req); - check(U64_is_2pow(temp_buf_extension_req.alignment)); - check((temp_buf_extension_req.memoryTypeBits & (1ull << self->memory_type_id)) > 0) - if ((occ_start + temp_buf_extension_req.size > RIGHT_FREE_SPACE.start + RIGHT_FREE_SPACE.len) || - ((occ_start & (temp_buf_extension_req.alignment)) != 0) - ){ - vkDestroyBuffer(self->device, temp_buf_extension, NULL); - rr++; - continue; - } - MargaretBufferKindInfo_erase_free_space(kindred, right_free_space.start, right_free_space.len, ans->memory_allocation_id); - MargaretMemFreeSpaceManager_erase(&self->mem_free_space, RIGHT_FREE_SPACE.start, RIGHT_FREE_SPACE.len, ans->memory_allocation_id); - MargaretMemFreeSpaceManager_insert(&self->mem_free_space, - occ_start + temp_buf_extension_req.size, - RIGHT_FREE_SPACE.start + RIGHT_FREE_SPACE.len - (occ_start + temp_buf_extension_req.size), - ans->memory_allocation_id); - VecMargaretOldBufferResizeRecord_append(&old_buf_resize_record, (MargaretOldBufferResizeRecord){ - .old_mem_block_id = ans->memory_allocation_id, .old_start = ans->offset, .old_len = subbuf->length, - .new_mem_block_id = ans->memory_allocation_id, .new_start = ans->offset, .new_len = new_size}); - /* Success */ - subbuf->length = new_size; - occ->taken_size = temp_buf_extension_req.size; - buf->capacity = subbuf_start + new_size; - vkDestroyBuffer(self->device, buf->buffer, NULL); - buf->buffer = temp_buf_extension; - /* TODO: write RBTree_Map, rewrite the whole MMA to use normal RBTree */ - for (size_t si = 0; si < buf->subbuffers.el.len; buf++) { - buf->subbuffers.el.buf[si].value.ans->buffer = temp_buf_extension; - } - VecMargaretMemAllocatorRequestResizeSubBuffer_unordered_pop(&buf_requests->expand, rr); + VkBuffer temp_buf_extension; + VkBufferCreateInfo temp_buf_extension_crinfo = { + .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + .size = new_size, + .usage = buf->usage_flags, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + }; + if (vkCreateBuffer(self->device, &temp_buf_extension_crinfo, NULL, &temp_buf_extension) != VK_SUCCESS) + abortf("vkCreateBuffer"); + VkMemoryRequirements temp_buf_extension_req; + vkGetBufferMemoryRequirements(self->device, temp_buf_extension, &temp_buf_extension_req); + check(U64_is_2pow(temp_buf_extension_req.alignment)); + check((temp_buf_extension_req.memoryTypeBits & (1ull << self->memory_type_id)) > 0) + if ((occ_start + temp_buf_extension_req.size > right_free_space.start + right_free_space.len) || + ((occ_start & (temp_buf_extension_req.alignment - 1)) != 0) + ){ + vkDestroyBuffer(self->device, temp_buf_extension, NULL); + rr++; + continue; } + MargaretMemFreeSpaceManager_erase(&self->mem_free_space, right_free_space.start, right_free_space.len, ans->device_mem_ind); + MargaretMemFreeSpaceManager_insert(&self->mem_free_space, + occ_start + temp_buf_extension_req.size, + right_free_space.start + right_free_space.len - (occ_start + temp_buf_extension_req.size), + ans->device_mem_ind); + VecMargaretMABufferExpansionRecord_append(&buffer_expansion_record, (MargaretMABufferExpansionRecord){ + .mem_block_ind = ans->device_mem_ind, .old_capacity = buf->capacity, .occ_it = ans->occ_it + }); + /* Success */ + buf->capacity = new_size; + ans->occ_it->value.taken_size = temp_buf_extension_req.size; + vkDestroyBuffer(self->device, buf->buffer, NULL); + buf->buffer = temp_buf_extension; + VecMargaretMemAllocatorRequestResizeBuffer_unordered_pop(&requests->expand_buf, rr); } - VecMargaretResizeToNascentRecord to_nascent = VecMargaretResizeToNascentRecord_new(); - VkBuffer wart_hand = VK_NULL_HANDLE; - U64 wart_capacity = 0; - VkMemoryRequirements wart_mem_req; /* undefined when wart_hand is 0 */ - for (U16 bk = 0; bk < (U16)self->buffer_types.len;) { - MargaretBufferKindInfo* kindred = &self->buffer_types.buf[bk]; - MargaretMemAllocatorRequestsForCertainBufferKindAllocation* buf_requests = &request->expand_alloc_buffer.buf[bk]; + check(vkResetCommandBuffer(cmd_buff, 0) == VK_SUCCESS); - /* We tried methods 1, 2, now we start with method 3 and if it fails we do defragmentation */ - for (U64 rr = 0; rr < buf_requests->expand.len;) { - U64 new_size = buf_requests->expand.buf[rr].new_size; - MargaretMemAllocatorSubBufferPosition* ans = buf_requests->expand.buf[rr].prev_ans; - MargaretMemAllocatorOneBlock* block = VecMargaretMemAllocatorOneBlock_mat(&self->blocks, ans->memory_allocation_id); - U64 occ_it = BuffRBTree_MapU64ToMargaretMemoryOccupation_find(&block->occupied_memory, - ans->offset_in_device_memory_nubble - ans->offset); - U64 occ_start; - MargaretMemoryOccupation* occ; - BuffRBTree_MapU64ToMargaretMemoryOccupation_mat_iter(&block->occupied_memory, occ_it, &occ_start, &occ); - assert(occ->variant == MargaretMemoryOccupation_Buffer); - MargaretMemoryOccupationBuffer* buf = &occ->buf; - assert(ans->offset_in_device_memory_nubble == occ_start + ans->offset); + for (U64 ri = 0; ri < requests->expand_buf.len; ri++) { - U64 subbuf_it = BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_find(&buf->subbuffers, ans->offset); - U64 subbuf_start; - MargaretBufferOccupationSubBuffer* subbuf; - BuffRBTree_MapU64ToMargaretBufferOccupationSubBuffer_mat_iter(&buf->subbuffers, subbuf_it, &subbuf_start, &subbuf); - assert(subbuf->length <= new_size); - - for (int attempt = 0; attempt < 2; attempt++) { - U64 temp_ext_wart_capacity = wart_capacity + new_size; - } - } } + + // todo: write + return 0; } -// todo: fix skill issues , lol char* MargaretMemAllocator_get_host_visible_buffer_ptr( - const MargaretMemAllocator* self, const MargaretMemAllocatorSubBufferPosition* pos){ + const MargaretMemAllocator* self, const MargaretMemAllocatorOccupantPosition* pos){ + const MargaretMemAllocatorOneBlock* bl = VecMargaretMemAllocatorOneBlock_at(&self->blocks, pos->device_mem_ind); + assert(pos->occ_it->value.variant == MargaretMemoryOccupation_Buffer); check((self->mem_properties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); - const MargaretMemAllocatorOneBlock* bl = VecMargaretMemAllocatorOneBlock_at(&self->blocks, pos->memory_allocation_id); assert(bl->mapped_memory); - /* We could check correctness of this position, but who cares, lol */ - return (char*)bl->mapped_memory + pos->offset_in_device_memory_nubble; + return (char*)bl->mapped_memory + pos->occ_it->key; } \ No newline at end of file diff --git a/src/l2/margaret/vulkan_utils.h b/src/l2/margaret/vulkan_utils.h index 9e5fce5..819eac5 100644 --- a/src/l2/margaret/vulkan_utils.h +++ b/src/l2/margaret/vulkan_utils.h @@ -1116,19 +1116,6 @@ void margaret_end_and_submit_and_free_command_buffer( vkFreeCommandBuffers(device, command_pool, 1, &cmd_buffer); } -// For application initialization purposes only -void margaret_copy_buffer_imm ( - VkDevice device, VkCommandPool command_pool, VkQueue graphics_queue, - VkBuffer dest_buffer, VkBuffer src_buffer, VkDeviceSize buffer_size - ) { - VkCommandBuffer cmd_buffer = margaret_alloc_and_begin_single_use_command_buffer(device, command_pool); - - VkBufferCopy regions_to_copy[1] = {(VkBufferCopy){.srcOffset = 0, .dstOffset = 0, .size = buffer_size}}; - vkCmdCopyBuffer(cmd_buffer, src_buffer, dest_buffer, ARRAY_SIZE(regions_to_copy), regions_to_copy); - - margaret_end_and_submit_and_free_command_buffer(device, command_pool, graphics_queue, cmd_buffer); -} - typedef struct { size_t host_mem_buff_offset; const MargaretImageInMemoryInfo* dst_image; diff --git a/src/l2/tests/data_structures/t2.c b/src/l2/tests/data_structures/t2.c index cbdecd1..5e92fb6 100644 --- a/src/l2/tests/data_structures/t2.c +++ b/src/l2/tests/data_structures/t2.c @@ -40,7 +40,7 @@ typedef struct { typedef int VkMemoryPropertyFlags; -const VkMemoryPropertyFlags VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 184; +const VkMemoryPropertyFlags VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x1000; typedef struct { VkMemoryPropertyFlags propertyFlags; @@ -93,7 +93,7 @@ typedef struct { typedef int VkSampleCountFlagBits; -const VkSampleCountFlagBits VK_SAMPLE_COUNT_1_BIT = 1299; +const VkSampleCountFlagBits VK_SAMPLE_COUNT_1_BIT = 0x100; typedef int VkImageTiling; @@ -229,4 +229,113 @@ void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef int VkCommandBufferResetFlags; + +VkResult vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +typedef int VkCommandBufferUsageFlags; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const void* pInheritanceInfo; /* will be NULL */ +} VkCommandBufferBeginInfo; + +VkResult vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +typedef int VkAccessFlags; +const VkAccessFlags VK_ACCESS_TRANSFER_READ_BIT = 0x100; + +typedef int VkImageAspectFlags; +const VkImageAspectFlags VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef int VkPipelineStageFlags; +const VkPipelineStageFlags VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x1; +const VkPipelineStageFlags VK_PIPELINE_STAGE_TRANSFER_BIT = 0x2; + +typedef int VkDependencyFlags; + +void vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const void* /* VkMemoryBarrier */ pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const void* /* VkBufferMemoryBarrier */ pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +void vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +void vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + + #include "../../margaret/vulkan_memory_claire.h" \ No newline at end of file