mirror of
https://github.com/Kbz-8/Pulse.git
synced 2026-01-11 23:43:34 +00:00
adding Vulkan device creation, adding unit tests, adding few API function declarations
This commit is contained in:
@@ -2,26 +2,32 @@
|
||||
// This file is part of "Pulse"
|
||||
// For conditions of distribution and use, see copyright notice in LICENSE
|
||||
|
||||
#include "VulkanInstance.h"
|
||||
#include "Pulse.h"
|
||||
#include "Vulkan.h"
|
||||
#include "VulkanComputePipeline.h"
|
||||
#include "VulkanDevice.h"
|
||||
#include "VulkanInstance.h"
|
||||
#include "VulkanLoader.h"
|
||||
#include "VulkanQueue.h"
|
||||
#include "../../PulseInternal.h"
|
||||
/*
|
||||
static int32_t VulkanScorePhysicalDevice(VkPhysicalDevice device, const char** device_extensions, uint32_t device_extensions_count)
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static int32_t VulkanScorePhysicalDevice(VulkanInstance* instance, VkPhysicalDevice device, const char** device_extensions, uint32_t device_extensions_count)
|
||||
{
|
||||
PULSE_DECLARE_STACK_FIXED_ALLOCATOR(allocator, sizeof(VkExtensionProperties) * 4096, sizeof(VkExtensionProperties));
|
||||
// Check extensions support
|
||||
uint32_t extension_count;
|
||||
kbhGetVulkanPFNs()->vkEnumerateDeviceExtensionProperties(device, PULSE_NULLPTR, &extension_count, PULSE_NULLPTR);
|
||||
VkExtensionProperties* props = (VkExtensionProperties*)kbhCallocInFixed(&allocator, extension_count, sizeof(VkExtensionProperties));
|
||||
instance->vkEnumerateDeviceExtensionProperties(device, PULSE_NULLPTR, &extension_count, PULSE_NULLPTR);
|
||||
VkExtensionProperties* props = (VkExtensionProperties*)calloc(extension_count, sizeof(VkExtensionProperties));
|
||||
if(!props)
|
||||
return -1;
|
||||
kbhGetVulkanPFNs()->vkEnumerateDeviceExtensionProperties(device, PULSE_NULLPTR, &extension_count, props);
|
||||
instance->vkEnumerateDeviceExtensionProperties(device, PULSE_NULLPTR, &extension_count, props);
|
||||
|
||||
bool are_there_required_device_extensions = true;
|
||||
for(int j = 0; j < device_extensions_count; j++)
|
||||
for(uint32_t j = 0; j < device_extensions_count; j++)
|
||||
{
|
||||
bool is_there_extension = false;
|
||||
for(int k = 0; k < extension_count; k++)
|
||||
for(uint32_t k = 0; k < extension_count; k++)
|
||||
{
|
||||
if(strcmp(device_extensions[j], props[k].extensionName) == 0)
|
||||
{
|
||||
@@ -40,18 +46,18 @@ static int32_t VulkanScorePhysicalDevice(VkPhysicalDevice device, const char** d
|
||||
|
||||
// Check Queue Families Support
|
||||
int32_t queue;
|
||||
if(kbhFindPhysicalDeviceQueueFamily(device, KBH_VULKAN_QUEUE_COMPUTE, &queue) != KBH_RHI_SUCCESS)
|
||||
if(!VulkanFindPhysicalDeviceQueueFamily(instance, device, VULKAN_QUEUE_COMPUTE, &queue))
|
||||
return -1;
|
||||
|
||||
VkPhysicalDeviceProperties device_props;
|
||||
kbhGetVulkanPFNs()->vkGetPhysicalDeviceProperties(device, &device_props);
|
||||
instance->vkGetPhysicalDeviceProperties(device, &device_props);
|
||||
|
||||
VkPhysicalDeviceFeatures device_features;
|
||||
kbhGetVulkanPFNs()->vkGetPhysicalDeviceFeatures(device, &device_features);
|
||||
instance->vkGetPhysicalDeviceFeatures(device, &device_features);
|
||||
|
||||
int32_t score = -1;
|
||||
if(device_props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
|
||||
score += 1001;
|
||||
score += 10000;
|
||||
|
||||
score += device_props.limits.maxComputeWorkGroupCount[0];
|
||||
score += device_props.limits.maxComputeWorkGroupCount[1];
|
||||
@@ -61,7 +67,20 @@ static int32_t VulkanScorePhysicalDevice(VkPhysicalDevice device, const char** d
|
||||
return score;
|
||||
}
|
||||
|
||||
static VkPhysicalDevice VulkanPickPhysicalDevice(VulkanInstance* instance)
|
||||
static bool VulkanIsDeviceForbidden(VkPhysicalDevice device, PulseDevice* forbiden_devices, uint32_t forbiden_devices_count)
|
||||
{
|
||||
if(device == VK_NULL_HANDLE)
|
||||
return true;
|
||||
#pragma omp parallel for
|
||||
for(uint32_t i = 0; i < forbiden_devices_count; i++)
|
||||
{
|
||||
if(device == ((VulkanDevice*)forbiden_devices[i]->driver_data)->physical)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static VkPhysicalDevice VulkanPickPhysicalDevice(VulkanInstance* instance, PulseDevice* forbiden_devices, uint32_t forbiden_devices_count)
|
||||
{
|
||||
VkPhysicalDevice* devices = PULSE_NULLPTR;
|
||||
VkPhysicalDevice chosen_one = VK_NULL_HANDLE;
|
||||
@@ -73,9 +92,12 @@ static VkPhysicalDevice VulkanPickPhysicalDevice(VulkanInstance* instance)
|
||||
PULSE_CHECK_ALLOCATION_RETVAL(devices, VK_NULL_HANDLE);
|
||||
instance->vkEnumeratePhysicalDevices(instance->instance, &device_count, devices);
|
||||
|
||||
for(int i = 0; i < device_count; i++)
|
||||
#pragma omp parallel for
|
||||
for(uint32_t i = 0; i < device_count; i++)
|
||||
{
|
||||
int32_t current_device_score = VulkanScorePhysicalDevice(devices[i], PULSE_NULLPTR, 0);
|
||||
if(VulkanIsDeviceForbidden(devices[i], forbiden_devices, forbiden_devices_count))
|
||||
continue;
|
||||
int32_t current_device_score = VulkanScorePhysicalDevice(instance, devices[i], PULSE_NULLPTR, 0);
|
||||
if(current_device_score > best_device_score)
|
||||
{
|
||||
best_device_score = current_device_score;
|
||||
@@ -84,17 +106,132 @@ static VkPhysicalDevice VulkanPickPhysicalDevice(VulkanInstance* instance)
|
||||
}
|
||||
return chosen_one;
|
||||
}
|
||||
*/
|
||||
|
||||
void* VulkanCreateDevice(PulseBackend backend, PulseDevice* forbiden_devices, uint32_t forbiden_devices_count)
|
||||
PulseDevice VulkanCreateDevice(PulseBackend backend, PulseDevice* forbiden_devices, uint32_t forbiden_devices_count)
|
||||
{
|
||||
PULSE_CHECK_HANDLE_RETVAL(backend, PULSE_NULLPTR);
|
||||
|
||||
PulseDevice pulse_device = (PulseDeviceHandler*)calloc(1, sizeof(PulseDeviceHandler));
|
||||
PULSE_CHECK_ALLOCATION_RETVAL(pulse_device, PULSE_NULL_HANDLE);
|
||||
|
||||
VulkanDevice* device = (VulkanDevice*)calloc(1, sizeof(VulkanDevice));
|
||||
PULSE_CHECK_ALLOCATION_RETVAL(device, PULSE_NULLPTR);
|
||||
|
||||
VulkanInstance* instance = &VULKAN_RETRIEVE_DRIVER_DATA(backend)->instance;
|
||||
|
||||
device->physical = VulkanPickPhysicalDevice(instance, forbiden_devices, forbiden_devices_count);
|
||||
PULSE_CHECK_HANDLE_RETVAL(device->physical, PULSE_NULLPTR);
|
||||
|
||||
const float queue_priority = 1.0f;
|
||||
|
||||
VkDeviceQueueCreateInfo* queue_create_infos = (VkDeviceQueueCreateInfo*)PulseStaticAllocStack(VULKAN_QUEUE_END_ENUM * sizeof(VkDeviceQueueCreateInfo));
|
||||
// No need to check allocation, it is allocated on the stack
|
||||
|
||||
uint32_t unique_queues_count = 1;
|
||||
|
||||
for(int32_t i = 0; i < VULKAN_QUEUE_END_ENUM; i++) // Needs to be done before next loop
|
||||
{
|
||||
if(!VulkanPrepareDeviceQueue(instance, device, i))
|
||||
{
|
||||
PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
|
||||
return PULSE_NULLPTR;
|
||||
}
|
||||
}
|
||||
|
||||
for(int32_t i = 0; i < VULKAN_QUEUE_END_ENUM; i++)
|
||||
{
|
||||
if(device->queues[i]->queue_family_index == -1)
|
||||
continue;
|
||||
int j;
|
||||
for(j = i; j < VULKAN_QUEUE_END_ENUM; j++) // Ugly shit but array will never be big so it's okay
|
||||
{
|
||||
if(device->queues[i]->queue_family_index == device->queues[j]->queue_family_index)
|
||||
break;
|
||||
}
|
||||
if(j == VULKAN_QUEUE_END_ENUM)
|
||||
unique_queues_count++;
|
||||
queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
||||
queue_create_infos[i].queueFamilyIndex = device->queues[i]->queue_family_index;
|
||||
queue_create_infos[i].queueCount = 1;
|
||||
queue_create_infos[i].pQueuePriorities = &queue_priority;
|
||||
queue_create_infos[i].flags = 0;
|
||||
queue_create_infos[i].pNext = PULSE_NULLPTR;
|
||||
}
|
||||
|
||||
instance->vkGetPhysicalDeviceProperties(device->physical, &device->properties);
|
||||
instance->vkGetPhysicalDeviceMemoryProperties(device->physical, &device->memory_properties);
|
||||
instance->vkGetPhysicalDeviceFeatures(device->physical, &device->features);
|
||||
|
||||
VkDeviceCreateInfo create_info = {};
|
||||
create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
||||
create_info.queueCreateInfoCount = unique_queues_count;
|
||||
create_info.pQueueCreateInfos = queue_create_infos;
|
||||
create_info.pEnabledFeatures = &device->features;
|
||||
create_info.enabledExtensionCount = 0;
|
||||
create_info.ppEnabledExtensionNames = PULSE_NULLPTR;
|
||||
create_info.enabledLayerCount = 0;
|
||||
create_info.ppEnabledLayerNames = PULSE_NULLPTR;
|
||||
create_info.flags = 0;
|
||||
create_info.pNext = PULSE_NULLPTR;
|
||||
|
||||
CHECK_VK_RETVAL(instance->vkCreateDevice(device->physical, &create_info, PULSE_NULLPTR, &device->device), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULLPTR);
|
||||
if(!VulkanLoadDevice(instance, device))
|
||||
{
|
||||
PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
|
||||
return PULSE_NULLPTR;
|
||||
}
|
||||
|
||||
for(int32_t i = 0; i < VULKAN_QUEUE_END_ENUM; i++)
|
||||
{
|
||||
if(!VulkanRetrieveDeviceQueue(device, (VulkanQueueType)i))
|
||||
{
|
||||
PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
|
||||
return PULSE_NULLPTR;
|
||||
}
|
||||
}
|
||||
|
||||
VmaVulkanFunctions vma_vulkan_func = {};
|
||||
vma_vulkan_func.vkAllocateMemory = device->vkAllocateMemory;
|
||||
vma_vulkan_func.vkBindBufferMemory = device->vkBindBufferMemory;
|
||||
vma_vulkan_func.vkBindImageMemory = device->vkBindImageMemory;
|
||||
vma_vulkan_func.vkCreateBuffer = device->vkCreateBuffer;
|
||||
vma_vulkan_func.vkCreateImage = device->vkCreateImage;
|
||||
vma_vulkan_func.vkDestroyBuffer = device->vkDestroyBuffer;
|
||||
vma_vulkan_func.vkDestroyImage = device->vkDestroyImage;
|
||||
vma_vulkan_func.vkFlushMappedMemoryRanges = device->vkFlushMappedMemoryRanges;
|
||||
vma_vulkan_func.vkFreeMemory = device->vkFreeMemory;
|
||||
vma_vulkan_func.vkGetBufferMemoryRequirements = device->vkGetBufferMemoryRequirements;
|
||||
vma_vulkan_func.vkGetImageMemoryRequirements = device->vkGetImageMemoryRequirements;
|
||||
vma_vulkan_func.vkInvalidateMappedMemoryRanges = device->vkInvalidateMappedMemoryRanges;
|
||||
vma_vulkan_func.vkMapMemory = device->vkMapMemory;
|
||||
vma_vulkan_func.vkUnmapMemory = device->vkUnmapMemory;
|
||||
vma_vulkan_func.vkCmdCopyBuffer = device->vkCmdCopyBuffer;
|
||||
vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties = instance->vkGetPhysicalDeviceMemoryProperties;
|
||||
vma_vulkan_func.vkGetPhysicalDeviceProperties = instance->vkGetPhysicalDeviceProperties;
|
||||
|
||||
VmaAllocatorCreateInfo allocator_create_info = {};
|
||||
allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_0;
|
||||
allocator_create_info.physicalDevice = device->physical;
|
||||
allocator_create_info.device = device->device;
|
||||
allocator_create_info.instance = instance->instance;
|
||||
allocator_create_info.pVulkanFunctions = &vma_vulkan_func;
|
||||
|
||||
CHECK_VK_RETVAL(vmaCreateAllocator(&allocator_create_info, &device->allocator), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULLPTR);
|
||||
|
||||
pulse_device->driver_data = device;
|
||||
pulse_device->backend = backend;
|
||||
PULSE_LOAD_DRIVER_DEVICE(Vulkan);
|
||||
return pulse_device;
|
||||
}
|
||||
|
||||
void VulkanDestroyDevice(VulkanDevice* device)
|
||||
void VulkanDestroyDevice(PulseDevice device)
|
||||
{
|
||||
if(device == PULSE_NULLPTR || device->device == VK_NULL_HANDLE)
|
||||
VulkanDevice* vulkan_device = (VulkanDevice*)device->driver_data;
|
||||
if(vulkan_device == PULSE_NULLPTR || vulkan_device->device == VK_NULL_HANDLE)
|
||||
return;
|
||||
vmaDestroyAllocator(device->allocator);
|
||||
device->vkDestroyDevice(device->device, PULSE_NULLPTR);
|
||||
device->device = VK_NULL_HANDLE;
|
||||
vmaDestroyAllocator(vulkan_device->allocator);
|
||||
vulkan_device->vkDestroyDevice(vulkan_device->device, PULSE_NULLPTR);
|
||||
vulkan_device->device = VK_NULL_HANDLE;
|
||||
free(vulkan_device);
|
||||
free(device);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user