kbz_8/Pulse
1
0
Fork 0
mirror of https://github.com/Kbz-8/Pulse.git synced 2026-03-03 20:06:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

working on Vulkahn compute pipelines

Browse Source
This commit is contained in:
kbz_8
2024-11-18 17:23:14 +01:00
parent d8b14d1a7e
commit d0eb9e0876
18 changed files with 278 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Sources/Backends/Vulkan/Vulkan.h
View File

@@ -20,11 +20,10 @@
if((res) != VK_SUCCESS) \
{ \
if(backend != PULSE_NULL_HANDLE && PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend)) \
PulseLogErrorFmt(backend, "(Vulkan) Call to Vulkan function failed due to %s", VulkanVerbaliseResult(res)); \
PulseLogErrorFmt(backend, "(Vulkan) call to Vulkan function failed due to %s", VulkanVerbaliseResult(res)); \
PulseSetInternalError(error); \
return retval; \
}
#define CHECK_VK(backend, res, error) CHECK_VK_RETVAL(backend, res, error, )
typedef struct VulkanGlobal

10
Sources/Backends/Vulkan/VulkanCommandList.c
View File

@@ -78,9 +78,8 @@ PulseCommandList VulkanRequestCommandList(PulseDevice device, PulseCommandListUs
}
cmd->compute_pipelines_bound_size = 0;
cmd->state = PULSE_COMMAND_LIST_STATE_EMPTY;
cmd->state = PULSE_COMMAND_LIST_STATE_RECORDING;
cmd->is_available = false;
cmd->is_compute_pipeline_bound = false;
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
@@ -103,7 +102,6 @@ PulseCommandList VulkanRequestCommandList(PulseDevice device, PulseCommandListUs
bool VulkanSubmitCommandList(PulseDevice device, PulseCommandList cmd, PulseFence fence)
{
PULSE_UNUSED(device);
PULSE_CHECK_HANDLE_RETVAL(cmd, false);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
@@ -121,8 +119,9 @@ bool VulkanSubmitCommandList(PulseDevice device, PulseCommandList cmd, PulseFenc
VkFence vulkan_fence;
if(fence != PULSE_NULL_HANDLE)
{
vulkan_fence = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VkFence);
vulkan_device->vkResetFences(vulkan_device->device, 1, &vulkan_fence);
vulkan_fence = VULKAN_RETRIEVE_DRIVER_DATA_AS(fence, VkFence);
CHECK_VK_RETVAL(device->backend, vulkan_device->vkResetFences(vulkan_device->device, 1, &vulkan_fence), PULSE_ERROR_DEVICE_ALLOCATION_FAILED, false);
fence->cmd = cmd;
}
VulkanQueue* vulkan_queue;
@@ -140,6 +139,7 @@ bool VulkanSubmitCommandList(PulseDevice device, PulseCommandList cmd, PulseFenc
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &vulkan_cmd->cmd;
res = vulkan_device->vkQueueSubmit(vulkan_queue->queue, 1, &submit_info, vulkan_fence);
cmd->state = PULSE_COMMAND_LIST_STATE_SENT;
switch(res)
{
case VK_SUCCESS: return true;

78
Sources/Backends/Vulkan/VulkanComputePipeline.c
View File

@@ -2,16 +2,92 @@
// This file is part of "Pulse"
// For conditions of distribution and use, see copyright notice in LICENSE
#include "Vulkan.h"
#include "VulkanDevice.h"
#include "VulkanCommandList.h"
#include "VulkanComputePipeline.h"
PulseComputePipeline VulkanCreateComputePipeline(PulseDevice device, const PulseComputePipelineCreateInfo* info)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
PulseComputePipelineHandler* pipeline = (PulseComputePipelineHandler*)calloc(1, sizeof(PulseComputePipelineHandler));
PULSE_CHECK_ALLOCATION_RETVAL(pipeline, PULSE_NULL_HANDLE);
VulkanComputePipeline* vulkan_pipeline = (VulkanComputePipeline*)calloc(1, sizeof(VulkanComputePipeline));
PULSE_CHECK_ALLOCATION_RETVAL(vulkan_pipeline, PULSE_NULL_HANDLE);
pipeline->driver_data = vulkan_pipeline;
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
{
if(info->code == PULSE_NULLPTR)
PulseLogError(device->backend, "invalid code pointer passed to PulseComputePipelineCreateInfo");
if(info->entrypoint == PULSE_NULLPTR)
PulseLogError(device->backend, "invalid entrypoint pointer passed to PulseComputePipelineCreateInfo");
if(info->format == PULSE_SHADER_FORMAT_SPIRV_BIT && (device->backend->supported_shader_formats & PULSE_SHADER_FORMAT_SPIRV_BIT) == 0)
PulseLogError(device->backend, "invalid shader format passed to PulseComputePipelineCreateInfo");
}
VkShaderModuleCreateInfo shader_module_create_info = {};
shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shader_module_create_info.codeSize = info->code_size;
shader_module_create_info.pCode = (const uint32_t*)info->code;
CHECK_VK_RETVAL(device->backend, vulkan_device->vkCreateShaderModule(vulkan_device->device, &shader_module_create_info, PULSE_NULLPTR, &vulkan_pipeline->module), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULL_HANDLE);
VkPipelineShaderStageCreateInfo shader_stage_info = {};
shader_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shader_stage_info.stage = VK_SHADER_STAGE_COMPUTE_BIT;
shader_stage_info.module = vulkan_pipeline->module;
shader_stage_info.pName = info->entrypoint;
VkPipelineLayoutCreateInfo pipeline_layout_info = {};
pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipeline_layout_info.setLayoutCount = 0;
pipeline_layout_info.pSetLayouts = PULSE_NULLPTR; // will change
CHECK_VK_RETVAL(device->backend, vulkan_device->vkCreatePipelineLayout(vulkan_device->device, &pipeline_layout_info, PULSE_NULLPTR, &vulkan_pipeline->layout), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULL_HANDLE);
VkComputePipelineCreateInfo pipeline_info = {};
pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
pipeline_info.layout = vulkan_pipeline->layout;
pipeline_info.stage = shader_stage_info;
CHECK_VK_RETVAL(device->backend, vulkan_device->vkCreateComputePipelines(vulkan_device->device, VK_NULL_HANDLE, 1, &pipeline_info, PULSE_NULLPTR, &vulkan_pipeline->pipeline), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULL_HANDLE);
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(device->backend))
PulseLogInfoFmt(device->backend, "(Vulkan) created new compute pipeline %p", pipeline);
return pipeline;
}
void VulkanBindComputePipeline(PulseComputePass pass, PulseComputePipeline pipeline)
void VulkanDispatchComputePipeline(PulseComputePipeline pipeline, PulseCommandList cmd, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z)
{
VulkanComputePipeline* vulkan_pipeline = VULKAN_RETRIEVE_DRIVER_DATA_AS(pipeline, VulkanComputePipeline*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
vulkan_device->vkCmdBindPipeline(vulkan_cmd->cmd, VK_PIPELINE_BIND_POINT_COMPUTE, vulkan_pipeline->pipeline);
vulkan_device->vkCmdDispatch(vulkan_cmd->cmd, groupcount_x, groupcount_y, groupcount_z);
}
void VulkanDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipeline)
{
if(pipeline == PULSE_NULL_HANDLE)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogWarning(device->backend, "compute pipeline is NULL, this may be a bug in your application");
return;
}
VulkanComputePipeline* vulkan_pipeline = VULKAN_RETRIEVE_DRIVER_DATA_AS(pipeline, VulkanComputePipeline*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
vulkan_device->vkDeviceWaitIdle(vulkan_device->device);
vulkan_device->vkDestroyShaderModule(vulkan_device->device, vulkan_pipeline->module, PULSE_NULLPTR);
vulkan_device->vkDestroyPipelineLayout(vulkan_device->device, vulkan_pipeline->layout, PULSE_NULLPTR);
vulkan_device->vkDestroyPipeline(vulkan_device->device, vulkan_pipeline->pipeline, PULSE_NULLPTR);
free(vulkan_pipeline);
free(pipeline);
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(device->backend))
PulseLogInfoFmt(device->backend, "(Vulkan) destroyed compute pipeline %p", pipeline);
}

5
Sources/Backends/Vulkan/VulkanComputePipeline.h
View File

@@ -13,10 +13,13 @@
typedef struct VulkanComputePipeline
{
VkShaderModule module;
VkPipelineLayout layout;
VkPipeline pipeline;
} VulkanComputePipeline;
PulseComputePipeline VulkanCreateComputePipeline(PulseDevice device, const PulseComputePipelineCreateInfo* info);
void VulkanBindComputePipeline(PulseComputePipeline pipeline);
void VulkanDispatchComputePipeline(PulseComputePipeline pipeline, PulseCommandList cmd, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z);
void VulkanDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipeline);
#endif // PULSE_VULKAN_COMPUTE_PIPELINE_H_

