device.c

#include <kiba/renderer/vulkan/device.h>
 
#include <kiba/containers/array.h>
#include <kiba/core/string.h>
 
b8 vulkan_select_physical_device(vulkan_context *context);
b8 vulkan_select_logical_device(vulkan_context *context);
 
b8 vulkan_physical_device_meets_requirements(VkPhysicalDevice            device,
                                             VkPhysicalDeviceFeatures   *features,
                                             VkPhysicalDeviceProperties *props,
                                             vulkan_context             *context);
 
b8   vulkan_queue_create(VkDevice logical_device, vulkan_queue *queue, const VkAllocationCallbacks *alloc);
void vulkan_queue_destroy(VkDevice logical_device, vulkan_queue *queue, const VkAllocationCallbacks *alloc);
 
b8 vulkan_device_create(vulkan_context *context) {
    if (!vulkan_select_physical_device(context)) {
        KB_ERROR("failed to find GPU meeting the requirements");
        return false;
    }
    if (!vulkan_select_logical_device(context)) {
        KB_ERROR("failed to create logical device");
        return false;
    }
 
    return true;
}
 
void vulkan_device_destroy(vulkan_context *context) {
    vulkan_queue_destroy(context->device.logical, &context->device.graphics_queue, &context->alloc.vulkan_callbacks);
    vulkan_queue_destroy(context->device.logical, &context->device.transfer_queue, &context->alloc.vulkan_callbacks);
    vulkan_queue_destroy(context->device.logical, &context->device.present_queue, &context->alloc.vulkan_callbacks);
    vulkan_queue_destroy(context->device.logical, &context->device.compute_queue, &context->alloc.vulkan_callbacks);
    vkDestroyDevice(context->device.logical, &context->alloc.vulkan_callbacks);
}
 
b8 vulkan_select_physical_device(vulkan_context *context) {
    u32   physical_device_count = 0;
    VK_CALL_B8(vkEnumeratePhysicalDevices(context->instance.instance, &physical_device_count, 0));
    if (physical_device_count == 0) {
        KB_INFO("found no device that supports vulkan");
        return false;
    }
 
    array_of(VkPhysicalDevice) physical_devices =
        array_create(VkPhysicalDevice, physical_device_count, &context->alloc.kiba_alloc);
    if (physical_devices == KB_NULL) {
        KB_ERROR("unable to allocate enough memory for list of physical devices");
        return false;
    }
    VK_CALL_B8(vkEnumeratePhysicalDevices(context->instance.instance, &physical_device_count, physical_devices));
    array_resize(&physical_devices, physical_device_count);
 
    b8 ret = false;
    array_for_each(const VkPhysicalDevice, device, physical_devices) {
        VkPhysicalDeviceProperties physical_device_properties;
        VkPhysicalDeviceFeatures   physical_device_features;
        vkGetPhysicalDeviceProperties(*device, &physical_device_properties);
        vkGetPhysicalDeviceFeatures(*device, &physical_device_features);
        KB_INFO("checking device {raw_string} against requirements", physical_device_properties.deviceName);
        if (vulkan_physical_device_meets_requirements(*device,
                                                      &physical_device_features,
                                                      &physical_device_properties,
                                                      context)) {
            KB_INFO("device {raw_string} meets requirements", physical_device_properties.deviceName);
            context->device.physical = *device;
            ret                      = true;
            break;
        }
        KB_INFO("skipping physical device {raw_string} because it does not match the requirements",
                physical_device_properties.deviceName);
    }
    array_destroy(&physical_devices);
    return ret;
}
 
b8 vulkan_select_logical_device(vulkan_context *context) {
    const usize max_different_queue = 8;
 
    u32 indices[max_different_queue];
    u32 index        = 0;
    indices[index++] = context->device.graphics_queue.index;
    if (context->device.graphics_queue.index != context->device.present_queue.index) {
        indices[index++] = context->device.present_queue.index;
    }
    if (context->device.graphics_queue.index != context->device.transfer_queue.index) {
        indices[index++] = context->device.transfer_queue.index;
    }
 
    f32                     high_prio = 1.0f;
    VkDeviceQueueCreateInfo queue_create_infos[max_different_queue];
    for (u32 i = 0; i < index; ++i) {
        queue_create_infos[i].sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
        queue_create_infos[i].queueFamilyIndex = indices[i];
        // TODO: should be configurable how many
        queue_create_infos[i].queueCount       = 1;
        queue_create_infos[i].flags            = 0;
        queue_create_infos[i].pNext            = 0;
        queue_create_infos[i].pQueuePriorities = &high_prio;
    }
 
    VkDeviceCreateInfo device_create_info = {
        .sType                   = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pQueueCreateInfos       = queue_create_infos,
        .queueCreateInfoCount    = index,
        .pEnabledFeatures        = &context->device.requirements.features,
        .ppEnabledExtensionNames = context->device.requirements.extensions,
        .enabledExtensionCount   = (u32) array_size(context->device.requirements.extensions),
    };
    VK_CALL_B8(vkCreateDevice(context->device.physical,
                              &device_create_info,
                              &context->alloc.vulkan_callbacks,
                              &context->device.logical));
 
    if (!vulkan_queue_create(context->device.logical,
                             &context->device.graphics_queue,
                             &context->alloc.vulkan_callbacks)) {
        KB_ERROR("failed to initialize graphics queue");
        context->device.graphics_queue.available = false;
        return false;
    }
    if (!vulkan_queue_create(context->device.logical,
                             &context->device.transfer_queue,
                             &context->alloc.vulkan_callbacks)) {
        KB_ERROR("failed to initialize transfer queue");
        context->device.transfer_queue.available = false;
        return false;
    }
    if (!vulkan_queue_create(context->device.logical,
                             &context->device.present_queue,
                             &context->alloc.vulkan_callbacks)) {
        KB_ERROR("failed to initialize present queue");
        context->device.present_queue.available = false;
        return false;
    }
    if (!vulkan_queue_create(context->device.logical,
                             &context->device.compute_queue,
                             &context->alloc.vulkan_callbacks)) {
        KB_ERROR("failed to initialize compute queue");
        context->device.compute_queue.available = false;
        return false;
    }
    return true;
}
 
