device_memory_allocator.c File Reference

#include "shared/shared.h"
#include <vulkan/vulkan.h>
#include <assert.h>
#include "device_memory_allocator.h"
#include "buddy_allocator.h"
#include "vkpt.h"

Go to the source code of this file.

Classes
struct	SubAllocator
struct	DeviceMemoryAllocator

Macros
#define	ALLOCATOR_CAPACITY   33554432
#define	ALLOCATOR_BLOCK_SIZE   1024

Typedefs
typedef struct SubAllocator	SubAllocator
typedef struct DeviceMemoryAllocator	DeviceMemoryAllocator

Functions
int	create_sub_allocator (DeviceMemoryAllocator *allocator, uint32_t memory_type)
DeviceMemoryAllocator *	create_device_memory_allocator (VkDevice device)
DMAResult	allocate_device_memory (DeviceMemoryAllocator *allocator, DeviceMemory *device_memory)
void	free_device_memory (DeviceMemoryAllocator *allocator, const DeviceMemory *device_memory)
void	destroy_device_memory_allocator (DeviceMemoryAllocator *allocator)

Macro Definition Documentation

ALLOCATOR_BLOCK_SIZE

#define ALLOCATOR_BLOCK_SIZE   1024

Definition at line 30 of file device_memory_allocator.c.

ALLOCATOR_CAPACITY

#define ALLOCATOR_CAPACITY   33554432

Definition at line 29 of file device_memory_allocator.c.

Typedef Documentation

DeviceMemoryAllocator

typedef struct DeviceMemoryAllocator DeviceMemoryAllocator

SubAllocator

typedef struct SubAllocator SubAllocator

Function Documentation

allocate_device_memory()

DMAResult allocate_device_memory	(	DeviceMemoryAllocator *	allocator,
		DeviceMemory *	device_memory
	)

Definition at line 60 of file device_memory_allocator.c.

{
    const uint32_t memory_type = device_memory->memory_type;
    if (allocator->sub_allocators[memory_type] == NULL)
    {
        if (!create_sub_allocator(allocator, memory_type))
            return DMA_NOT_ENOUGH_MEMORY;
    }
 
    assert(device_memory->size <= ALLOCATOR_CAPACITY);
 
    BAResult result = BA_NOT_ENOUGH_MEMORY;
    SubAllocator* sub_allocator = allocator->sub_allocators[memory_type];
 
    while (result != BA_SUCCESS)
    {
        device_memory->memory = sub_allocator->memory;
 
        result = buddy_allocator_allocate(sub_allocator->buddy_allocator, device_memory->size,
            device_memory->alignment, &device_memory->memory_offset);
 
        assert(result <= BA_NOT_ENOUGH_MEMORY);
        if (result == BA_NOT_ENOUGH_MEMORY)
        {
            if (sub_allocator->next != NULL)
            {
                sub_allocator = sub_allocator->next;
            }
            else
            {
                if (!create_sub_allocator(allocator, memory_type))
                    return DMA_NOT_ENOUGH_MEMORY;
                sub_allocator = allocator->sub_allocators[memory_type];
            }
        }
    }
 
    return DMA_SUCCESS;
}

Referenced by create_invalid_texture(), and vkpt_textures_end_registration().

create_device_memory_allocator()

DeviceMemoryAllocator* create_device_memory_allocator

(

VkDevice

device

)

Definition at line 48 of file device_memory_allocator.c.

{
    char* memory = malloc(sizeof(DeviceMemoryAllocator));
 
    DeviceMemoryAllocator* allocator = (DeviceMemoryAllocator*)memory;
    memset(allocator, 0, sizeof(DeviceMemoryAllocator));
    allocator->memory = memory;
    allocator->device = device;
 
    return allocator;
}

Referenced by vkpt_textures_initialize().

create_sub_allocator()

int create_sub_allocator	(	DeviceMemoryAllocator *	allocator,
		uint32_t	memory_type
	)

Definition at line 125 of file device_memory_allocator.c.

{
    SubAllocator* sub_allocator = (SubAllocator*)malloc(sizeof(SubAllocator));
 
    VkMemoryAllocateInfo memory_allocate_info = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize = ALLOCATOR_CAPACITY,
        .memoryTypeIndex = memory_type
    };
 
#ifdef VKPT_DEVICE_GROUPS
    VkMemoryAllocateFlagsInfoKHR mem_alloc_flags = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR,
        .flags = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR,
        .deviceMask = (1 << qvk.device_count) - 1
    };
 
    if (qvk.device_count > 1) {
        memory_allocate_info.pNext = &mem_alloc_flags;
    }
#endif
 
    const VkResult result = vkAllocateMemory(allocator->device, &memory_allocate_info, NULL, &sub_allocator->memory);
    if (result != VK_SUCCESS)
        return 0;
 
    sub_allocator->buddy_allocator = create_buddy_allocator(ALLOCATOR_CAPACITY, ALLOCATOR_BLOCK_SIZE);
    sub_allocator->next = allocator->sub_allocators[memory_type];
    allocator->sub_allocators[memory_type] = sub_allocator;
 
    return 1;
}

Referenced by allocate_device_memory().

destroy_device_memory_allocator()

void destroy_device_memory_allocator

(

DeviceMemoryAllocator *

allocator

)

Definition at line 110 of file device_memory_allocator.c.

{
    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
    {
        SubAllocator* sub_allocator = allocator->sub_allocators[i];
        while (sub_allocator != NULL)
        {
            vkFreeMemory(allocator->device, sub_allocator->memory, NULL);
            sub_allocator = sub_allocator->next;
        }
    }
 
    free(allocator->memory);
}

Referenced by vkpt_textures_destroy().

free_device_memory()

void free_device_memory	(	DeviceMemoryAllocator *	allocator,
		const DeviceMemory *	device_memory
	)

Definition at line 100 of file device_memory_allocator.c.

{
    SubAllocator* sub_allocator = allocator->sub_allocators[device_memory->memory_type];
 
    while (sub_allocator->memory != device_memory->memory)
        sub_allocator = sub_allocator->next;
 
    buddy_allocator_free(sub_allocator->buddy_allocator, device_memory->memory_offset, device_memory->size);
}

Referenced by destroy_invalid_texture(), destroy_tex_images(), IMG_ReloadAll(), and textures_destroy_unused_set().