GDC 2015 - Vulkan

Vulkan est représenté par une instance. Une application peut avoir plusieurs instances de Vulkan. Chacune est indépendante et appartient au pilote l'initiant. Ainsi, il est possible d'agréger les pilotes de différents constructeurs, de découvrir les GPU présents sur la machine et de créer une application en considérant que vous n'avez qu'un seul gros pilote supportant plusieurs GPU.

VK_APPLICATION_INFO appInfo = { ... }; 
VK_ALLOC_CALLBACKS allocCb = { ... }; 
VK_INSTANCE instance; 

vkCreateInstance(&appInfo, &allocCb, &instance);

La création d'une instance demande des informations sur votre application et des callbacks d'allocation. Vulkan alloue de la mémoire en utilisant votre allocateur. Une fois que vous obtenez l'instance, vous pouvez vous renseigner sur les GPU présents sur la machine.
Vous pouvez récupérer des informations sur chaque GPU : le constructeur, ses performances relatives, la taille de la mémoire, les types de queues… Il est aussi possible de savoir si les GPU peuvent partager des ressources entre eux, ou non.

uint32_t gpuCount; 
VK_PHYSICAL_GPU gpus[10]; 

vkEnumerateGpus(instance, ARRAYSIZE(gpus), &gpuCount, gpus);

VK_SOME_GPU_INFO_STRUCTURE info; 
uint32_t infoSize = sizeof(info); 

vkGetGpuInfo(gpu[0], VK_GPU_INFO_WHATEVER, &infoSize, &info);

VK_GPU_COMPATIBILITY_INFO compatInfo; 

vkGetMultiGpuCompatibility(gpuA, gpuB, &compatInfo);

Ensuite, vous devez créer un périphérique (device) offrant une représentation logique du GPU. Lors de la création, vous pouvez spécifier le nombre de queues nécessaires, les extensions…

VK_DEVICE_CREATE_INFO info = { ... }; 
VK_DEVICE device; 

vkCreateDevice(gpu, &info, &device);

Vous pouvez récupérer les queues à partir du périphérique. Celles-ci exécutent les tampons de commandes. Lors de la création des tampons de commandes, vous devez spécifier quel type de queues ils doivent utiliser.

VK_DEVICE_CREATE_INFO info = { ... }; 
VK_DEVICE device; 

vkCreateDevice(gpu, &info, &device);

Finalement, vous insérez des commandes dans les tampons de commandes. Vous pouvez créer autant de tampons de commandes que vous avez de threads. Vous pouvez aussi prendre un peu de temps pour optimiser le processus, mais ne le faites pas juste avant le rendu.

VK_CMD_BUFFER_CREATE_INFO info; 
VK_CMD_BUFFER cmdBuffer; 

vkCreateCommandBuffer(device, &info, &cmdBuffer);

Les shaders sont précompilés dans un langage intermédiaire (SPIR-V). La compilation en instructions natives peut être parallélisée sur le GPU.

VK_SHADER_CREATE_INFO info = { ... }; 
VK_SHADER shader; 

vkCreateShader(device, &info, &shader);

L'état du pipeline de rendu peut être sérialisé et désérialisé. Celui-ci contient les shaders compilés, les états des passes et une liste des états devant être mutables. Ceux-ci sont représentés par des objets indépendants.

VK_GRAPHICS_PIPELINE_CREATE_INFO info = { ... }; 
VK_PIPELINE pipeline; 

vkCreateGraphicsPipeline(device, &info, &pipeline);

uint32_t dataSize = DATA_SIZE; 
void* data = malloc(DATA_SIZE); 

vkStorePipeline(pipeline, &dataSize, data); 
... 
vkLoadPipeline(device, dataSize, data, &pipeline)

Les objets ressources de Vulkan possèdent un composant CPU et GPU. Du côté du CPU, la ressource est allouée avec une fonction vkCreate*. C'est à l'application d'allouer les ressources mémoire du GPU.

VK_IMAGE_CREATE_INFO imageInfo = { ... }; 
VK_IMAGE image; 
vkCreateImage(device, &imageInfo, &image); 

VK_BUFFER_CREATE_INFO bufferInfo = { ... }; 
VK_BUFFER buffer; 
vkCreateBuffer(device, &bufferInfo, &buffer)

Les passes de rendu (render pass) représentent les phases de l'affichage d'une image. Elles contiennent énormément d'informations sur le rendu (disposition et types liés au tampon d'image, ce qu'il faut faire au début et la fin de la passe de rendu, la région du tampon d'image que la passe affecte). L'affichage est placé dans une passe de rendu.

VK_RENDER_PASS_CREATE_INFO info = { ... }; 
VK_RENDER_PASS renderPass; 

vkCreateRenderPass(device, &info, &renderPass);

Du côté de la synchronisation, Vulkan propose les événements. Les tampons de commandes peuvent signaler des événements à la fin de leur exécution. Les opérations d'un tampon de commandes peuvent être démarquées par des barrières. Les barrières peuvent attendre pour un événement ou encore envoyer un signal.

VK_IMAGE_MEMORY_BARRIER imageBarrier = { ... }; 
VK_PIPELINE_BARRIER barrier = { ..., 1, &imageBarrier }; 

vkCmdPipelineBarrier(cmdBuffer, &barrier);

SPIR est une toute nouvelle représentation intermédiaire. Le standard est défini par Khronos. SPIR fait partie de Vulkan, mais aussi d'OpenCL 2.1.

Les fonctions dans un module contiennent un graphe du flux de contrôle (control-flow graph) des blocs basiques. Les résultats intermédiaires sont représentés en utilisant une seule tâche statique (single static-assignment).
Le langage peut être facilement étendu. Il est aussi possible de rajouter des informations de débogage.

Dans une des implémentations préliminaires de Vulkan chez ARM, les ingénieurs ont remarqué une diminution de 79 % du temps passé dans le driver, du côté du CPU.

GFXBench 5.0 est un test permettant de comparer les performances des nouvelles bibliothèques de rendu (Mantle, Vulkan, Direct3D 12). Dans la démonstration durant la GDC 2015 on voit qu'une fois le rendu passé sur la bibliothèque Vulkan, la consommation du CPU a diminué et le nombre d'images par seconde a augmenté.