Moved to homebrew clang, added gpu memory management functions\n
parent
8bba0f1c26
commit
82166a8181
@ -0,0 +1,54 @@
|
|||||||
|
#ifndef GPU_MEM_H
|
||||||
|
#define GPU_MEM_H
|
||||||
|
|
||||||
|
#include <vulkan/vulkan_core.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
typedef struct GPUMemoryTypeStruct {
|
||||||
|
VkMemoryPropertyFlags flags;
|
||||||
|
uint32_t index;
|
||||||
|
} GPUMemoryType;
|
||||||
|
|
||||||
|
typedef struct GPUMemoryChunkStruct {
|
||||||
|
VkDeviceSize size;
|
||||||
|
VkDeviceSize offset;
|
||||||
|
struct GPUMemoryChunkStruct* next;
|
||||||
|
} GPUMemoryChunk;
|
||||||
|
|
||||||
|
typedef struct GPUPageStruct {
|
||||||
|
VkDeviceMemory memory;
|
||||||
|
VkDeviceSize size;
|
||||||
|
GPUMemoryType type;
|
||||||
|
|
||||||
|
GPUMemoryChunk* free;
|
||||||
|
GPUMemoryChunk* allocated;
|
||||||
|
|
||||||
|
} GPUPage;
|
||||||
|
|
||||||
|
typedef struct GPUBufferStruct {
|
||||||
|
GPUPage* page;
|
||||||
|
GPUMemoryChunk* memory;
|
||||||
|
VkBuffer handle;
|
||||||
|
} GPUBuffer;
|
||||||
|
|
||||||
|
typedef struct GPUImageStruct {
|
||||||
|
GPUPage* page;
|
||||||
|
GPUMemoryChunk* memory;
|
||||||
|
VkImage handle;
|
||||||
|
} GPUImage;
|
||||||
|
|
||||||
|
GPUMemoryType pick_memory(VkPhysicalDeviceMemoryProperties memories, uint32_t filter, VkMemoryPropertyFlags include, VkMemoryPropertyFlags exclude);
|
||||||
|
|
||||||
|
VkResult gpu_page_allocate(VkDevice device, VkPhysicalDeviceMemoryProperties memories, VkDeviceSize size, uint32_t filter, VkMemoryPropertyFlags include, VkMemoryPropertyFlags exclude, GPUPage** handle);
|
||||||
|
void gpu_page_free(VkDevice device, GPUPage* page);
|
||||||
|
VkResult gpu_buffer_malloc(VkDevice device, GPUPage* page, VkDeviceSize size, VkBufferUsageFlags usage, GPUBuffer* buffer);
|
||||||
|
VkResult gpu_image_malloc(VkDevice device, GPUPage* page, VkImageCreateInfo* info, GPUImage* image);
|
||||||
|
void gpu_buffer_free(VkDevice device, GPUBuffer buffer);
|
||||||
|
|
||||||
|
void gpu_free(GPUPage* page, GPUMemoryChunk* memory);
|
||||||
|
|
||||||
|
|
||||||
|
void fprintchunks(FILE* out, GPUMemoryChunk* start);
|
||||||
|
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -0,0 +1,320 @@
|
|||||||
|
#include <string.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdbool.h>
|
||||||
|
#include <gpu_mem.h>
|
||||||
|
|
||||||
|
GPUMemoryType pick_memory(VkPhysicalDeviceMemoryProperties memories, uint32_t filter, VkMemoryPropertyFlags include, VkMemoryPropertyFlags exclude) {
|
||||||
|
for(uint32_t i = 0; i < memories.memoryTypeCount; i++){
|
||||||
|
if((filter & (1 << i))
|
||||||
|
&& ((include & memories.memoryTypes[i].propertyFlags) == include)
|
||||||
|
&& ((exclude & memories.memoryTypes[i].propertyFlags) == 0)) {
|
||||||
|
GPUMemoryType ret = {
|
||||||
|
.flags = memories.memoryTypes[i].propertyFlags,
|
||||||
|
.index = i,
|
||||||
|
};
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
GPUMemoryType err = {
|
||||||
|
.flags = 0,
|
||||||
|
.index = 0xFFFFFFFF,
|
||||||
|
};
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult gpu_page_allocate(VkDevice device, VkPhysicalDeviceMemoryProperties memories, VkDeviceSize size, uint32_t filter, VkMemoryPropertyFlags include, VkMemoryPropertyFlags exclude, GPUPage** handle) {
|
||||||
|
if(handle == NULL) {
|
||||||
|
return VK_ERROR_VALIDATION_FAILED_EXT;
|
||||||
|
}
|
||||||
|
|
||||||
|
GPUPage* output = malloc(sizeof(GPUPage));
|
||||||
|
if(output == NULL) {
|
||||||
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||||
|
}
|
||||||
|
|
||||||
|
GPUMemoryChunk* initial_chunk = malloc(sizeof(GPUMemoryChunk));
|
||||||
|
if(initial_chunk == 0) {
|
||||||
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||||
|
}
|
||||||
|
|
||||||
|
initial_chunk->size = size;
|
||||||
|
initial_chunk->offset = 0;
|
||||||
|
initial_chunk->next = NULL;
|
||||||
|
|
||||||
|
GPUMemoryType memory_type = pick_memory(memories, filter, include, exclude);
|
||||||
|
if(memory_type.index == 0xFFFFFFFF) {
|
||||||
|
return VK_ERROR_UNKNOWN;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkMemoryAllocateInfo allocate_info = {
|
||||||
|
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
|
||||||
|
.allocationSize = size,
|
||||||
|
.memoryTypeIndex = memory_type.index,
|
||||||
|
.pNext = NULL,
|
||||||
|
};
|
||||||
|
|
||||||
|
VkDeviceMemory memory = VK_NULL_HANDLE;
|
||||||
|
VkResult result = vkAllocateMemory(device, &allocate_info, 0, &memory);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
output->memory = memory;
|
||||||
|
output->size = size;
|
||||||
|
output->type = memory_type;
|
||||||
|
output->free = initial_chunk;
|
||||||
|
output->allocated = NULL;
|
||||||
|
|
||||||
|
*handle = output;
|
||||||
|
|
||||||
|
return VK_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
|
void gpu_page_free(VkDevice device, GPUPage* page) {
|
||||||
|
if(page == NULL) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
GPUMemoryChunk* cur = page->free;
|
||||||
|
while(cur != NULL) {
|
||||||
|
GPUMemoryChunk* last = cur;
|
||||||
|
cur = cur->next;
|
||||||
|
free(last);
|
||||||
|
}
|
||||||
|
|
||||||
|
vkFreeMemory(device, page->memory, 0);
|
||||||
|
free(page);
|
||||||
|
}
|
||||||
|
|
||||||
|
void gpu_add_allocation(GPUPage* page, GPUMemoryChunk* allocation, VkDeviceSize size, GPUMemoryChunk* prev, GPUMemoryChunk* cur) {
|
||||||
|
if(page->allocated == NULL) {
|
||||||
|
page->allocated = allocation;
|
||||||
|
} else {
|
||||||
|
GPUMemoryChunk* alloc_cur = page->allocated;
|
||||||
|
while(alloc_cur->next != NULL) {
|
||||||
|
alloc_cur = alloc_cur->next;
|
||||||
|
}
|
||||||
|
alloc_cur->next = allocation;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(cur->size == size && prev == NULL) {
|
||||||
|
free(cur);
|
||||||
|
page->free = NULL;
|
||||||
|
} else if(cur->size == size && prev != NULL) {
|
||||||
|
prev->next = cur->next;
|
||||||
|
free(cur);
|
||||||
|
} else if(cur->size > size) {
|
||||||
|
cur->offset += size;
|
||||||
|
cur->size -= size;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult gpu_new_allocation(GPUPage* page, GPUMemoryChunk** prev, GPUMemoryChunk** cur, GPUMemoryChunk** allocation, VkDeviceSize size) {
|
||||||
|
if(prev == NULL || cur == NULL || allocation == NULL) {
|
||||||
|
return VK_ERROR_VALIDATION_FAILED_EXT;
|
||||||
|
}
|
||||||
|
|
||||||
|
*cur = page->free;
|
||||||
|
*prev = NULL;
|
||||||
|
|
||||||
|
|
||||||
|
// Find a chunk
|
||||||
|
while(*cur != NULL) {
|
||||||
|
if((*cur)->size >= size) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
*prev = *cur;
|
||||||
|
*cur = (*cur)->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(*cur == NULL) {
|
||||||
|
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
|
||||||
|
}
|
||||||
|
|
||||||
|
*allocation = malloc(sizeof(GPUMemoryChunk));
|
||||||
|
if(*allocation == NULL) {
|
||||||
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
(*allocation)->next = NULL;
|
||||||
|
(*allocation)->size = size;
|
||||||
|
(*allocation)->offset = (*cur)->offset;
|
||||||
|
|
||||||
|
return VK_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult gpu_image_malloc(VkDevice device, GPUPage* page, VkImageCreateInfo* info, GPUImage* image) {
|
||||||
|
if(image == NULL || info == NULL || page == NULL) {
|
||||||
|
return VK_ERROR_VALIDATION_FAILED_EXT;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult result = vkCreateImage(device, info, 0, &image->handle);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkMemoryRequirements requirements;
|
||||||
|
vkGetImageMemoryRequirements(device, image->handle, &requirements);
|
||||||
|
|
||||||
|
GPUMemoryChunk* cur;
|
||||||
|
GPUMemoryChunk* prev;
|
||||||
|
GPUMemoryChunk* allocation;
|
||||||
|
|
||||||
|
result = gpu_new_allocation(page, &prev, &cur, &allocation, requirements.size);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = vkBindImageMemory(device, image->handle, page->memory, cur->offset);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
image->page = page;
|
||||||
|
image->memory = allocation;
|
||||||
|
|
||||||
|
gpu_add_allocation(page, allocation, requirements.size, prev, cur);
|
||||||
|
|
||||||
|
return VK_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult gpu_buffer_malloc(VkDevice device, GPUPage* page, VkDeviceSize size, VkBufferUsageFlags usage, GPUBuffer* buffer) {
|
||||||
|
if(buffer == NULL || page == NULL) {
|
||||||
|
return VK_ERROR_VALIDATION_FAILED_EXT;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkBufferCreateInfo buffer_info = {
|
||||||
|
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
||||||
|
.size = size,
|
||||||
|
.usage = usage,
|
||||||
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
||||||
|
};
|
||||||
|
|
||||||
|
VkResult result = vkCreateBuffer(device, &buffer_info, 0, &buffer->handle);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
GPUMemoryChunk* cur;
|
||||||
|
GPUMemoryChunk* prev;
|
||||||
|
GPUMemoryChunk* allocation;
|
||||||
|
|
||||||
|
result = gpu_new_allocation(page, &prev, &cur, &allocation, size);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = vkBindBufferMemory(device, buffer->handle, page->memory, cur->offset);
|
||||||
|
if(result != VK_SUCCESS) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
buffer->page = page;
|
||||||
|
buffer->memory = allocation;
|
||||||
|
|
||||||
|
gpu_add_allocation(page, allocation, size, prev, cur);
|
||||||
|
|
||||||
|
return VK_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
|
void gpu_buffer_free(VkDevice device, GPUBuffer buffer) {
|
||||||
|
vkDestroyBuffer(device, buffer.handle, 0);
|
||||||
|
gpu_free(buffer.page, buffer.memory);
|
||||||
|
}
|
||||||
|
|
||||||
|
void gpu_free(GPUPage* page, GPUMemoryChunk* memory) {
|
||||||
|
|
||||||
|
if(memory == page->allocated) {
|
||||||
|
page->allocated = memory->next;
|
||||||
|
} else {
|
||||||
|
GPUMemoryChunk* cur = page->allocated;
|
||||||
|
while(cur->next != NULL) {
|
||||||
|
if(cur->next == memory) {
|
||||||
|
cur->next = memory->next;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
cur = cur->next;
|
||||||
|
}
|
||||||
|
if(cur == NULL) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
memory->next = NULL;
|
||||||
|
|
||||||
|
GPUMemoryChunk* free_cur = page->free;
|
||||||
|
GPUMemoryChunk* free_prev = NULL;
|
||||||
|
while(free_cur != NULL) {
|
||||||
|
if(free_cur->offset > memory->offset) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
free_prev = free_cur;
|
||||||
|
free_cur = free_cur->next;
|
||||||
|
}
|
||||||
|
if(free_cur == NULL && free_prev == NULL) {
|
||||||
|
page->free = memory;
|
||||||
|
} else {
|
||||||
|
bool left_cont = false;
|
||||||
|
if (free_prev != NULL) {
|
||||||
|
left_cont = ((free_prev->offset + free_prev->size) == memory->offset);
|
||||||
|
}
|
||||||
|
bool right_cont = false;
|
||||||
|
if (free_cur != NULL) {
|
||||||
|
right_cont = ((memory->offset + memory->size) == free_cur->offset);
|
||||||
|
}
|
||||||
|
|
||||||
|
fprintf(stderr, "l: %d, r: %d\n", left_cont, right_cont);
|
||||||
|
|
||||||
|
if(left_cont && right_cont) {
|
||||||
|
free_prev->next = free_cur->next;
|
||||||
|
free_prev->size += free_cur->size;
|
||||||
|
free_prev->size += memory->size;
|
||||||
|
|
||||||
|
free(free_cur);
|
||||||
|
free(memory);
|
||||||
|
} else if(!left_cont && right_cont) {
|
||||||
|
free_cur->offset -= memory->size;
|
||||||
|
free_cur->size += memory->size;
|
||||||
|
free(memory);
|
||||||
|
} else if(left_cont && !right_cont) {
|
||||||
|
free_prev->size += memory->size;
|
||||||
|
free(memory);
|
||||||
|
} else if(!left_cont && !right_cont) {
|
||||||
|
if(free_cur == NULL) {
|
||||||
|
memory->next = NULL;
|
||||||
|
} else {
|
||||||
|
memory->next = free_cur->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(free_prev == NULL) {
|
||||||
|
memory->next = page->free;
|
||||||
|
page->free = memory;
|
||||||
|
} else {
|
||||||
|
free_prev->next = memory;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void fprintchunks(FILE* out, GPUMemoryChunk* start) {
|
||||||
|
if(start == NULL) {
|
||||||
|
fprintf(out, "Chunks: {}\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
fprintf(out, "Chunks: {");
|
||||||
|
GPUMemoryChunk* cur = start;
|
||||||
|
while(cur != NULL) {
|
||||||
|
if(cur->next == NULL) {
|
||||||
|
fprintf(out, "%llu@%llu}", cur->size, cur->offset);
|
||||||
|
} else {
|
||||||
|
fprintf(out, "%llu@%llu, ", cur->size, cur->offset);
|
||||||
|
}
|
||||||
|
cur = cur->next;
|
||||||
|
}
|
||||||
|
fprintf(out, "\n");
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue