[Vulkan] Vulkan Device

인프런 삼각형님의 '삼각형의 실전! Vulkan 중급' 강의를 참고하였습니다. 
😎 [삼각형의 실전! Vulkan 중급] 강의 들으러 가기!

Vulkan Device

Vulkan Device란?

렌더링이나 컴퓨팅을 하기 위해서는 Vulkan Device가 반드시 필요함.

Vulkan Device는 Logical한 자원임.

Vulkan Physical Device를 Vulkan Device를 통해 추상화함으로써 하드웨어 의존성을 벗어날 수 있음.

• NVIDIA GPU와 AMD GPU가 Logical하게 같다면 두 Vulkan Device를 동일하다고 생각할 수 있다.
• Logical하게 같은 두 Vulkan Device를 하나로 묶어서 mGPU로 사용할 수 있습니다.

Vulkan Device 생성

Vulkan Queue

Vulkan Queue는 생성되는 자원이 아니라 Vulkan Device의 요소입니다.

RDNA 아키텍처를 살펴보면 다양한 Queue가 있는 것을 확인할 수 있다. Queue는 아래에 적힌 Graphics Command Processor, AC, DMA 중 한 개에 포함된다. 이러한 분류를 Queue Family라고 한다.

• Graphics Command Processor
• ACE
• DMA

개발자는 다양한 Queue 중에서 어플리케이션에 적합한 Queue를 선택하여 Vulkan Device를 생성한다.

Vulkan Queue family properties 얻기

void vkGetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice physicalDevice,
     uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties* pQueueFamilyProperties);

VkQueueFamilyProperties 구조체

typedef struct VkQueueFamilyProperties {
     VkQueueFlags queueFlags;
     uint32_t queueCount;
     uint32_t timestampValidBits;
     VkExtent3D minImageTransferGranularity;
} VkQueueFamilyProperties;

VkQueueFlagBits 열거형

typedef enum VkQueueFlagBits {
     VK_QUEUE_GRAPHICS_BIT = 0x00000001, // 랜더링 작업을 수행하기 위해서는 켜져 있어야 함.
     VK_QUEUE_COMPUTE_BIT = 0x00000002,
     VK_QUEUE_TRANSFER_BIT = 0x00000004,
     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
     VK_QUEUE_PROTECTED_BIT = 0x00000010,
} VkQueueFlagBits;

Vulkan Queue가 어떤 기능을 제공하는지 VkQueueFlagsBits 열거형을 사용하여 알 수 있다.

Vulkan을 사용해서 렌더링을 할 것이기 때문에 VK_QUEUE_GRAPHICS_BIT이 활성화되어 있어야 한다.

Vulkan을 통해 랜더링 작업을 수행하기 위해서는 VK_QUEUE_GRAPHICS_BIT이 활성화된 queue-family를 선택해야 한다. 만약 이 플래그가 활성화되지 않으면 해당 queue에서 렌더링 작업을 할 수 없다.

Graphics가 지원되는 Vulkan Queue family 찾기

mQueueFamilyIndex는 VKGapPhysicalDeviceQueueFamilyProperty 함수를 통해 얻어온 배열의 인덱스를 의미한다.

VkDeviceQueueCreateInfo 구조체

typedef struct VkDeviceQueueCreateInfo {
     VkStructureType sType;
     const void* pNext;
     VkDeviceQueueCreateFlags flags;
     uint32_t queueFamilyIndex;
     uint32_t queueCount;
     const float* pQueuePriorities;
} VkDeviceQueueCreateInfo;

VkDeviceCreateInfo 구조체

만약 queue를 2개 생성한다면 const vector<float> queuePriorities 배열의 크기도 2가 되어야 한다.

VkDeviceCreateInfo 구조체

typedef struct VkDeviceCreateInfo {
     VkStructureType sType;
     const void* pNext;
     VkDeviceCreateFlags flags;
     uint32_t queueCreateInfoCount;
     const VkDeviceQueueCreateInfo* pQueueCreateInfos;
     uint32_t enabledLayerCount;
     const char* const* ppEnabledLayerNames;
     uint32_t enabledExtensionCount;
     const char* const* ppEnabledExtensionNames;
     const VkPhysicalDeviceFeatures* pEnabledFeatures;
} VkDeviceCreateInfo;

