Удалил кучу хлама. Сохраняю прогресс. Иду читать самый длинный щитпост в мире
This commit is contained in:
parent
6287a2f5f4
commit
98af159dbc
@ -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);
|
||||
//
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
|
||||
@ -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"
|
||||
Loading…
x
Reference in New Issue
Block a user