Added initial implementation of Vulkan Render Passes.

gpu/vulkan/vulkan_swap_chain.cc

Index: gpu/vulkan/vulkan_swap_chain.cc
diff --git a/gpu/vulkan/vulkan_swap_chain.cc b/gpu/vulkan/vulkan_swap_chain.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2e048f82770f525b94172db14e3f66e7ae240453
--- /dev/null
+++ b/gpu/vulkan/vulkan_swap_chain.cc
@@ -0,0 +1,315 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/vulkan/vulkan_swap_chain.h"
+
+#include "gpu/vulkan/vulkan_command_buffer.h"
+#include "gpu/vulkan/vulkan_command_pool.h"
+#include "gpu/vulkan/vulkan_image_view.h"
+#include "gpu/vulkan/vulkan_implementation.h"
+
+namespace gpu {
+
+VulkanSwapChain::VulkanSwapChain() {}
+
+VulkanSwapChain::~VulkanSwapChain() {
+  DCHECK(images_.empty());
+  DCHECK_EQ(static_cast<VkSwapchainKHR>(VK_NULL_HANDLE), swap_chain_);
+}
+
+bool VulkanSwapChain::Initialize(VkSurfaceKHR surface,
+                                 const VkSurfaceCapabilitiesKHR& surface_caps,
+                                 const VkSurfaceFormatKHR& surface_format) {
+  return InitializeSwapChain(surface, surface_caps, surface_format) &&
+         InitializeSwapImages(surface_caps, surface_format) &&
+         InitializeInitialBuffer();
+}
+
+void VulkanSwapChain::Destroy() {
+  DestroySwapImages();
+  DestroySwapChain();
+}
+
+gfx::SwapResult VulkanSwapChain::SwapBuffers() {
+  VkResult result = VK_SUCCESS;
+
+  scoped_ptr<ImageData>& current_image_data = images_[current_image_];
+
+  // Default image subresource range.
+  VkImageSubresourceRange image_subresource_range = {};
+  image_subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  image_subresource_range.baseMipLevel = 0;
+  image_subresource_range.levelCount = 1;
+  image_subresource_range.baseArrayLayer = 0;
+  image_subresource_range.layerCount = 1;
+
+  // Submit our command buffer for the current buffer.
+  if (!current_image_data->command_buffer->Submit(
+          GetVulkanQueue(), 0, nullptr, 1,
+          &current_image_data->render_semaphore)) {

[piman, 2016/03/25 02:01:27]

You need a fence here, to know when you can reuse the command buffer. the next
time around. One per image, and you probably want to wait on that fence after
vkAcquireNextImageKHR returns the same image.

[David Yen, 2016/03/25 17:36:14]

Since vkAcquireNextImageKHR is blocking on the presentation engine, doesn't that
mean when the presentation engine releases an image the command buffer is also
done being used and can be reused? Or are they not synchronized that way?

Otherwise, would just waiting on the present_semaphore be enough? I think
previously I had this wait on the present_semaphore but after I added the
UINT64_MAX timeout I removed it since the present_semaphore didn't seem
necessary anymore.

[piman, 2016/03/25 21:13:22]

That's not enough. The blocking that vkAcquireNextImageKHR is actually
potentially unrelated to GPU<->CPU communication, and has to do with the
app<->compositor communication.

For example if the presentation engine uses a blit model (i.e. it copies the
data from the presentation image), you can conceptually see vkQueuePresentKHR as
just enqueuing a blit, and after that the image is available again.

IOW, the following API sequence:
Submit(queue, null /*sema*/, command_buffer1, sema1);
QueuePresent(queue, sema1, swapchain, image_index);
AcquireNextImage(device, swap_chain, sema2, &image_index);
Submit(queue, sema2, command_buffer2, null /*sema*/);

Is really equivalent, under the hood, to:
Submit(queue, null /*sema*/, command_buffer1, sema1);
Submit(queue, sema1, blit_command_buffer, sema2);
Submit(queue, sema2, command_buffer2, null /*sema*/);

No fence needs to be involved. That would mean that AcquireNextImage can return
as soon as blit_command_buffer is submitted, with the same image, but that
doesn't mean that command_buffer1 is done executing, or any previous command
buffer, really. In fact the presentation engine may never even wait on the GPU.
You need a GPU->CPU synchronization, that's a VkFence. You can't wait on a
VkSemaphore from the CPU. A semaphore is more like an ordering primitive
(similar to chrome sync tokens).

[David Yen, 2016/03/26 00:33:30]

Ok I see. I added the submission fence. Since the AcquireNextImage call also
enqueues commands, that means we still would need to wait on the present
semaphore right? Waiting on the submission fence is not enough to guarantee the
present semaphore has signaled yet.


I wonder if we should just make this a feature in VulkanCommandBuffer, where we
can set a VkFence which always gets waited upon before submission. Seems like we
would always need something like this. We can add an check for the fence status
too for asynchronous usage patterns.

[piman, 2016/03/26 01:38:01]

Correct.
I think associating the VkFence with the VkCommandBuffer is a good idea, but
keep in mind that you want to wait for it before reusing the command buffer, not
before submitting it.

+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  // Queue the present.
+  VkPresentInfoKHR present_info = {};
+  present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+  present_info.waitSemaphoreCount = 1;
+  present_info.pWaitSemaphores = &current_image_data->render_semaphore;
+  present_info.swapchainCount = 1;
+  present_info.pSwapchains = &swap_chain_;
+  present_info.pImageIndices = &current_image_;
+
+  result = vkQueuePresentKHR(GetVulkanQueue(), &present_info);
+  if (VK_SUCCESS != result) {
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  // Setup for the next available buffer.
+  // TODO(dyen): Look into if this does what I'm expecting. More studying of
+  // the spec is required here. It doesn't seem clear if "success" when timeout
+  // is 0 means it will give you a buffer even before it's done presenting. That
+  // is probably what we want and the present/render_layout semaphore will
+  // do the synchronization for us.

[piman, 2016/03/25 02:01:26]

We'll need a fence for throttling, though. Without a fence, this could queue an
infinite number of frames, faster than the GPU or display can consume. The fence
suggested above may be enough.

[David Yen, 2016/03/25 17:36:14]

Wouldn't this call throttle by blocking if the next image is still being owned
by the presentation engine?

[piman, 2016/03/25 21:13:22]

The presentation engine may very well never wait on the GPU, so it's not enough
to throttle.

[David Yen, 2016/03/26 00:33:30]

Acknowledged.

+  result = vkAcquireNextImageKHR(GetVulkanDevice(), swap_chain_, UINT64_MAX,
+                                 current_image_data->present_semaphore,
+                                 VK_NULL_HANDLE, &current_image_);
+  if (VK_SUCCESS != result) {
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  scoped_ptr<ImageData>& next_image_data = images_[current_image_];
+
+  // The present semaphore actually is associated with the new image data, but
+  // the previous one is guaranteed to be unused to swap it to the correct one.
+  std::swap(next_image_data->present_semaphore,
+            current_image_data->present_semaphore);
+
+  return gfx::SwapResult::SWAP_ACK;
+}
+
+bool VulkanSwapChain::InitializeSwapChain(
+    VkSurfaceKHR surface,
+    const VkSurfaceCapabilitiesKHR& surface_caps,
+    const VkSurfaceFormatKHR& surface_format) {
+  VkDevice device = GetVulkanDevice();
+  VkResult result = VK_SUCCESS;
+
+  VkSwapchainCreateInfoKHR swap_chain_create_info = {};
+  swap_chain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+  swap_chain_create_info.surface = surface;
+  swap_chain_create_info.minImageCount =
+      std::max(2u, surface_caps.minImageCount);
+  swap_chain_create_info.imageFormat = surface_format.format;
+  swap_chain_create_info.imageColorSpace = surface_format.colorSpace;
+  swap_chain_create_info.imageExtent = surface_caps.currentExtent;
+  swap_chain_create_info.imageArrayLayers = 1;
+  swap_chain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+  swap_chain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+  swap_chain_create_info.preTransform = surface_caps.currentTransform;
+  swap_chain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+  swap_chain_create_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
+  swap_chain_create_info.clipped = true;
+  swap_chain_create_info.oldSwapchain = swap_chain_;
+
+  VkSwapchainKHR new_swap_chain = VK_NULL_HANDLE;
+  result = vkCreateSwapchainKHR(device, &swap_chain_create_info, nullptr,
+                                &new_swap_chain);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkCreateSwapchainKHR() failed: " << result;
+    return false;
+  }
+
+  // Destroy the old swap chain and buffers.
+  // TODO(dyen): Look into how to do this safely while commands in flight.
+  Destroy();
+
+  swap_chain_ = new_swap_chain;
+  size_ = gfx::Size(swap_chain_create_info.imageExtent.width,
+                    swap_chain_create_info.imageExtent.height);
+
+  return true;
+}
+
+void VulkanSwapChain::DestroySwapChain() {
+  VkDevice device = GetVulkanDevice();
+
+  if (swap_chain_ != VK_NULL_HANDLE) {
+    vkDestroySwapchainKHR(device, swap_chain_, nullptr);
+    swap_chain_ = VK_NULL_HANDLE;
+  }
+}
+
+bool VulkanSwapChain::InitializeSwapImages(
+    const VkSurfaceCapabilitiesKHR& surface_caps,
+    const VkSurfaceFormatKHR& surface_format) {
+  VkDevice device = GetVulkanDevice();
+  VkResult result = VK_SUCCESS;
+
+  uint32_t image_count = 0;
+  result = vkGetSwapchainImagesKHR(device, swap_chain_, &image_count, nullptr);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkGetSwapchainImagesKHR(NULL) failed: " << result;
+    return false;
+  }
+
+  std::vector<VkImage> images(image_count);
+  result =
+      vkGetSwapchainImagesKHR(device, swap_chain_, &image_count, images.data());
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkGetSwapchainImagesKHR(images) failed: " << result;
+    return false;
+  }
+
+  // Generic semaphore creation structure.
+  VkSemaphoreCreateInfo semaphore_create_info = {};
+  semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+  // Default image subresource range.
+  VkImageSubresourceRange image_subresource_range = {};
+  image_subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  image_subresource_range.baseMipLevel = 0;
+  image_subresource_range.levelCount = 1;
+  image_subresource_range.baseArrayLayer = 0;
+  image_subresource_range.layerCount = 1;
+
+  // The image memory barrier is used to setup the image layout.
+  VkImageMemoryBarrier image_memory_barrier = {};
+  image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+  image_memory_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+  image_memory_barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+  image_memory_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  image_memory_barrier.subresourceRange = image_subresource_range;
+
+  command_pool_ = CreateCommandPool();
+  if (!command_pool_)
+    return false;
+
+  scoped_ptr<VulkanCommandBuffer> setup_command_buffer =
+      command_pool_->CreatePrimaryCommandBuffer();
+  if (!setup_command_buffer)
+    return false;
+
+  {
+    ScopedSingleUseCommandBufferRecorder recorder(*setup_command_buffer);
+    images_.resize(image_count);
+    for (uint32_t i = 0; i < image_count; ++i) {
+      images_[i].reset(new ImageData);
+      scoped_ptr<ImageData>& image_data = images_[i];
+      image_data->image = images[i];
+
+      // Setup semaphores.
+      result = vkCreateSemaphore(device, &semaphore_create_info, nullptr,
+                                 &image_data->render_semaphore);
+      if (VK_SUCCESS != result) {
+        DLOG(ERROR) << "vkCreateSemaphore(render) failed: " << result;
+        return false;
+      }
+
+      result = vkCreateSemaphore(device, &semaphore_create_info, nullptr,
+                                 &image_data->present_semaphore);
+      if (VK_SUCCESS != result) {
+        DLOG(ERROR) << "vkCreateSemaphore(present) failed: " << result;
+        return false;
+      }
+
+      // Setup the Image Layout.
+      image_memory_barrier.image = images[i];
+      vkCmdPipelineBarrier(recorder.handle(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                           VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0,
+                           nullptr, 1, &image_memory_barrier);
+
+      // Create the image view.
+      image_data->image_view.reset(new VulkanImageView);
+      if (!image_data->image_view->Initialize(
+              images[i], VK_IMAGE_VIEW_TYPE_2D,
+              VulkanImageView::IMAGE_TYPE_COLOR, surface_format.format,
+              size_.width(), size_.height(), 0, 1, 0, 1)) {
+        return false;
+      }
+
+      // Initialize the command buffer for this buffer data.
+      image_data->command_buffer = command_pool_->CreatePrimaryCommandBuffer();
+    }
+  }
+
+  // Submit the image layout commands, and tie them all to the render layout.
+  std::vector<VkSemaphore> initial_present_semaphores(image_count);
+  for (uint32_t i = 0; i < image_count; ++i) {
+    initial_present_semaphores[i] = images_[i]->present_semaphore;
+  }
+  if (!setup_command_buffer->Submit(GetVulkanQueue(), 0, nullptr, image_count,
+                                    initial_present_semaphores.data())) {
+    return false;
+  }
+
+  // TODO(dyen): Look into how we want to asynchronously check and clean up used
+  // command buffers. For now just wait until the queue is idle so we can delete
+  // the command buffer from the stack.
+  result = vkQueueWaitIdle(GetVulkanQueue());
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkQueueWaitIdle() failed: " << result;
+    return false;
+  }
+
+  setup_command_buffer->Destroy();
+  return true;
+}
+
+void VulkanSwapChain::DestroySwapImages() {
+  VkDevice device = GetVulkanDevice();
+
+  for (const scoped_ptr<ImageData>& image_data : images_) {
+    if (image_data->command_buffer) {
+      image_data->command_buffer->Destroy();
+      image_data->command_buffer.reset();
+    }
+
+    // Destroy Image View.
+    if (image_data->image_view) {
+      image_data->image_view->Destroy();
+      image_data->image_view.reset();
+    }
+
+    // Destroy Semaphores.
+    if (VK_NULL_HANDLE != image_data->present_semaphore) {
+      vkDestroySemaphore(device, image_data->present_semaphore, nullptr);
+      image_data->present_semaphore = VK_NULL_HANDLE;
+    }
+
+    if (VK_NULL_HANDLE != image_data->render_semaphore) {
+      vkDestroySemaphore(device, image_data->render_semaphore, nullptr);
+      image_data->render_semaphore = VK_NULL_HANDLE;
+    }
+
+    image_data->image = VK_NULL_HANDLE;
+  }
+  images_.clear();
+
+  if (command_pool_) {
+    command_pool_->Destroy();
+    command_pool_.reset();
+  }
+}
+
+bool VulkanSwapChain::InitializeInitialBuffer() {
+  // Acquire the initial buffer, all the buffers have their initial render
+  // layout semaphore setup so this is a special case.
+  const VkResult result =
+      vkAcquireNextImageKHR(GetVulkanDevice(), swap_chain_, UINT64_MAX,
+                            VK_NULL_HANDLE, VK_NULL_HANDLE, &current_image_);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkAcquireNextImageKHR() failed: " << result;
+    return false;
+  }
+
+  return true;
+}
+
+VulkanSwapChain::ImageData::ImageData() {}
+
+VulkanSwapChain::ImageData::~ImageData() {}
+
+}  // namespace gpu