In order to establish a connection with the available physical devices, an application has to enumerate them. Physical device enumeration is a process by which Vulkan exposes the number of actual devices, which are available on the system, to the application. A list of physical devices can be retrieved using vkEnumeratePhysicalDevices().

The following is the syntax of this API:

VkResult  (  
           VkInstance                   instance, 
           uint32_t                     pPhysicalDeviceCount, 
           VkPhysicalDevice*            pPhysicalDevice); 

The following are the fields associated with this API:

This API is wrapped in the Application class's enumeratePhysicalDevices function. It returns the number of physical device objects on the available system:

  VkResult VulkanApplication::enumeratePhysicalDevices 
               (std::vector<VkPhysicalDevice>& gpuList){ 
     
   // Holds the gpu count  
   uint32_t gpuDeviceCount;           
     
    
    // Get the gpu count 
    vkEnumeratePhysicalDevices 
    (instanceObj.instance, &gpuDeviceCount, NULL);          
 
    // Make space for retrieval 
    gpuList.resize(gpuDeviceCount);  
    
    // Get Physical device object 
    return vkEnumeratePhysicalDevices 
    (instanceObj.instance, &gpuDeviceCount, gpuList.data()); 
 
  } 

The following diagram shows the enumerated physical devices on the system and is associated with the VkInstance object while querying:

A physical device exposes extensions similar to Vulkan instances. For each retrieved instance layer property (VkLayerProperties), there may exist extension properties for each physical device that can be queried using the vkEnumerateDeviceExtensionProperties() API.

The following is the syntax of this API:

VkResult vkEnumerateDeviceExtensionProperties ( 
                VkPhysicalDevice             physicalDevice, 
                const char*                  pLayerName, 
                uint32_t*                    pExtensionCount, 
                VkExtensionProperties*       pProperties); 

Here are the fields associated with this API:

The process of querying device-based extension properties is very similar to that of an instance-based one. The following is the implementation of this function:

VkResult VulkanLayerAndExtension::getDeviceExtensionProperties 
                                      (VkPhysicalDevice* gpu) 
{ 
   // Variable to check Vulkan API result status 
   VkResult result; 
 
   // Query all the extensions for each layer and store it. 
   std::cout << "Device extensions" << std::endl; 
   std::cout << "===================" << std::endl; 
   VulkanApplication* appObj = VulkanApplication::GetInstance(); 
   std::vector<LayerProperties>* instanceLayerProp =  
                            &appObj->GetInstance()->instanceObj. 
                            layerExtension.layerPropertyList; 
 
   for (auto globalLayerProp : *instanceLayerProp) { 
         LayerProperties layerProps; 
         layerProps.properties = globalLayerProp.properties; 
 
         if (result = getExtensionProperties(layerProps, gpu)) 
               continue; 
 
         layerPropertyList.push_back(layerProps); 
 
        // Many lines skipped.. 
   } 
   return result; 
} 

The properties of a physical device can be retrieved using the vkGetPhysicalDeviceProperties() API; the attributes are retrieved in the VkPhysicalDeviceProperties control structure. Here's the syntax of this process:

void vkGetPhysicalDeviceMemoryProperties ( 
      VkPhysicalDevice                       physicalDevice, 
      VkPhysicalDeviceMemoryProperties*      pMemoryProperties ); 

Here are the fields for vkGetPhysicalDeviceMemoryProperties:

A single physical device may have different memory types, which are further differentiated based on their properties. It's important for an application to know the characteristics of the memory; this facilitates better allocation of the resources, depending upon the application logic or resource type. The following syntax is to retrieve the physical device memory properties:

void vkGetPhysicalDeviceMemoryProperties ( 
             VkPhysicalDevice                   physicalDevice, 
             VkPhysicalDeviceMemoryProperties*  pMemoryProperties ); 

Here are the fields described for vkGetPhysicalDeviceMemoryProperties:

A logical device is represented using VkDevice and can be created using the vkCreateDevice API. Here's the syntax of this:

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

For more information on API fields, refer to the following table:

This API uses the VkDeviceCreateInfo control structure object (deviceInfo), which contains the necessary information required to create a logical device object. For instance, it contains the names of the layers (this feature is deprecated and kept for backward-compatibility) and extensions that need to be enabled on the device. In addition, it also specifies which queue it should be creating and connect to. In our case, we are interested in drawing operations; therefore, we need a queue handle (graphicsQueueIndex) that will represent a queue that has the functionality of drawing capabilities. In other words, we need the graphics queue handle.

VulkanDevice::createDevice is a user-defined wrapper method that helps to create the logical device object. Here is its implementation:

  VkResult VulkanDevice::createDevice(vector<const char *>& layers, 
                          vector<const char *>& extensions){ 
 
  VkResult result; 
  float queuePriorities[1]       = { 0.0 }; 
 
  // Create the object information       
  VkDeviceQueueCreateInfo queueInfo    = {}; 
  queueInfo.queueFamilyIndex           = graphicsQueueIndex;   
  queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 
  queueInfo.pNext                      = NULL; 
  queueInfo.queueCount                 = 1; 
  queueInfo.pQueuePriorities           = queuePriorities; 
 
  VkDeviceCreateInfo deviceInfo = {}; 
  deviceInfo.sType   = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 
  deviceInfo.pNext                     = NULL; 
  deviceInfo.queueCreateInfoCount      = 1; 
  deviceInfo.pQueueCreateInfos         = &queueInfo; 
  deviceInfo.enabledLayerCount         = 0; 
  // Device layers are deprecated 
  deviceInfo.ppEnabledLayerNames       = NULL; 
  deviceInfo.enabledExtensionCount     = extensions.size(); 
  deviceInfo.ppEnabledExtensionNames   = extensions.data(); 
  deviceInfo.pEnabledFeatures          = NULL; 
 
  result = vkCreateDevice(*gpu, &deviceInfo, NULL, &device); 
 
  assert(result == VK_SUCCESS); 
  return result; 
} 

A device is said to be active as long as it has jobs in the queues to process. Once the queues have no more command buffers to process, the device becomes idle. The following vkDeviceWaitIdle API waits on the host until all the queues for the logical device become idle. This API accepts the argument that takes the handle of the logical device object for which the idle status is to be checked. Here's the syntax for this:

VkResult vkDeviceWaitIdle( VkDevice device); 

While working with logical (VKDevice) and physical (VKPhysicalDevice) devices for a certain reason--such as hardware malfunction, device error, execution timeouts, power management events, and/or platform-specific events--the devices can be lost. This may result in failing to execute the pending commands buffer.