Added initial implementation of Vulkan Render Passes.

gpu/vulkan/vulkan_command_buffer.cc

+// 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_command_buffer.h"
+
+#include "gpu/vulkan/vulkan_command_pool.h"
+#include "gpu/vulkan/vulkan_implementation.h"
+
+namespace gpu {
+
+VulkanCommandBuffer::VulkanCommandBuffer(VulkanCommandPool* command_pool,
+                                         bool primary)
+    : primary_(primary), command_pool_(command_pool) {
+  command_pool_->IncrementCommandBufferCount();
+}
+
+VulkanCommandBuffer::~VulkanCommandBuffer() {
+  DCHECK_EQ(static_cast<VkCommandBuffer>(VK_NULL_HANDLE), command_buffer_);
+  DCHECK_EQ(static_cast<VkFence>(VK_NULL_HANDLE), submission_fence_);
+  DCHECK(!recording_);
+  command_pool_->DecrementCommandBufferCount();
+}
+
+bool VulkanCommandBuffer::Initialize() {
+  VkResult result = VK_SUCCESS;
+  VkDevice device = GetVulkanDevice();
+
+  VkCommandBufferAllocateInfo command_buffer_info = {};
+  command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  command_buffer_info.commandPool = command_pool_->handle();
+  command_buffer_info.level = primary_ ? VK_COMMAND_BUFFER_LEVEL_PRIMARY
+                                       : VK_COMMAND_BUFFER_LEVEL_SECONDARY;
+  command_buffer_info.commandBufferCount = 1;
+
+  result =
+      vkAllocateCommandBuffers(device, &command_buffer_info, &command_buffer_);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkAllocateCommandBuffers() failed: " << result;
+    return false;
+  }
+
+  VkFenceCreateInfo fence_create_info = {};
+  fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+  fence_create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;

[piman, 2016/03/29 19:09:21]

I don't think you want it to be created signaled, if you initialize in
"RECORD_TYPE_EMPTY" state, because ResetIfDirty will skip waiting in that case -
so you'll have a signalled fence when you submit (which is illegal, and
incorrect anyway).

[David Yen, 2016/03/29 19:27:31]

That's interesting that my tests passed. Maybe validation would have caught it?
I will add validation layers on the next patch.

Having it signaled makes some things very convenient though (for example being
able to always call SubmissionFinished() such as my DCHECK in the destroy).
Maybe we should reset the fence before submission instead? That would make the
behavior of Wait() and SubmissionFinished() slightly different, but I can change
the comments to reflect that.

[piman, 2016/03/29 20:42:39]

I think they would have caught it.
Another option is to add one more state, RECORD_TYPE_SUBMITTED. Wait could
return immediately except in that state, and SubmissionFinished would return
true. Either one would transition to RECORD_TYPE_DIRTY after the fence is
passed, and reset the fence. ResetIfDirty could call Wait(infinite) and then
reset the command buffer if dirty.

[David Yen, 2016/03/29 21:26:42]

It kind of is already like that already, but because of the state tracking we
have 2 for the submission state: RECORD_TYPE_RECORDED for multi use and DIRTY
for single use, although DIRTY is also used when the command buffer is cleared.
I think keeping the current state is simplest to understand and only adds one
extra reset for the very first submission. The fence reset would just be a
client side function right?

