Hash :
9601a548
Author :
Date :
2019-11-23T23:44:52
Vulkan: implement external semaphore barriers glWaitSemaphoreEXT and glSignalSemaphoreEXT functions optionally request buffer and image barriers to be performed by the implementation. If any barriers are present, a single global memory barrier is inserted to take care of memory accesses. In both functions, buffer and image memory barriers are used to perform queue ownership transfers to ANGLE's queue (glWaitSemaphoreEXT) or the EXTERNAL queue (glSignalSemaphoreEXT). In glWaitSemaphoreEXT, the given layouts are information regarding how the external entity (the caller) has modified the images' layouts, and is used to update ANGLE's internal state tracking. Bug: angleproject:3289 Bug: 1026673 Change-Id: Ic478a8813df727c89413c8ae2adf42b5c1d06069 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1933016 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Jamie Madill <jmadill@chromium.org> Reviewed-by: Michael Spang <spang@chromium.org>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// SemaphoreVk.cpp: Defines the class interface for SemaphoreVk, implementing
// SemaphoreImpl.
#include "libANGLE/renderer/vulkan/SemaphoreVk.h"
#include "common/debug.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/vulkan/BufferVk.h"
#include "libANGLE/renderer/vulkan/ContextVk.h"
#include "libANGLE/renderer/vulkan/RendererVk.h"
#include "libANGLE/renderer/vulkan/TextureVk.h"
namespace rx
{
namespace
{
vk::ImageLayout GetVulkanImageLayout(GLenum layout)
{
switch (layout)
{
case GL_NONE:
return vk::ImageLayout::Undefined;
case GL_LAYOUT_GENERAL_EXT:
return vk::ImageLayout::ExternalShadersWrite;
case GL_LAYOUT_COLOR_ATTACHMENT_EXT:
return vk::ImageLayout::ColorAttachment;
case GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT:
case GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT:
case GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT:
case GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT:
// Note: once VK_KHR_separate_depth_stencil_layouts becomes core or ubiquitous, we
// should optimize depth/stencil image layout transitions to only be performed on the
// aspect that needs transition. In that case, these four layouts can be distinguished
// and optimized. Note that the exact equivalent of these layouts are specified in
// VK_KHR_maintenance2, which are also usable, granted we transition the pair of
// depth/stencil layouts accordingly elsewhere in ANGLE.
return vk::ImageLayout::DepthStencilAttachment;
case GL_LAYOUT_SHADER_READ_ONLY_EXT:
return vk::ImageLayout::ExternalShadersReadOnly;
case GL_LAYOUT_TRANSFER_SRC_EXT:
return vk::ImageLayout::TransferSrc;
case GL_LAYOUT_TRANSFER_DST_EXT:
return vk::ImageLayout::TransferDst;
default:
UNREACHABLE();
return vk::ImageLayout::Undefined;
}
}
} // anonymous namespace
SemaphoreVk::SemaphoreVk() = default;
SemaphoreVk::~SemaphoreVk() = default;
void SemaphoreVk::onDestroy(const gl::Context *context)
{
ContextVk *contextVk = vk::GetImpl(context);
contextVk->addGarbage(&mSemaphore);
}
angle::Result SemaphoreVk::importFd(gl::Context *context, gl::HandleType handleType, GLint fd)
{
switch (handleType)
{
case gl::HandleType::OpaqueFd:
return importOpaqueFd(context, fd);
default:
ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
return angle::Result::Stop;
}
}
angle::Result SemaphoreVk::wait(gl::Context *context,
const gl::BufferBarrierVector &bufferBarriers,
const gl::TextureBarrierVector &textureBarriers)
{
ContextVk *contextVk = vk::GetImpl(context);
if (!bufferBarriers.empty() || !textureBarriers.empty())
{
// Create one global memory barrier to cover all barriers.
contextVk->getCommandGraph()->syncExternalMemory();
}
uint32_t rendererQueueFamilyIndex = contextVk->getRenderer()->getQueueFamilyIndex();
if (!bufferBarriers.empty())
{
// Perform a queue ownership transfer for each buffer.
for (gl::Buffer *buffer : bufferBarriers)
{
BufferVk *bufferVk = vk::GetImpl(buffer);
vk::BufferHelper &bufferHelper = bufferVk->getBuffer();
// If there were GL commands using this buffer prior to this call, that's a
// synchronization error on behalf of the program.
ASSERT(!bufferHelper.isCurrentlyInGraph());
vk::CommandBuffer *queueChange;
ANGLE_TRY(bufferHelper.recordCommands(contextVk, &queueChange));
// Queue ownership transfer.
bufferHelper.changeQueue(rendererQueueFamilyIndex, queueChange);
}
}
if (!textureBarriers.empty())
{
// Perform a queue ownership transfer for each texture. Additionally, we are being
// informed that the layout of the image has been externally transitioned, so we need to
// update our internal state tracking.
for (const gl::TextureAndLayout &textureAndLayout : textureBarriers)
{
TextureVk *textureVk = vk::GetImpl(textureAndLayout.texture);
vk::ImageHelper &image = textureVk->getImage();
vk::ImageLayout layout = GetVulkanImageLayout(textureAndLayout.layout);
// If there were GL commands using this image prior to this call, that's a
// synchronization error on behalf of the program.
ASSERT(!image.isCurrentlyInGraph());
// Inform the image that the layout has been externally changed.
image.onExternalLayoutChange(layout);
vk::CommandBuffer *queueChange;
ANGLE_TRY(image.recordCommands(contextVk, &queueChange));
// Queue ownership transfer.
image.changeLayoutAndQueue(image.getAspectFlags(), layout, rendererQueueFamilyIndex,
queueChange);
}
}
contextVk->insertWaitSemaphore(&mSemaphore);
return angle::Result::Continue;
}
angle::Result SemaphoreVk::signal(gl::Context *context,
const gl::BufferBarrierVector &bufferBarriers,
const gl::TextureBarrierVector &textureBarriers)
{
ContextVk *contextVk = vk::GetImpl(context);
if (!bufferBarriers.empty())
{
// Perform a queue ownership transfer for each buffer.
for (gl::Buffer *buffer : bufferBarriers)
{
BufferVk *bufferVk = vk::GetImpl(buffer);
vk::BufferHelper &bufferHelper = bufferVk->getBuffer();
vk::CommandBuffer *queueChange;
ANGLE_TRY(bufferHelper.recordCommands(contextVk, &queueChange));
// Queue ownership transfer.
bufferHelper.changeQueue(VK_QUEUE_FAMILY_EXTERNAL, queueChange);
}
}
if (!textureBarriers.empty())
{
// Perform a queue ownership transfer for each texture. Additionally, transition the image
// to the requested layout.
for (const gl::TextureAndLayout &textureAndLayout : textureBarriers)
{
TextureVk *textureVk = vk::GetImpl(textureAndLayout.texture);
vk::ImageHelper &image = textureVk->getImage();
vk::ImageLayout layout = GetVulkanImageLayout(textureAndLayout.layout);
// Don't transition to Undefined layout. If external wants to transition the image away
// from Undefined after this operation, it's perfectly fine to keep the layout as is in
// ANGLE. Note that vk::ImageHelper doesn't expect transitions to Undefined.
if (layout == vk::ImageLayout::Undefined)
{
layout = image.getCurrentImageLayout();
}
vk::CommandBuffer *layoutChange;
ANGLE_TRY(image.recordCommands(contextVk, &layoutChange));
// Queue ownership transfer and layout transition.
image.changeLayoutAndQueue(image.getAspectFlags(), layout, VK_QUEUE_FAMILY_EXTERNAL,
layoutChange);
}
}
if (!bufferBarriers.empty() || !textureBarriers.empty())
{
// Create one global memory barrier to cover all barriers.
contextVk->getCommandGraph()->syncExternalMemory();
}
return contextVk->flushImpl(&mSemaphore);
}
angle::Result SemaphoreVk::importOpaqueFd(gl::Context *context, GLint fd)
{
ContextVk *contextVk = vk::GetImpl(context);
RendererVk *renderer = contextVk->getRenderer();
if (!mSemaphore.valid())
{
mSemaphore.init(renderer->getDevice());
}
ASSERT(mSemaphore.valid());
VkImportSemaphoreFdInfoKHR importSemaphoreFdInfo = {};
importSemaphoreFdInfo.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR;
importSemaphoreFdInfo.semaphore = mSemaphore.getHandle();
importSemaphoreFdInfo.flags = 0;
importSemaphoreFdInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
importSemaphoreFdInfo.fd = fd;
ANGLE_VK_TRY(contextVk, vkImportSemaphoreFdKHR(renderer->getDevice(), &importSemaphoreFdInfo));
return angle::Result::Continue;
}
} // namespace rx