4
Sources/Backends/Vulkan/VulkanDevice.c
View File

@@ -227,7 +227,7 @@ PulseDevice VulkanCreateDevice(PulseBackend backend, PulseDevice* forbiden_devic
PULSE_LOAD_DRIVER_DEVICE(Vulkan);
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(backend))
PulseLogInfoFmt(backend, "(Vulkan) Created device from %s", device->properties.deviceName);
PulseLogInfoFmt(backend, "(Vulkan) created device from %s", device->properties.deviceName);
return pulse_device;
}
@@ -241,7 +241,7 @@ void VulkanDestroyDevice(PulseDevice device)
vmaDestroyAllocator(vulkan_device->allocator);
vulkan_device->vkDestroyDevice(vulkan_device->device, PULSE_NULLPTR);
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(device->backend))
PulseLogInfoFmt(device->backend, "(Vulkan) Destroyed device created from %s", vulkan_device->properties.deviceName);
PulseLogInfoFmt(device->backend, "(Vulkan) destroyed device created from %s", vulkan_device->properties.deviceName);
free(vulkan_device->cmd_pools);
free(vulkan_device);
free(device);

15
Sources/Backends/Vulkan/VulkanFence.c
View File

@@ -21,6 +21,7 @@ PulseFence VulkanCreateFence(PulseDevice device)
PulseFenceHandler* fence = (PulseFenceHandler*)malloc(sizeof(PulseFenceHandler));
PULSE_CHECK_ALLOCATION_RETVAL(fence, PULSE_NULL_HANDLE);
fence->cmd = PULSE_NULL_HANDLE;
fence->driver_data = vulkan_fence;
return fence;
}
@@ -60,7 +61,10 @@ bool VulkanIsFenceReady(PulseDevice device, PulseFence fence)
VkResult res = vulkan_device->vkGetFenceStatus(vulkan_device->device, vulkan_fence);
switch(res)
{
case VK_SUCCESS: return true;
case VK_SUCCESS:
if(fence->cmd != PULSE_NULL_HANDLE)
fence->cmd->state = PULSE_COMMAND_LIST_STATE_READY;
return true;
case VK_NOT_READY: return false;
case VK_ERROR_DEVICE_LOST: PulseSetInternalError(PULSE_ERROR_DEVICE_LOST); return false;
@@ -80,12 +84,19 @@ bool VulkanWaitForFences(PulseDevice device, const PulseFence* fences, uint32_t
VkFence* vulkan_fences = (VkFence*)calloc(fences_count, sizeof(VkFence));
PULSE_CHECK_ALLOCATION_RETVAL(vulkan_fences, false);
for(uint32_t i = 0; i < fences_count; i++)
{
if(fences[i]->cmd == PULSE_NULL_HANDLE && PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogError(device->backend, "cannot wait on a fence that has no command list attached to it");
vulkan_fences[i] = VULKAN_RETRIEVE_DRIVER_DATA_AS(((PulseFence)fences[i]), VkFence);
}
VkResult result = vulkan_device->vkWaitForFences(vulkan_device->device, fences_count, vulkan_fences, wait_for_all, UINT64_MAX);
free(vulkan_fences);
switch(result)
{
case VK_SUCCESS: break;
case VK_SUCCESS:
for(uint32_t i = 0; i < fences_count; i++)
fences[i]->cmd->state = PULSE_COMMAND_LIST_STATE_READY;
break;
case VK_TIMEOUT: break;
case VK_ERROR_DEVICE_LOST: PulseSetInternalError(PULSE_ERROR_DEVICE_LOST); return false;

15
Sources/PulseCommandList.c
View File

@@ -16,7 +16,7 @@ PULSE_API bool PulseSubmitCommandList(PulseDevice device, PulseCommandList cmd,
PULSE_CHECK_HANDLE_RETVAL(device, false);
PULSE_CHECK_HANDLE_RETVAL(cmd, false);
if(cmd->state != PULSE_COMMAND_LIST_STATE_READY)
if(cmd->state != PULSE_COMMAND_LIST_STATE_RECORDING)
{
switch(cmd->state)
{
@@ -25,14 +25,9 @@ PULSE_API bool PulseSubmitCommandList(PulseDevice device, PulseCommandList cmd,
PulseLogError(device->backend, "command list is in invalid state");
return false;
case PULSE_COMMAND_LIST_STATE_EMPTY:
case PULSE_COMMAND_LIST_STATE_READY:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogWarning(device->backend, "command list is empty");
return false;
case PULSE_COMMAND_LIST_STATE_RECORDING:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogError(device->backend, "command list is in recording state");
PulseLogError(device->backend, "command list is empty");
return false;
case PULSE_COMMAND_LIST_STATE_SENT:
@@ -60,9 +55,9 @@ PULSE_API void PulseReleaseCommandList(PulseDevice device, PulseCommandList cmd)
switch(cmd->state)
{
case PULSE_COMMAND_LIST_STATE_RECORDING:
case PULSE_COMMAND_LIST_STATE_SENT:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogWarning(device->backend, "command list is in recording state");
PulseLogWarning(device->backend, "command list is in pending state");
break;
default: break;

45
Sources/PulseComputePipeline.c
View File

@@ -2,20 +2,61 @@
// This file is part of "Pulse"
// For conditions of distribution and use, see copyright notice in LICENSE
#include <Pulse.h>
#include "PulseDefs.h"
#include "PulseInternal.h"
PULSE_API PulseComputePipeline PulseCreateComputePipeline(PulseDevice device, const PulseComputePipelineCreateInfo* info)
{
PULSE_CHECK_HANDLE_RETVAL(device, PULSE_NULL_HANDLE);
if(info == PULSE_NULLPTR && PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
PulseLogError(device->backend, "null infos pointer");
PULSE_CHECK_PTR_RETVAL(info, PULSE_NULL_HANDLE);
return device->PFN_CreateComputePipeline(device, info);
}
PULSE_API void PulseBindComputePipeline(PulseComputePipeline pipeline)
PULSE_API void PulseDispatchComputePipeline(PulseComputePipeline pipeline, PulseCommandList cmd, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z)
{
PULSE_CHECK_HANDLE(pipeline);
PULSE_CHECK_HANDLE(cmd);
if(cmd->state != PULSE_COMMAND_LIST_STATE_RECORDING)
{
switch(cmd->state)
{
case PULSE_COMMAND_LIST_STATE_INVALID:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(cmd->device->backend))
PulseLogError(cmd->device->backend, "command list is in invalid state");
return;
case PULSE_COMMAND_LIST_STATE_READY:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(cmd->device->backend))
PulseLogError(cmd->device->backend, "command list is not recording");
return;
case PULSE_COMMAND_LIST_STATE_SENT:
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(cmd->device->backend))
PulseLogWarning(cmd->device->backend, "command list has already been submitted");
return;
default: break;
}
}
cmd->device->PFN_DispatchComputePipeline(pipeline, cmd, groupcount_x, groupcount_y, groupcount_z);
pipeline->cmd = cmd;
if(cmd->compute_pipelines_bound_size == cmd->compute_pipelines_bound_capacity)
{
cmd->compute_pipelines_bound_capacity += 5;
cmd->compute_pipelines_bound = (PulseComputePipeline*)realloc(cmd->compute_pipelines_bound, cmd->compute_pipelines_bound_capacity * sizeof(PulseComputePipeline));
PULSE_CHECK_ALLOCATION(cmd->compute_pipelines_bound);
}
cmd->compute_pipelines_bound[cmd->compute_pipelines_bound_size] = pipeline;
cmd->compute_pipelines_bound_size++;
}
PULSE_API void PulseDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipeline)
{
PULSE_CHECK_HANDLE(device);
device->PFN_DestroyComputePipeline(device, pipeline);
}

2
Sources/PulseDefs.h
View File

@@ -54,7 +54,7 @@
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(DestroyDevice, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(CreateComputePipeline, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(DestroyComputePipeline, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(BindComputePipeline, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(DispatchComputePipeline, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(CreateFence, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(DestroyFence, _namespace) \
PULSE_LOAD_DRIVER_DEVICE_FUNCTION(IsFenceReady, _namespace) \

1
Sources/PulseEnums.h
View File

@@ -8,7 +8,6 @@
typedef enum PulseCommandListState
{
PULSE_COMMAND_LIST_STATE_INVALID,
PULSE_COMMAND_LIST_STATE_EMPTY,
PULSE_COMMAND_LIST_STATE_RECORDING,
PULSE_COMMAND_LIST_STATE_READY,
PULSE_COMMAND_LIST_STATE_SENT

5
Sources/PulseInternal.h
View File

@@ -43,12 +43,12 @@ typedef struct PulseCommandListHandler
uint32_t compute_pipelines_bound_size;
PulseCommandListState state;
PulseCommandListUsage usage;
bool is_compute_pipeline_bound;
bool is_available;
} PulseCommandListHandler;
typedef struct PulseComputePipelineHandler
{
PulseCommandList cmd;
void* driver_data;
} PulseComputePipelineHandler;
@@ -57,7 +57,7 @@ typedef struct PulseDeviceHandler
// PFNs
PulseDestroyDevicePFN PFN_DestroyDevice;
PulseCreateComputePipelinePFN PFN_CreateComputePipeline;
PulseBindComputePipelinePFN PFN_BindComputePipeline;
PulseDispatchComputePipelinePFN PFN_DispatchComputePipeline;
PulseDestroyComputePipelinePFN PFN_DestroyComputePipeline;
PulseCreateFencePFN PFN_CreateFence;
PulseDestroyFencePFN PFN_DestroyFence;
@@ -74,6 +74,7 @@ typedef struct PulseDeviceHandler
typedef struct PulseFenceHandler
{
PulseCommandList cmd;
void* driver_data;
} PulseFenceHandler;

2
Sources/PulsePFNs.h
View File

@@ -15,7 +15,7 @@ typedef PulseDevice (*PulseCreateDevicePFN)(PulseBackend, PulseDevice*, uint32_t
typedef void (*PulseDestroyDevicePFN)(PulseDevice);
typedef PulseComputePipeline (*PulseCreateComputePipelinePFN)(PulseDevice, const PulseComputePipelineCreateInfo*);
typedef void (*PulseBindComputePipelinePFN)(PulseComputePipeline);
typedef void (*PulseDispatchComputePipelinePFN)(PulseComputePipeline, PulseCommandList, uint32_t, uint32_t, uint32_t);
typedef void (*PulseDestroyComputePipelinePFN)(PulseDevice, PulseComputePipeline);
typedef PulseFence (*PulseCreateFencePFN)(PulseDevice);
typedef void (*PulseDestroyFencePFN)(PulseDevice, PulseFence);