+
+  result =
+      vkCreateFence(device, &fence_create_info, nullptr, &submission_fence_);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkCreateFence(submission) failed: " << result;
+    return false;
+  }
+
+  record_type_ = RECORD_TYPE_EMPTY;
+  return true;
+}
+
+void VulkanCommandBuffer::Destroy() {
+  VkDevice device = GetVulkanDevice();
+  if (VK_NULL_HANDLE != submission_fence_) {
+    DCHECK(SubmissionFinished());
+    vkDestroyFence(device, submission_fence_, nullptr);
+    submission_fence_ = VK_NULL_HANDLE;
+  }
+
+  if (VK_NULL_HANDLE != command_buffer_) {
+    vkFreeCommandBuffers(device, command_pool_->handle(), 1, &command_buffer_);
+    command_buffer_ = VK_NULL_HANDLE;
+  }
+}
+
+bool VulkanCommandBuffer::Submit(VkQueue queue,
+                                 uint32_t num_wait_semaphores,
+                                 VkSemaphore* wait_semaphores,
+                                 uint32_t num_signal_semaphores,
+                                 VkSemaphore* signal_semaphores) {
+  DCHECK(primary_);
+  VkSubmitInfo submit_info = {};
+  submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+  submit_info.commandBufferCount = 1;
+  submit_info.pCommandBuffers = &command_buffer_;
+  submit_info.waitSemaphoreCount = num_wait_semaphores;
+  submit_info.pWaitSemaphores = wait_semaphores;
+  submit_info.signalSemaphoreCount = num_signal_semaphores;
+  submit_info.pSignalSemaphores = signal_semaphores;
+
+  VkResult result = vkQueueSubmit(queue, 1, &submit_info, submission_fence_);

[piman, 2016/03/29 19:09:21]

Thought for later (nothing to do in this CL, it's big enough as it is): we may
want at some point to submit several command buffers at once - the submit
overhead is high on at least some platforms (Windows in particular). When we get
to that, we'll need to share the fence across command buffers. It could be
something along the lines of: the fence is owned by the image data in the swap
chain, and it's given to the command buffer after the multi-submit.

[David Yen, 2016/03/29 19:27:31]

Would we want to submit multiple command buffers which setup render passes?
Otherwise we can submit multiple secondary command buffers within a single
primary command buffer right?

[piman, 2016/03/29 20:42:39]

Possibly. For example, we'll need one render pass per tile we raster. It could
make sense to create those on multiple threads, which will require separate
command buffers.
The other things are non-render things, such as texture upload, which don't go
into render passes.

+  PostExecution();
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkQueueSubmit() failed: " << result;
+    return false;
+  }
+
+  return true;
+}
+
+void VulkanCommandBuffer::Enqueue(VkCommandBuffer primary_command_buffer) {
+  DCHECK(!primary_);
+  vkCmdExecuteCommands(primary_command_buffer, 1, &command_buffer_);
+  PostExecution();
+}
+
+void VulkanCommandBuffer::Clear() {
+  // Mark to reset upon next use.
+  if (record_type_ != RECORD_TYPE_EMPTY)
+    record_type_ = RECORD_TYPE_DIRTY;
+}
+
+void VulkanCommandBuffer::Wait(uint64_t timeout) {
+  vkWaitForFences(GetVulkanDevice(), 1, &submission_fence_, true, timeout);
+}
+
+bool VulkanCommandBuffer::SubmissionFinished() {
+  return VK_SUCCESS == vkGetFenceStatus(GetVulkanDevice(), submission_fence_);
+}
+
+void VulkanCommandBuffer::PostExecution() {
+  if (record_type_ == RECORD_TYPE_SINGLE_USE) {
+    // Clear upon next use.
+    record_type_ = RECORD_TYPE_DIRTY;
+  } else if (record_type_ == RECORD_TYPE_MULTI_USE) {
+    // Can no longer record new items unless marked as clear.
+    record_type_ = RECORD_TYPE_RECORDED;
+  }
+}
+
+void VulkanCommandBuffer::ResetIfDirty() {
+  DCHECK(!recording_);
+  if (record_type_ == RECORD_TYPE_DIRTY) {
+    // Block if command buffer is still in use. This can be externally avoided
+    // using the asynchronous SubmissionFinished() function.
+    vkWaitForFences(GetVulkanDevice(), 1, &submission_fence_, true, UINT64_MAX);
+    vkResetFences(GetVulkanDevice(), 1, &submission_fence_);
+
+    vkResetCommandBuffer(command_buffer_, 0);
+    record_type_ = RECORD_TYPE_EMPTY;
+  }
+}
+
+CommandBufferRecorderBase::~CommandBufferRecorderBase() {
+  vkEndCommandBuffer(handle_);
+};
+
+ScopedMultiUseCommandBufferRecorder::ScopedMultiUseCommandBufferRecorder(
+    VulkanCommandBuffer& command_buffer)
+    : CommandBufferRecorderBase(command_buffer) {
+  ValidateMultiUse(command_buffer);
+  VkCommandBufferBeginInfo begin_info = {};
+  begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  vkBeginCommandBuffer(handle_, &begin_info);
+}
+
+ScopedSingleUseCommandBufferRecorder::ScopedSingleUseCommandBufferRecorder(
+    VulkanCommandBuffer& command_buffer)
+    : CommandBufferRecorderBase(command_buffer) {
+  ValidateSingleUse(command_buffer);
+  VkCommandBufferBeginInfo begin_info = {};
+  begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+  vkBeginCommandBuffer(handle_, &begin_info);
+}
+
+}  // namespace gpu