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..ace4d2411c22cd181ebee48c7ae93a038bab57d6
--- /dev/null
+++ b/gpu/vulkan/vulkan_swap_chain.cc
@@ -0,0 +1,361 @@
+// 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_);
+  DCHECK_EQ(static_cast<VkSemaphore>(VK_NULL_HANDLE), next_present_semaphore_);
+}
+
+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;
+
+  VkDevice device = GetVulkanDevice();
+  VkQueue queue = GetVulkanQueue();
+
+  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;
+
+  // Make sure the current command buffer is not in use.

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

You need to do that before resetting/recording the command buffer, though...
That's why I suggested doing that after vkAcquireNextImageKHR.

[David Yen, 2016/03/28 18:31:12]

Right, I was trying to delay it to be as late as possible. Putting it here
doesn't make sense... I think placing it in VulkanCommandBuffer before we reset
the command buffer is the best place.

+  result = vkWaitForFences(device, 1,
+                           &current_image_data->submission_fence,
+                           VK_TRUE, UINT64_MAX);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkWaitForFences() failed: " << result;
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  // Submit our command buffer for the current buffer.
+  if (!current_image_data->command_buffer->Submit(
+          queue, 1, &current_image_data->present_semaphore, 1,
+          &current_image_data->render_semaphore,
+          current_image_data->submission_fence)) {
+    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(queue, &present_info);
+  if (VK_SUCCESS != result) {
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  // Acquire then next image.
+  result = vkAcquireNextImageKHR(device, swap_chain_, UINT64_MAX,
+                                 next_present_semaphore_, VK_NULL_HANDLE,
+                                 &current_image_);
+  if (VK_SUCCESS != result) {
+    return gfx::SwapResult::SWAP_FAILED;
+  }
+
+  // Swap in the "next_present_semaphore" into the newly acquired image. The
+  // old "present_semaphore" for the image becomes the place holder for the next
+  // present semaphore for the next image.
+  scoped_ptr<ImageData>& next_image_data = images_[current_image_];
+  std::swap(next_image_data->present_semaphore, next_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;
+
+  // Generic fence creation structure.
+  VkFenceCreateInfo fence_create_info = {};
+  fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_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;

[jchen10, 2016/03/28 07:47:23]

Should we use VK_ACCESS_MEMORY_READ_BIT here for the below
VK_IMAGE_LAYOUT_SRC_KHR layout?

[piman, 2016/03/28 16:48:48]

True, this is inconsistent.
Actually, we're not allowed to operate on swapchain images that we haven't
acquired, so we should do the transition as part of the commands of the first
frame that operates on each image.

[David Yen, 2016/03/28 18:31:12]

Done. I can just queue the command for each command buffer which will get
submitted after the acquire commands.

+  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;
+      }
+
+      result = vkCreateFence(device, &fence_create_info, nullptr,
+                             &image_data->submission_fence);

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

Maybe you want to create these ones with VK_FENCE_CREATE_SIGNALED_BIT for the
first frame. Otherwise your first vkWaitForFences in SwapBuffers will block.

(but obviously, not for layout_fence since you submit it before waiting for it).

[David Yen, 2016/03/28 18:31:12]

Done inside VulkanCommandBuffer. The implementation didn't need it for this
particular problem (VulkanCommandBuffer has state tracking for when a submission
took place), but this just makes it so Wait() and SubmissionFinished() can be
called before the first Submit() call.

+      if (VK_SUCCESS != result) {
+        DLOG(ERROR) << "vkCreateFence(submission) 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();
+    }
+  }
+
+  result = vkCreateSemaphore(device, &semaphore_create_info, nullptr,
+                             &next_present_semaphore_);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkCreateSemaphore(next_present) failed: " << result;
+    return false;
+  }
+
+  // Submit the image layout commands here.
+  VkFence layout_fence = VK_NULL_HANDLE;
+  result = vkCreateFence(device, &fence_create_info, nullptr, &layout_fence);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkCreateFence(layout) failed: " << result;
+    return false;
+  }
+
+  // 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(),
+                                    layout_fence)) {
+    return false;
+  }
+
+  // TODO(dyen): Look into how we want to asynchronously check and clean up used
+  // command buffers. For now just wait until the fence passes. Eventually we
+  // probably want to store the fence somewhere and cleanup on a callback.
+  result = vkWaitForFences(device, 1, &layout_fence, VK_TRUE, UINT64_MAX);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkWaitForFences() failed: " << result;
+    return false;
+  }
+
+  vkDestroyFence(device, layout_fence, nullptr);
+  setup_command_buffer->Destroy();
+  return true;
+}
+
+void VulkanSwapChain::DestroySwapImages() {
+  VkDevice device = GetVulkanDevice();
+
+  if (VK_NULL_HANDLE != next_present_semaphore_) {
+    vkDestroySemaphore(device, next_present_semaphore_, nullptr);
+    next_present_semaphore_ = VK_NULL_HANDLE;
+  }
+
+  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/Fences.
+    if (VK_NULL_HANDLE != image_data->submission_fence) {
+      vkDestroyFence(device, image_data->submission_fence, nullptr);
+      image_data->submission_fence = VK_NULL_HANDLE;
+    }
+
+    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