rooty/rpi-vk-driver
1
0
Fork 0
mirror of https://github.com/Yours3lf/rpi-vk-driver.git synced 2025-02-19 16:54:18 +01:00
Code Issues Releases Wiki Activity

allocators are now supported, more CTS fixes.

Browse Source
This commit is contained in:
Unknown 2018-11-17 15:53:13 +00:00
parent fb2af568b2
commit ce9668b992
12 changed files with 109 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
driver/command.c
View File

@ -20,9 +20,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
assert(device); assert(device);
assert(pCreateInfo); assert(pCreateInfo);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
//VK_COMMAND_POOL_CREATE_TRANSIENT_BIT //VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
//specifies that command buffers allocated from the pool will be short-lived, meaning that they will be reset or freed in a relatively short timeframe. //specifies that command buffers allocated from the pool will be short-lived, meaning that they will be reset or freed in a relatively short timeframe.
//This flag may be used by the implementation to control memory allocation behavior within the pool. //This flag may be used by the implementation to control memory allocation behavior within the pool.
@ -34,7 +31,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
//TODO pool family ignored for now //TODO pool family ignored for now
_commandPool* cp = malloc(sizeof(_commandPool)); _commandPool* cp = ALLOCATE(sizeof(_commandPool), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!cp) if(!cp)
{ {
@ -43,26 +40,39 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
cp->queueFamilyIndex = pCreateInfo->queueFamilyIndex; cp->queueFamilyIndex = pCreateInfo->queueFamilyIndex;
//TODO CTS fails as we can't allocate enough memory for some reason
//tweak system allocation as root using:
//make sure kernel denies memory allocation that it won't be able to serve
//sysctl -w vm.overcommit_memory="2"
//specify after how much memory used the kernel will start denying requests
//sysctl -w vm.overcommit_ratio="80"
//
//initial number of command buffers to hold //initial number of command buffers to hold
int numCommandBufs = 100; int numCommandBufs = 128;
int controlListSize = ARM_PAGE_SIZE * 100; int consecutivePoolSize = ARM_PAGE_SIZE*128;
int consecutiveBlockSize = ARM_PAGE_SIZE>>2;
static int counter = 0;
//if(pCreateInfo->flags & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) //if(pCreateInfo->flags & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)
{ {
//use pool allocator //use pool allocator
void* pamem = malloc(numCommandBufs * sizeof(_commandBuffer)); void* pamem = ALLOCATE(numCommandBufs * sizeof(_commandBuffer), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pamem) if(!pamem)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
} }
cp->pa = createPoolAllocator(pamem, sizeof(_commandBuffer), numCommandBufs * sizeof(_commandBuffer)); cp->pa = createPoolAllocator(pamem, sizeof(_commandBuffer), numCommandBufs * sizeof(_commandBuffer));
void* cpamem = malloc(controlListSize); void* cpamem = ALLOCATE(consecutivePoolSize, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!cpamem) if(!cpamem)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
} }
cp->cpa = createConsecutivePoolAllocator(cpamem, ARM_PAGE_SIZE, controlListSize); cp->cpa = createConsecutivePoolAllocator(cpamem, consecutiveBlockSize, consecutivePoolSize);
} }
*pCommandPool = (VkCommandPool)cp; *pCommandPool = (VkCommandPool)cp;
@ -394,20 +404,17 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
assert(device); assert(device);
assert(commandPool); assert(commandPool);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
_commandPool* cp = (_commandPool*)commandPool; _commandPool* cp = (_commandPool*)commandPool;
//if(cp->usePoolAllocator) //if(cp->usePoolAllocator)
{ {
free(cp->pa.buf); FREE(cp->pa.buf);
free(cp->cpa.buf); FREE(cp->cpa.buf);
destroyPoolAllocator(&cp->pa); destroyPoolAllocator(&cp->pa);
destroyConsecutivePoolAllocator(&cp->cpa); destroyConsecutivePoolAllocator(&cp->cpa);
} }
free(cp); FREE(cp);
} }
/* /*

4
driver/common.c
View File

@ -20,11 +20,13 @@ uint32_t getFormatBpp(VkFormat f)
case VK_FORMAT_R8G8_UNORM: case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R16_SFLOAT: case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_R16_SINT: case VK_FORMAT_R16_SINT:
case VK_FORMAT_D16_UNORM:
return 16; return 16;
case VK_FORMAT_R8_UNORM: case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_SINT: case VK_FORMAT_R8_SINT:
return 8; return 8;
default: default://
printf("format %i\n", f);
assert(0); assert(0);
return 0; return 0;
} }

12
driver/common.h
View File

@ -34,6 +34,18 @@
#include "vkCaps.h" #include "vkCaps.h"
/**
//scope
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
**/
#define ALLOCATE(size, alignment, scope) (pAllocator == 0) ? malloc(size) : pAllocator->pfnAllocation(pAllocator->pUserData, size, alignment, scope);
#define FREE(memory) (pAllocator == 0) ? free(memory) : pAllocator->pfnFree(pAllocator->pUserData, memory);
typedef struct VkDevice_T _device; typedef struct VkDevice_T _device;
typedef struct VkQueue_T typedef struct VkQueue_T

