queues. We will use a fence to synchronize swap chain image acquisition and a

semaphore to synchronize drawing commands with presentation.

A fence is a synchronization primitive in Vulkan that allows you to synchronize

your program with GPU operations. You can set up GPU operations like drawing

commands to put such a fence is a *signalled* state when they are completed and

use a function call like `vkWaitForFences` in your own program to wait for them

to become signalled. This is useful because many functions in Vulkan that start

operations return immediately and the actual operation is finished at some point

in the background. With fences you can wait for one or more of these operations

to finish before continuing code execution.

We'll be using a fence to signal that an image has been acquired from the swap

chain and is ready for rendering. Create a class member to store this fence

object:

VkFence imageAvailableFence;

To create the fence, we'll add the last `create` function for this part of the

tutorial: `createSynchronizationPrimitives`. It's named that way because we'll

also create the semaphore in this function later on.

createSynchronizationPrimitives();

void createSynchronizationPrimitives() {

}

Creating a fence requires filling in the `VkFenceCreateInfo` struct, but in the

current version of the API we'll only need to fill in the `sType` field. There

is an optional `flags` field that allows you to initialize a fence to already be

signalled, but we don't need that.

void createSynchronizationPrimitives() {

VkFenceCreateInfo fenceInfo = {};

fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;

}

Creating the fence follows the familiar pattern with `vkCreateFence`:

if (vkCreateFence(device, &fenceInfo, nullptr, &imageAvailableFence) != VK_SUCCESS) {

throw std::runtime_error("failed to create fence!");

The fence should be cleaned up at the end of the program, when all commands have

finished and no more synchronization is necessary:

void cleanup() {

vkDestroyFence(device, imageAvailableFence, nullptr);

We'll continue working in the `createSynchronizationPrimitives` function.

Creating semaphores requires filling in the `VkSemaphoreCreateInfo` struct, but

in the current version of the API it doesn't actually have any required fields

besides `sType`:

void createSynchronizationPrimitives() {

...

a semaphore is done through `vkCreateSemaphore`:

if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphore) != VK_SUCCESS) {

throw std::runtime_error("failed to create semaphore!");

The semaphore should be cleaned up at the end of the program, when all commands

vkDestroyFence(device, imageAvailableFence, nullptr);

fence or both. We're going to use our `imageAvailableFence` for that purpose

This function returns immediately, possibly before an image is actually

available. To wait for this to happen, we should now wait on our fence to be

signalled using `vkWaitForFences`:

vkWaitForFences(device, 1, &imageAvailableFence, VK_TRUE, std::numeric_limits<uint64_t>::max());

submitInfo.waitSemaphoreCount = 0; // Optional

submitInfo.pWaitSemaphores = nullptr; // Optional

submitInfo.pWaitDstStageMask = nullptr; // Optional

The rendering operations should wait with writing to the image until after it

has successfully been acquired. We've already explicitly synchronized this by

waiting on the image acquisition fence to be signalled before submitting the

drawing command buffer in the first place, so no semaphore is necessary here.

argument for efficiency when the workload is much larger. The last parameter can

be used to signal a fence once the drawing commands have finished execution, but

we're using a semaphore in this case so we'll just pass a `VK_NULL_HANDLE` here.

We now used a fence to synchronize image acquisition with drawing commands and a

semaphore to synchronize drawing with presentation. As you saw, it is also

possible for `vkAcquireNextImageKHR` to signal a semaphore instead of a fence

and have `vkQueueSubmit` wait on a semaphore through fields in `VkSubmitInfo`.

Doing this synchronization with a semaphore would look like this:

vkAcquireNextImageKHR(device, swapChain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);

...

VkSemaphore waitSemaphores[] = {imageAvailableSemaphore};

VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = waitSemaphores;

submitInfo.pWaitDstStageMask = waitStages;