Vulkan Device 정의

Vulkan Device 생성

VkResult vkCreateDevice(
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDevice* pDevice);

Vulkan Queue 얻기

void vkGetDeviceQueue(
     VkDevice device,
     uint32_t queueFamilyIndex,
     uint32_t queueIndex,
     VkQueue* pQueue);

Vulkan Device 파괴

void vkDestroyDevice(
     VkDevice device,
     const VkAllocationCallbacks* pAllocator);

코드

#include ...
using namespace std;
 
VkRenderer::VkRenderer() {
    // 1. VkInstance 생성
    // 2. VkPhysicalDevice 선택
 
    // ================================================================================
    // 3. VkDevice 생성
    
    uint32_t queueFamilyPropertiesCount;
 
    //---------------------------------------------------------------------------------
    //** queueFamily 속성을 조회
    // 사용 가능한 queueFamily의 수(=queueFamilyPropertiesCount)를 얻어온다.
    vkGetPhysicalDeviceQueueFamilyProperties(mPhysicalDevice, &queueFamilyPropertiesCount, nullptr);
 
    vector<VkQueueFamilyProperties> queueFamilyProperties(queueFamilyPropertiesCount);
    // 해당 queueFamily들의 속성을 배열에 얻어온다.
    vkGetPhysicalDeviceQueueFamilyProperties(mPhysicalDevice, &queueFamilyPropertiesCount, queueFamilyProperties.data());
    //---------------------------------------------------------------------------------
 
    // 특정 queueFamilyProperties가 VK_QUEUE_GRAPHICS_BIT를 지원하는지 확인.
    // 지원하는 queueFamilyProperties를 찾으면 break. queueFamily에 대한 정보는 mQueueFamilyIndex에 저장.
    for (mQueueFamilyIndex = 0;
         mQueueFamilyIndex != queueFamilyPropertiesCount; ++mQueueFamilyIndex) {
        if (queueFamilyProperties[mQueueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
            break;
        }
    }
 
    // 생성할 큐를 정의
    const vector<float> queuePriorities{1.0};
    VkDeviceQueueCreateInfo deviceQueueCreateInfo{
        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
        .queueFamilyIndex = mQueueFamilyIndex,      // queueFamilyIndex
        .queueCount = 1,                            // 생성할 큐의 개수
        .pQueuePriorities = queuePriorities.data()  // 큐의 우선순위
    };
 
    // 생성할 Device 정의
    VkDeviceCreateInfo deviceCreateInfo{
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .queueCreateInfoCount = 1,                  // 큐의 개수
        .pQueueCreateInfos = &deviceQueueCreateInfo // 생성할 큐의 정보
    };
 
    // vkCreateDevice를 호출하여 Device 생성(= mDevice 생성)
    VK_CHECK_ERROR(vkCreateDevice(mPhysicalDevice, &deviceCreateInfo, nullptr, &mDevice));
    // 생성된 Device(= mDevice)로부터 큐를 vkGetDeviceQueue를 호출하여 얻어온다.
    vkGetDeviceQueue(mDevice, mQueueFamilyIndex, 0, &mQueue);
}
 
VkRenderer::~VkRenderer() {
    vkDestroyDevice(mDevice, nullptr);      // Device 파괴
    vkDestroyInstance(mInstance, nullptr);
    
    // queue의 경우 Device를 생성하면서 생겼기 때문에 따로 파괴하는 API가 존재하지 않는다.
}

전체 코드

#include <cassert>
#include <array>
#include <vector>
#include <iomanip>
#include "VkRenderer.h"
#include "VkUtil.h"
#include "AndroidOut.h"
using namespace std;
 
VkRenderer::VkRenderer() {
    // ================================================================================
    // 1. VkInstance 생성
    // ================================================================================
    VkApplicationInfo applicationInfo{
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pApplicationName = "Practice Vulkan",
        .applicationVersion = VK_MAKE_API_VERSION(0, 0, 1, 0),
        .apiVersion = VK_MAKE_API_VERSION(0, 1, 3, 0)
    };
 
    uint32_t instanceLayerCount;
    VK_CHECK_ERROR(vkEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr));
 
    vector<VkLayerProperties> instanceLayerProperties(instanceLayerCount);
    VK_CHECK_ERROR(vkEnumerateInstanceLayerProperties(&instanceLayerCount,
                                                      instanceLayerProperties.data()));
 
    vector<const char *> instanceLayerNames;
    for (const auto &properties: instanceLayerProperties) {
        instanceLayerNames.push_back(properties.layerName);
    }
 
    VkInstanceCreateInfo instanceCreateInfo{
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pApplicationInfo = &applicationInfo,
        .enabledLayerCount = static_cast<uint32_t>(instanceLayerNames.size()),
        .ppEnabledLayerNames = instanceLayerNames.data()
    };
 
    VK_CHECK_ERROR(vkCreateInstance(&instanceCreateInfo, nullptr, &mInstance));
 
    // ================================================================================
    // 2. VkPhysicalDevice 선택
    // ================================================================================
    uint32_t physicalDeviceCount;
    VK_CHECK_ERROR(vkEnumeratePhysicalDevices(mInstance, &physicalDeviceCount, nullptr));
 
    vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount);
    VK_CHECK_ERROR(vkEnumeratePhysicalDevices(
        mInstance, &physicalDeviceCount, physicalDevices.data()));
 
    mPhysicalDevice = physicalDevices[0];
 
    VkPhysicalDeviceProperties physicalDeviceProperties;
    vkGetPhysicalDeviceProperties(mPhysicalDevice, &physicalDeviceProperties);
 
    aout << "Selected Physical Device Information ↓" << endl;
    aout << setw(16) << left << " - Device Name: "
         << string_view(physicalDeviceProperties.deviceName) << endl;
    aout << setw(16) << left << " - Device Type: "
         << vkToString(physicalDeviceProperties.deviceType) << endl;
    aout << std::hex;
    aout << setw(16) << left << " - Device ID: " << physicalDeviceProperties.deviceID << endl;
    aout << setw(16) << left << " - Vendor ID: " << physicalDeviceProperties.vendorID << endl;
    aout << std::dec;
    aout << setw(16) << left << " - API Version: "
         << VK_API_VERSION_MAJOR(physicalDeviceProperties.apiVersion) << "."
         << VK_API_VERSION_MINOR(physicalDeviceProperties.apiVersion);
    aout << setw(16) << left << " - Driver Version: "
         << VK_API_VERSION_MAJOR(physicalDeviceProperties.driverVersion) << "."
         << VK_API_VERSION_MINOR(physicalDeviceProperties.driverVersion);
 
    // ================================================================================
    // 3. VkDevice 생성
    // ================================================================================
    uint32_t queueFamilyPropertiesCount;
    vkGetPhysicalDeviceQueueFamilyProperties(mPhysicalDevice, &queueFamilyPropertiesCount, nullptr);
 
    vector<VkQueueFamilyProperties> queueFamilyProperties(queueFamilyPropertiesCount);
    vkGetPhysicalDeviceQueueFamilyProperties(mPhysicalDevice, &queueFamilyPropertiesCount,
                                             queueFamilyProperties.data());
 
    for (mQueueFamilyIndex = 0;
         mQueueFamilyIndex != queueFamilyPropertiesCount; ++mQueueFamilyIndex) {
        if (queueFamilyProperties[mQueueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
            break;
        }
    }
 
    const vector<float> queuePriorities{1.0};
    VkDeviceQueueCreateInfo deviceQueueCreateInfo{
        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
        .queueFamilyIndex = mQueueFamilyIndex,
        .queueCount = 1,
        .pQueuePriorities = queuePriorities.data()
    };
 
    VkDeviceCreateInfo deviceCreateInfo{
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .queueCreateInfoCount = 1,
        .pQueueCreateInfos = &deviceQueueCreateInfo
    };
 
    VK_CHECK_ERROR(vkCreateDevice(mPhysicalDevice, &deviceCreateInfo, nullptr, &mDevice));
    vkGetDeviceQueue(mDevice, mQueueFamilyIndex, 0, &mQueue);
}
 
VkRenderer::~VkRenderer() {
    vkDestroyDevice(mDevice, nullptr);
    vkDestroyInstance(mInstance, nullptr);
}