16
driver/device.c
View File

@ -196,9 +196,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
assert(pDevice); assert(pDevice);
assert(pCreateInfo); assert(pCreateInfo);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
//check for enabled extensions //check for enabled extensions
for(int c = 0; c < pCreateInfo->enabledExtensionCount; ++c) for(int c = 0; c < pCreateInfo->enabledExtensionCount; ++c)
{ {
@ -224,8 +221,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
} }
} }
*pDevice = malloc(sizeof(_device)); *pDevice = ALLOCATE(sizeof(_device), 1, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if(!pDevice) if(!*pDevice)
{ {
return VK_ERROR_TOO_MANY_OBJECTS; return VK_ERROR_TOO_MANY_OBJECTS;
} }
@ -273,7 +270,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
{ {
for(int c = 0; c < pCreateInfo->queueCreateInfoCount; ++c) for(int c = 0; c < pCreateInfo->queueCreateInfoCount; ++c)
{ {
(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex] = malloc(sizeof(_queue)*pCreateInfo->pQueueCreateInfos[c].queueCount); (*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex] = ALLOCATE(sizeof(_queue)*pCreateInfo->pQueueCreateInfos[c].queueCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex]) if(!(*pDevice)->queues[pCreateInfo->pQueueCreateInfos[c].queueFamilyIndex])
{ {
@ -325,19 +322,16 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
{ {
assert(device); assert(device);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
_device* dev = device; _device* dev = device;
for(int c = 0; c < numQueueFamilies; ++c) for(int c = 0; c < numQueueFamilies; ++c)
{ {
for(int d = 0; d < dev->numQueues[c]; ++d) for(int d = 0; d < dev->numQueues[c]; ++d)
{ {
free(dev->queues[d]); FREE(dev->queues[d]);
} }
} }
free(dev); FREE(dev);
} }
/* /*

10
driver/instance.c
View File

@ -55,7 +55,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
assert(pInstance); assert(pInstance);
assert(pCreateInfo); assert(pCreateInfo);
*pInstance = malloc(sizeof(_instance)); *pInstance = ALLOCATE(sizeof(_instance), 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if(!*pInstance) if(!*pInstance)
{ {
@ -64,9 +64,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
(*pInstance)->numEnabledExtensions = 0; (*pInstance)->numEnabledExtensions = 0;
//TODO: allocator is ignored for now
assert(pAllocator == 0);
//TODO: possibly we need to load layers here //TODO: possibly we need to load layers here
//and store them in pInstance //and store them in pInstance
assert(pCreateInfo->enabledLayerCount == 0); assert(pCreateInfo->enabledLayerCount == 0);
@ -123,12 +120,9 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
{ {
assert(instance); assert(instance);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
closeIoctl(); closeIoctl();
free(instance); FREE(instance);
} }
/* /*

8
driver/memory.c
View File

@ -65,15 +65,13 @@ VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocate
assert(pAllocateInfo); assert(pAllocateInfo);
assert(pMemory); assert(pMemory);
assert(pAllocator == 0); //TODO
uint32_t bo = vc4_bo_alloc(device->dev->instance->controlFd, pAllocateInfo->allocationSize, "vkAllocateMemory"); uint32_t bo = vc4_bo_alloc(device->dev->instance->controlFd, pAllocateInfo->allocationSize, "vkAllocateMemory");
if(!bo) if(!bo)
{ {
return VK_ERROR_OUT_OF_DEVICE_MEMORY; return VK_ERROR_OUT_OF_DEVICE_MEMORY;
} }
_deviceMemory* mem = malloc(sizeof(_deviceMemory)); _deviceMemory* mem = ALLOCATE(sizeof(_deviceMemory), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!mem) if(!mem)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -143,11 +141,9 @@ void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCall
assert(device); assert(device);
assert(memory); assert(memory);
assert(pAllocator == 0); //TODO
_deviceMemory* mem = memory; _deviceMemory* mem = memory;
vc4_bo_free(device->dev->instance->controlFd, mem->bo, mem->mappedPtr, mem->size); vc4_bo_free(device->dev->instance->controlFd, mem->bo, mem->mappedPtr, mem->size);
free(mem); FREE(mem);
} }
/* /*

35
driver/pipeline.c
View File

@ -31,11 +31,10 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
assert(pPipelines); assert(pPipelines);
assert(pipelineCache == 0); //TODO not supported right now assert(pipelineCache == 0); //TODO not supported right now
assert(pAllocator == 0); //TODO
for(int c = 0; c < createInfoCount; ++c) for(int c = 0; c < createInfoCount; ++c)
{ {
_pipeline* pip = malloc(sizeof(_pipeline)); _pipeline* pip = ALLOCATE(sizeof(_pipeline), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip) if(!pip)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -46,7 +45,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
uint32_t idx = ulog2(pCreateInfos->pStages[d].stage); uint32_t idx = ulog2(pCreateInfos->pStages[d].stage);
pip->modules[idx] = pCreateInfos->pStages[d].module; pip->modules[idx] = pCreateInfos->pStages[d].module;
pip->names[idx] = malloc(strlen(pCreateInfos->pStages[d].pName)+1); pip->names[idx] = ALLOCATE(strlen(pCreateInfos->pStages[d].pName)+1, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->names[idx]) if(!pip->names[idx])
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -56,7 +55,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
} }
pip->vertexAttributeDescriptionCount = pCreateInfos->pVertexInputState->vertexAttributeDescriptionCount; pip->vertexAttributeDescriptionCount = pCreateInfos->pVertexInputState->vertexAttributeDescriptionCount;
pip->vertexAttributeDescriptions = malloc(sizeof(VkVertexInputAttributeDescription) * pip->vertexAttributeDescriptionCount); pip->vertexAttributeDescriptions = ALLOCATE(sizeof(VkVertexInputAttributeDescription) * pip->vertexAttributeDescriptionCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->vertexAttributeDescriptions) if(!pip->vertexAttributeDescriptions)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -65,7 +64,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
memcpy(pip->vertexAttributeDescriptions, pCreateInfos->pVertexInputState->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription) * pip->vertexAttributeDescriptionCount); memcpy(pip->vertexAttributeDescriptions, pCreateInfos->pVertexInputState->pVertexAttributeDescriptions, sizeof(VkVertexInputAttributeDescription) * pip->vertexAttributeDescriptionCount);
pip->vertexBindingDescriptionCount = pCreateInfos->pVertexInputState->vertexBindingDescriptionCount; pip->vertexBindingDescriptionCount = pCreateInfos->pVertexInputState->vertexBindingDescriptionCount;
pip->vertexBindingDescriptions = malloc(sizeof(VkVertexInputBindingDescription) * pip->vertexBindingDescriptionCount); pip->vertexBindingDescriptions = ALLOCATE(sizeof(VkVertexInputBindingDescription) * pip->vertexBindingDescriptionCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->vertexBindingDescriptions) if(!pip->vertexBindingDescriptions)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -79,7 +78,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
//TODO tessellation ignored //TODO tessellation ignored
pip->viewportCount = pCreateInfos->pViewportState->viewportCount; pip->viewportCount = pCreateInfos->pViewportState->viewportCount;
pip->viewports = malloc(sizeof(VkViewport) * pip->viewportCount); pip->viewports = ALLOCATE(sizeof(VkViewport) * pip->viewportCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->viewports) if(!pip->viewports)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -89,7 +88,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
pip->scissorCount = pCreateInfos->pViewportState->scissorCount; pip->scissorCount = pCreateInfos->pViewportState->scissorCount;
pip->scissors = malloc(sizeof(VkRect2D) * pip->viewportCount); pip->scissors = ALLOCATE(sizeof(VkRect2D) * pip->viewportCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->scissors) if(!pip->scissors)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -135,7 +134,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
pip->logicOpEnable = pCreateInfos->pColorBlendState->logicOpEnable; pip->logicOpEnable = pCreateInfos->pColorBlendState->logicOpEnable;
pip->logicOp = pCreateInfos->pColorBlendState->logicOp; pip->logicOp = pCreateInfos->pColorBlendState->logicOp;
pip->attachmentCount = pCreateInfos->pColorBlendState->attachmentCount; pip->attachmentCount = pCreateInfos->pColorBlendState->attachmentCount;
pip->attachmentBlendStates = malloc(sizeof(VkPipelineColorBlendAttachmentState) * pip->attachmentCount); pip->attachmentBlendStates = ALLOCATE(sizeof(VkPipelineColorBlendAttachmentState) * pip->attachmentCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->attachmentBlendStates) if(!pip->attachmentBlendStates)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -149,7 +148,7 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach
if(pCreateInfos->pDynamicState) if(pCreateInfos->pDynamicState)
{ {
pip->dynamicStateCount = pCreateInfos->pDynamicState->dynamicStateCount; pip->dynamicStateCount = pCreateInfos->pDynamicState->dynamicStateCount;
pip->dynamicStates = malloc(sizeof(VkDynamicState)*pip->dynamicStateCount); pip->dynamicStates = ALLOCATE(sizeof(VkDynamicState)*pip->dynamicStateCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pip->dynamicStates) if(!pip->dynamicStates)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -180,21 +179,19 @@ void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationC
assert(device); assert(device);
assert(pipeline); assert(pipeline);
assert(pAllocator == 0); //TODO
_pipeline* pip = pipeline; _pipeline* pip = pipeline;
free(pip->dynamicStates); FREE(pip->dynamicStates);
free(pip->attachmentBlendStates); FREE(pip->attachmentBlendStates);
free(pip->scissors); FREE(pip->scissors);
free(pip->viewports); FREE(pip->viewports);
free(pip->vertexBindingDescriptions); FREE(pip->vertexBindingDescriptions);
free(pip->vertexAttributeDescriptions); FREE(pip->vertexAttributeDescriptions);
for(int c = 0; c < 6; ++c) for(int c = 0; c < 6; ++c)
{ {
free(pip->names[c]); FREE(pip->names[c]);
} }
free(pip); FREE(pip);
} }

52
driver/renderpass.c
View File

@ -58,19 +58,17 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
assert(pCreateInfo); assert(pCreateInfo);
assert(pRenderPass); assert(pRenderPass);
assert(pAllocator == 0); //TODO allocators not supported yet
//just copy all data from create info //just copy all data from create info
//we'll later need to bake the control list based on this //we'll later need to bake the control list based on this
_renderpass* rp = malloc(sizeof(_renderpass)); _renderpass* rp = ALLOCATE(sizeof(_renderpass), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp) if(!rp)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
} }
rp->numAttachments = pCreateInfo->attachmentCount; rp->numAttachments = pCreateInfo->attachmentCount;
rp->attachments = malloc(sizeof(VkAttachmentDescription)*rp->numAttachments); rp->attachments = ALLOCATE(sizeof(VkAttachmentDescription)*rp->numAttachments, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->attachments) if(!rp->attachments)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -79,7 +77,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
memcpy(rp->attachments, pCreateInfo->pAttachments, sizeof(VkAttachmentDescription)*rp->numAttachments); memcpy(rp->attachments, pCreateInfo->pAttachments, sizeof(VkAttachmentDescription)*rp->numAttachments);
rp->numSubpasses = pCreateInfo->subpassCount; rp->numSubpasses = pCreateInfo->subpassCount;
rp->subpasses = malloc(sizeof(VkSubpassDescription)*rp->numSubpasses); rp->subpasses = ALLOCATE(sizeof(VkSubpassDescription)*rp->numSubpasses, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses) if(!rp->subpasses)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -95,7 +93,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
if(rp->subpasses[c].inputAttachmentCount) if(rp->subpasses[c].inputAttachmentCount)
{ {
rp->subpasses[c].pInputAttachments = malloc(sizeof(VkAttachmentReference)*rp->subpasses[c].inputAttachmentCount); rp->subpasses[c].pInputAttachments = ALLOCATE(sizeof(VkAttachmentReference)*rp->subpasses[c].inputAttachmentCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses[c].pInputAttachments) if(!rp->subpasses[c].pInputAttachments)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -110,7 +108,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
if(rp->subpasses[c].colorAttachmentCount) if(rp->subpasses[c].colorAttachmentCount)
{ {
rp->subpasses[c].pColorAttachments = malloc(sizeof(VkAttachmentReference)*rp->subpasses[c].colorAttachmentCount); rp->subpasses[c].pColorAttachments = ALLOCATE(sizeof(VkAttachmentReference)*rp->subpasses[c].colorAttachmentCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses[c].pColorAttachments) if(!rp->subpasses[c].pColorAttachments)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -125,7 +123,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
if(rp->subpasses[c].colorAttachmentCount && pCreateInfo->pSubpasses[c].pResolveAttachments) if(rp->subpasses[c].colorAttachmentCount && pCreateInfo->pSubpasses[c].pResolveAttachments)
{ {
rp->subpasses[c].pResolveAttachments = malloc(sizeof(VkAttachmentReference)*rp->subpasses[c].colorAttachmentCount); rp->subpasses[c].pResolveAttachments = ALLOCATE(sizeof(VkAttachmentReference)*rp->subpasses[c].colorAttachmentCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses[c].pResolveAttachments) if(!rp->subpasses[c].pResolveAttachments)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -140,7 +138,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
if(pCreateInfo->pSubpasses[c].pDepthStencilAttachment) if(pCreateInfo->pSubpasses[c].pDepthStencilAttachment)
{ {
rp->subpasses[c].pDepthStencilAttachment = malloc(sizeof(VkAttachmentReference)); rp->subpasses[c].pDepthStencilAttachment = ALLOCATE(sizeof(VkAttachmentReference), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses[c].pDepthStencilAttachment) if(!rp->subpasses[c].pDepthStencilAttachment)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -155,7 +153,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
if(rp->subpasses[c].preserveAttachmentCount) if(rp->subpasses[c].preserveAttachmentCount)
{ {
rp->subpasses[c].pPreserveAttachments = malloc(sizeof(uint32_t)*rp->subpasses[c].preserveAttachmentCount); rp->subpasses[c].pPreserveAttachments = ALLOCATE(sizeof(uint32_t)*rp->subpasses[c].preserveAttachmentCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpasses[c].pPreserveAttachments) if(!rp->subpasses[c].pPreserveAttachments)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -170,7 +168,7 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea
} }
rp->numSubpassDependencies = pCreateInfo->dependencyCount; rp->numSubpassDependencies = pCreateInfo->dependencyCount;
rp->subpassDependencies = malloc(sizeof(VkSubpassDependency)*rp->numSubpassDependencies); rp->subpassDependencies = ALLOCATE(sizeof(VkSubpassDependency)*rp->numSubpassDependencies, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!rp->subpassDependencies) if(!rp->subpassDependencies)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -188,26 +186,24 @@ void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAlloc
assert(device); assert(device);
assert(renderPass); assert(renderPass);
assert(pAllocator == 0); //TODO
_renderpass* rp = renderPass; _renderpass* rp = renderPass;
free(rp->subpassDependencies); FREE(rp->subpassDependencies);
for(int c = 0; c < rp->numSubpasses; ++c) for(int c = 0; c < rp->numSubpasses; ++c)
{ {
free(rp->subpasses[c].pInputAttachments); FREE(rp->subpasses[c].pInputAttachments);
free(rp->subpasses[c].pColorAttachments); FREE(rp->subpasses[c].pColorAttachments);
free(rp->subpasses[c].pResolveAttachments); FREE(rp->subpasses[c].pResolveAttachments);
free(rp->subpasses[c].pDepthStencilAttachment); FREE(rp->subpasses[c].pDepthStencilAttachment);
free(rp->subpasses[c].pPreserveAttachments); FREE(rp->subpasses[c].pPreserveAttachments);
} }
free(rp->subpasses); FREE(rp->subpasses);
free(rp->attachments); FREE(rp->attachments);
free(rp); FREE(rp);
} }
/* /*
@ -219,9 +215,7 @@ VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCr
assert(pCreateInfo); assert(pCreateInfo);
assert(pFramebuffer); assert(pFramebuffer);
assert(pAllocator == 0); //TODO _framebuffer* fb = ALLOCATE(sizeof(_framebuffer), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_framebuffer* fb = malloc(sizeof(_framebuffer));
if(!fb) if(!fb)
{ {
@ -231,7 +225,7 @@ VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCr
fb->renderpass = pCreateInfo->renderPass; fb->renderpass = pCreateInfo->renderPass;
fb->numAttachmentViews = pCreateInfo->attachmentCount; fb->numAttachmentViews = pCreateInfo->attachmentCount;
fb->attachmentViews = malloc(sizeof(_imageView) * fb->numAttachmentViews); fb->attachmentViews = ALLOCATE(sizeof(_imageView) * fb->numAttachmentViews, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!fb->attachmentViews) if(!fb->attachmentViews)
{ {
@ -259,11 +253,9 @@ void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAl
assert(device); assert(device);
assert(framebuffer); assert(framebuffer);
assert(pAllocator == 0); //TODO
_framebuffer* fb = framebuffer; _framebuffer* fb = framebuffer;
free(fb->attachmentViews); FREE(fb->attachmentViews);
free(fb); FREE(fb);
} }
/* /*

36
driver/resource.c
View File

@ -11,9 +11,7 @@ VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreate
assert(pCreateInfo); assert(pCreateInfo);
assert(pView); assert(pView);
assert(pAllocator == 0); //TODO _imageView* view = ALLOCATE(sizeof(_imageView), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_imageView* view = malloc(sizeof(_imageView));
if(!view) if(!view)
{ {
@ -42,9 +40,7 @@ VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
assert(pCreateInfo); assert(pCreateInfo);
assert(pBuffer); assert(pBuffer);
assert(pAllocator == 0); //TODO _buffer* buf = ALLOCATE(sizeof(_buffer), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_buffer* buf = malloc(sizeof(_buffer));
if(!buf) if(!buf)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -103,10 +99,8 @@ void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbac
assert(device); assert(device);
assert(buffer); assert(buffer);
assert(pAllocator == 0); //TODO
_buffer* buf = buffer; _buffer* buf = buffer;
free(buf); FREE(buf);
} }
void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
@ -114,10 +108,8 @@ void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocati
assert(device); assert(device);
assert(imageView); assert(imageView);
assert(pAllocator == 0); //TODO
_imageView* view = imageView; _imageView* view = imageView;
free(view); FREE(view);
} }
@ -134,9 +126,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
assert(pCreateInfo); assert(pCreateInfo);
assert(pView); assert(pView);
assert(pAllocator == 0); //TODO _bufferView* bv = ALLOCATE(sizeof(_bufferView), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_bufferView* bv = malloc(sizeof(_bufferView));
bv->buffer = pCreateInfo->buffer; bv->buffer = pCreateInfo->buffer;
bv->format = pCreateInfo->format; bv->format = pCreateInfo->format;
@ -157,10 +147,8 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
assert(device); assert(device);
assert(bufferView); assert(bufferView);
assert(pAllocator == 0); //TODO
_bufferView* bv = bufferView; _bufferView* bv = bufferView;
free(bv); FREE(bv);
} }
/* /*
@ -176,9 +164,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
assert(pCreateInfo); assert(pCreateInfo);
assert(pImage); assert(pImage);
assert(pAllocator == 0); _image* i = ALLOCATE(sizeof(_image), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_image* i = malloc(sizeof(_image));
if(!i) if(!i)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -212,7 +198,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
i->numQueueFamiliesWithAccess = pCreateInfo->queueFamilyIndexCount; i->numQueueFamiliesWithAccess = pCreateInfo->queueFamilyIndexCount;
if(i->numQueueFamiliesWithAccess > 0) if(i->numQueueFamiliesWithAccess > 0)
{ {
i->queueFamiliesWithAccess = malloc(sizeof(uint32_t) * i->numQueueFamiliesWithAccess); i->queueFamiliesWithAccess = ALLOCATE(sizeof(uint32_t) * i->numQueueFamiliesWithAccess, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!i->queueFamiliesWithAccess) if(!i->queueFamiliesWithAccess)
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
memcpy(i->queueFamiliesWithAccess, pCreateInfo->pQueueFamilyIndices, sizeof(uint32_t) * i->numQueueFamiliesWithAccess); memcpy(i->queueFamiliesWithAccess, pCreateInfo->pQueueFamilyIndices, sizeof(uint32_t) * i->numQueueFamiliesWithAccess);
@ -239,14 +225,12 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
assert(device); assert(device);
assert(image); assert(image);
assert(pAllocator == 0); //TODO
_image* i = image; _image* i = image;
if(i->numQueueFamiliesWithAccess > 0); if(i->numQueueFamiliesWithAccess > 0);
free(i->queueFamiliesWithAccess); FREE(i->queueFamiliesWithAccess);
free(i); FREE(i);
} }
/* /*

8
driver/shader.c
View File

@ -10,9 +10,7 @@ VkResult vkCreateShaderModuleFromRpiAssemblyKHR(VkDevice device, VkRpiShaderModu
assert(pCreateInfo->byteStreamArray); assert(pCreateInfo->byteStreamArray);
assert(pCreateInfo->numBytesArray); assert(pCreateInfo->numBytesArray);
assert(pAllocator == 0); //TODO _shaderModule* shader = ALLOCATE(sizeof(_shaderModule), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_shaderModule* shader = malloc(sizeof(_shaderModule));
if(!shader) if(!shader)
{ {
@ -52,8 +50,6 @@ void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const V
assert(device); assert(device);
assert(shaderModule); assert(shaderModule);
assert(pAllocator == 0);
_shaderModule* shader = shaderModule; _shaderModule* shader = shaderModule;
for(int c = 0; c < VK_RPI_ASSEMBLY_TYPE_MAX; ++c) for(int c = 0; c < VK_RPI_ASSEMBLY_TYPE_MAX; ++c)
@ -64,5 +60,5 @@ void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const V
} }
} }
free(shader); FREE(shader);
} }

18
driver/sync.c
View File

@ -24,11 +24,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
assert(device); assert(device);
assert(pSemaphore); assert(pSemaphore);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
//we'll probably just use an IOCTL to wait for a GPU sequence number to complete. //we'll probably just use an IOCTL to wait for a GPU sequence number to complete.
sem_t* s = malloc(sizeof(sem_t)); sem_t* s = ALLOCATE(sizeof(sem_t), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!s) if(!s)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -281,10 +278,9 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
assert(device); assert(device);
assert(semaphore); assert(semaphore);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
sem_destroy((sem_t*)semaphore); sem_destroy((sem_t*)semaphore);
FREE(semaphore);
} }
/* /*
@ -300,9 +296,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
assert(pCreateInfo); assert(pCreateInfo);
assert(pFence); assert(pFence);
assert(pAllocator == 0); _fence* f = ALLOCATE(sizeof(_fence), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
_fence* f = malloc(sizeof(_fence));
f->seqno = 0; f->seqno = 0;
f->signaled = pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT; f->signaled = pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT;
@ -321,9 +315,7 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
assert(device); assert(device);
assert(fence); assert(fence);
assert(pAllocator == 0); FREE(fence);
free(fence);
} }
/* /*

23
driver/wsi.c
View File

@ -15,8 +15,8 @@ VkResult vkCreateRpiSurfaceKHR(
assert(instance); assert(instance);
//assert(pCreateInfo); //ignored for now //assert(pCreateInfo); //ignored for now
assert(pSurface); assert(pSurface);
//TODO: allocator is ignored for now
assert(pAllocator == 0); //TODO use allocator!
*pSurface = (VkSurfaceKHR)modeset_create(instance->controlFd); *pSurface = (VkSurfaceKHR)modeset_create(instance->controlFd);
@ -37,8 +37,7 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
assert(instance); assert(instance);
assert(surface); assert(surface);
//TODO: allocator is ignored for now //TODO use allocator
assert(pAllocator == 0);
modeset_destroy(instance->controlFd, (modeset_dev*)surface); modeset_destroy(instance->controlFd, (modeset_dev*)surface);
} }
@ -183,10 +182,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
assert(pCreateInfo); assert(pCreateInfo);
assert(pSwapchain); assert(pSwapchain);
//TODO: allocator is ignored for now *pSwapchain = ALLOCATE(sizeof(_swapchain), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
assert(pAllocator == 0);
*pSwapchain = malloc(sizeof(_swapchain));
if(!*pSwapchain) if(!*pSwapchain)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -197,7 +193,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
//TODO flags, layers, queue sharing, pretransform, composite alpha, present mode..., clipped, oldswapchain //TODO flags, layers, queue sharing, pretransform, composite alpha, present mode..., clipped, oldswapchain
//TODO external sync on surface, oldswapchain //TODO external sync on surface, oldswapchain
s->images = malloc(sizeof(_image) * pCreateInfo->minImageCount); s->images = ALLOCATE(sizeof(_image) * pCreateInfo->minImageCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!s->images) if(!s->images)
{ {
return VK_ERROR_OUT_OF_HOST_MEMORY; return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -222,7 +218,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
s->images[c].numQueueFamiliesWithAccess = pCreateInfo->queueFamilyIndexCount; s->images[c].numQueueFamiliesWithAccess = pCreateInfo->queueFamilyIndexCount;
if(s->images[c].concurrentAccess) if(s->images[c].concurrentAccess)
{ {
s->images[c].queueFamiliesWithAccess = malloc(sizeof(uint32_t)*s->images[c].numQueueFamiliesWithAccess); s->images[c].queueFamiliesWithAccess = ALLOCATE(sizeof(uint32_t)*s->images[c].numQueueFamiliesWithAccess, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
memcpy(s->images[c].queueFamiliesWithAccess, pCreateInfo->pQueueFamilyIndices, sizeof(uint32_t)*s->images[c].numQueueFamiliesWithAccess); memcpy(s->images[c].queueFamiliesWithAccess, pCreateInfo->pQueueFamilyIndices, sizeof(uint32_t)*s->images[c].numQueueFamiliesWithAccess);
} }
s->images[c].preTransformMode = pCreateInfo->preTransform; s->images[c].preTransformMode = pCreateInfo->preTransform;
@ -395,9 +391,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
assert(device); assert(device);
assert(swapchain); assert(swapchain);
//TODO: allocator is ignored for now
assert(pAllocator == 0);
//TODO flush all ops //TODO flush all ops
_swapchain* s = swapchain; _swapchain* s = swapchain;
@ -408,7 +401,7 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
modeset_destroy_fb(device->dev->instance->controlFd, &s->images[c]); modeset_destroy_fb(device->dev->instance->controlFd, &s->images[c]);
} }
free(s->images); FREE(s->images);
free(s); FREE(s);
} }