allocator.c

#include <kiba/renderer/vulkan/allocator.h>
 
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
 
// TODO: think about the allocation scopes. Allocations that will be forgotten quickly could use a simpler allocator
// like the linear one. After the scope finished, the allocator could be reset instead of individually freeing the
// memory.
 
const char *vulkan_allocation_scope_names[] = {
    "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND",
    "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT",
    "VK_SYSTEM_ALLOCATION_SCOPE_CACHE",
    "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE",
    "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE",
};
 
void *vulkan_allocation_function(void                   *pUserData,
                                 size_t                  size,
                                 size_t                  alignment,
                                 VkSystemAllocationScope allocationScope);
 
void vulkan_free_function(void *pUserData, void *pMemory);
 
void vulkan_internal_allocation_notification(void                    *pUserData,
                                             size_t                   size,
                                             VkInternalAllocationType allocationType,
                                             VkSystemAllocationScope  allocationScope);
 
void vulkan_internal_free_notification(void                    *pUserData,
                                       size_t                   size,
                                       VkInternalAllocationType allocationType,
                                       VkSystemAllocationScope  allocationScope);
 
void *vulkan_reallocation_function(void                   *pUserData,
                                   void                   *pOriginal,
                                   size_t                  size,
                                   size_t                  alignment,
                                   VkSystemAllocationScope allocationScope);
 
b8 vulkan_allocator_create(vulkan_allocator *alloc) {
    if (!allocator_create(&alloc->kiba_alloc, ALLOCATOR_FREE_LIST, 2048)) {
        KB_ERROR("could not create kiba allocator for vulkan allocator");
        return false;
    }
 
    alloc->vulkan_callbacks.pUserData             = alloc;
    alloc->vulkan_callbacks.pfnAllocation         = vulkan_allocation_function;
    alloc->vulkan_callbacks.pfnFree               = vulkan_free_function;
    alloc->vulkan_callbacks.pfnInternalAllocation = vulkan_internal_allocation_notification;
    alloc->vulkan_callbacks.pfnInternalFree       = vulkan_internal_free_notification;
    alloc->vulkan_callbacks.pfnReallocation       = vulkan_reallocation_function;
    return true;
}
 
void vulkan_allocator_destroy(vulkan_allocator *alloc) {
    alloc->vulkan_callbacks.pUserData             = KB_NULL;
    alloc->vulkan_callbacks.pfnAllocation         = KB_NULL;
    alloc->vulkan_callbacks.pfnFree               = KB_NULL;
    alloc->vulkan_callbacks.pfnInternalAllocation = KB_NULL;
    alloc->vulkan_callbacks.pfnInternalFree       = KB_NULL;
    alloc->vulkan_callbacks.pfnReallocation       = KB_NULL;
    allocator_destroy(&alloc->kiba_alloc);
}
 
void *vulkan_allocation_function(void                   *pUserData,
                                 size_t                  size,
                                 size_t                  alignment,
                                 VkSystemAllocationScope allocationScope) {
    UNUSED(allocationScope);
    KB_TRACE("vulkan allocating {usize} bytes aligned to {usize} with scope {raw_string}",
             size,
             alignment,
             vulkan_allocation_scope_names[allocationScope]);
    vulkan_allocator *alloc        = pUserData;
    void             *ret          = allocator_allocate_aligned(&alloc->kiba_alloc, size, alignment);
    uptr              misalignment = (uptr) ret % alignment;
    KB_ASSERT(misalignment == 0, "allcation must be aligned as requested");
    return ret;
}
 
void vulkan_free_function(void *pUserData, void *pMemory) {
    KB_TRACE("vulkan freeing {pointer}", pMemory);
    vulkan_allocator *alloc = pUserData;
    if (pMemory != KB_NULL) {
        allocator_free(&alloc->kiba_alloc, pMemory);
    }
}
 
void vulkan_internal_allocation_notification(void                    *pUserData,
                                             size_t                   size,
                                             VkInternalAllocationType allocationType,
                                             VkSystemAllocationScope  allocationScope) {
    UNUSED(pUserData);
    UNUSED(size);
    UNUSED(allocationType);
    UNUSED(allocationScope);
    KB_DEBUG("vulkan allocating {usize} bytes of type {u32} with scope {raw_string}",
             size,
             allocationType,
             vulkan_allocation_scope_names[allocationScope]);
}
 
void vulkan_internal_free_notification(void                    *pUserData,
                                       size_t                   size,
                                       VkInternalAllocationType allocationType,
                                       VkSystemAllocationScope  allocationScope) {
    UNUSED(pUserData);
    UNUSED(size);
    UNUSED(allocationType);
    UNUSED(allocationScope);
    KB_DEBUG("vulkan freeing {usize} bytes of type {u32} with scope {raw_string}",
             size,
             allocationType,
             vulkan_allocation_scope_names[allocationScope]);
}
 
void *vulkan_reallocation_function(void                   *pUserData,
                                   void                   *pOriginal,
                                   size_t                  size,
                                   size_t                  alignment,
                                   VkSystemAllocationScope allocationScope) {
    UNUSED(allocationScope);
    KB_TRACE("vulkan reallocating {pointer} to {usize} bytes aligned to {usize} with scope {raw_string}",
             pOriginal,
             size,
             alignment,
             vulkan_allocation_scope_names[allocationScope]);
    vulkan_allocator *alloc = pUserData;
 
    if (pOriginal == KB_NULL) {
        return vulkan_allocation_function(pUserData, size, alignment, allocationScope);
    }
    if (size == 0) {
        vulkan_free_function(pUserData, pOriginal);
        return 0;
    }
    void *ret          = allocator_reallocate_aligned(&alloc->kiba_alloc, pOriginal, size, alignment);
    uptr  misalignment = (uptr) ret % alignment;
    KB_ASSERT(misalignment == 0, "reallcation must be aligned as requested");
    return ret;
}