b8 vulkan_physical_device_meets_requirements(VkPhysicalDevice            device,
                                             VkPhysicalDeviceFeatures   *features,
                                             VkPhysicalDeviceProperties *props,
                                             vulkan_context             *context) {
    UNUSED(features);
    // discrete gpu requirement
    if (context->device.requirements.discrete_gpu && props->deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
        KB_INFO("device is not viable as its not a discrete GPU");
        return false;
    }
 
    // queue families
    vulkan_queue graphics_queue;
    vulkan_queue transfer_queue;
    vulkan_queue present_queue;
    vulkan_queue compute_queue;
 
    u32   queue_family_count = 0;
    vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, 0);
 
    array_of(VkQueueFamilyProperties) queue_props =
        array_create(VkQueueFamilyProperties, queue_family_count, &context->alloc.kiba_alloc);
    if (queue_props == KB_NULL) {
        KB_INFO("unable to allocate enough memory for list of queue properties");
        return false;
    }
    vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_props);
    array_resize(&queue_props, queue_family_count);
 
    for (u32 i = 0; i < queue_family_count; ++i) {
        if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT && !context->device.graphics_queue.available) {
            graphics_queue.available = true;
            graphics_queue.index     = i;
            VkBool32 present_support = false;
            VK_CALL_B8(vkGetPhysicalDeviceSurfaceSupportKHR(device, i, context->surface, &present_support));
            if (present_support) {
                present_queue.available = true;
                present_queue.index     = i;
            }
        }
        if (queue_props[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
            transfer_queue.available = true;
            transfer_queue.index     = i;
        }
        if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
            compute_queue.available = true;
            compute_queue.index     = i;
        }
    }
    array_destroy(&queue_props);
    if (context->device.requirements.graphics && !graphics_queue.available) {
        KB_INFO("device does not support required graphics queue");
        return false;
    }
    if (context->device.requirements.transfer && !transfer_queue.available) {
        KB_INFO("device does not support required transfer queue");
        return false;
    }
    if (context->device.requirements.present && !present_queue.available) {
        KB_INFO("device does not support required present queue");
        return false;
    }
    if (context->device.requirements.compute && !compute_queue.available) {
        KB_INFO("device does not support required compute queue");
        return false;
    }
 
    // device extensions
    u32   extension_count = 0;
    vkEnumerateDeviceExtensionProperties(device, 0, &extension_count, 0);
 
    array_of(VkExtensionProperties) extensions =
        array_create(VkExtensionProperties, extension_count, &context->alloc.kiba_alloc);
    if (extensions == KB_NULL) {
        KB_INFO("unable to allocate enough memory for list of extensions");
        return false;
    }
    vkEnumerateDeviceExtensionProperties(device, 0, &extension_count, extensions);
    array_resize(&extensions, extension_count);
 
    u32 required_extension_count = (u32) array_size(context->device.requirements.extensions);
    b8  has_extensions           = true;
    if (extension_count >= required_extension_count) {
        array_for_each(const char *, extension, context->device.requirements.extensions) {
            b8 found = false;
            for (u32 j = 0; j < extension_count; ++j) {
                if (string_equal(string_from_raw(*extension), string_from_raw(extensions[j].extensionName))) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                KB_INFO("required extension {raw_string} not supported by device", *extension);
                has_extensions = false;
            }
        }
    } else {
        KB_INFO("device cannot support all required extensions");
        has_extensions = false;
    }
 
    array_destroy(&extensions);
 
    context->device.graphics_queue = graphics_queue;
    context->device.transfer_queue = transfer_queue;
    context->device.present_queue  = present_queue;
    context->device.compute_queue  = compute_queue;
 
    return has_extensions;
}
 
b8 vulkan_queue_create(VkDevice logical_device, vulkan_queue *queue, const VkAllocationCallbacks *alloc) {
    if (!queue->available)
        return true;
    vkGetDeviceQueue(logical_device, queue->index, 0, &queue->queue);
    // command pool
    VkCommandPoolCreateInfo pool_create_info = {
        .sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
        .queueFamilyIndex = queue->index,
        .flags            = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
    };
    VK_CALL_B8(vkCreateCommandPool(logical_device, &pool_create_info, alloc, &queue->command_pool));
    // command buffer
    VkCommandBufferAllocateInfo cb_allocate_info = {
        .sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .commandPool        = queue->command_pool,
        .level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = 1,
    };
    VK_CALL_B8(vkAllocateCommandBuffers(logical_device, &cb_allocate_info, &queue->command_buffer));
    return true;
}
 
void vulkan_queue_destroy(VkDevice logical_device, vulkan_queue *queue, const VkAllocationCallbacks *alloc) {
    if (queue->available) {
        vkDestroyCommandPool(logical_device, queue->command_pool, alloc);
    }
}