blob: 5f345256e34b515e7b1692b59ba5dd007a21174c [file] [log] [blame]
// 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 "base/logging.h"
#include "gpu/vulkan/vulkan_command_pool.h"
#include "gpu/vulkan/vulkan_device_queue.h"
#include "gpu/vulkan/vulkan_implementation.h"
namespace gpu {
VulkanCommandBuffer::VulkanCommandBuffer(VulkanDeviceQueue* device_queue,
VulkanCommandPool* command_pool,
bool primary)
: primary_(primary),
device_queue_(device_queue),
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 = device_queue_->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;
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 = device_queue_->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(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 = VK_SUCCESS;
result =
vkResetFences(device_queue_->GetVulkanDevice(), 1, &submission_fence_);
if (VK_SUCCESS != result) {
DLOG(ERROR) << "vkResetFences() failed: " << result;
return false;
}
result = vkQueueSubmit(device_queue_->GetVulkanQueue(), 1, &submit_info,
submission_fence_);
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) {
VkDevice device = device_queue_->GetVulkanDevice();
vkWaitForFences(device, 1, &submission_fence_, true, timeout);
}
bool VulkanCommandBuffer::SubmissionFinished() {
VkDevice device = device_queue_->GetVulkanDevice();
return VK_SUCCESS == vkGetFenceStatus(device, 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.
VkDevice device = device_queue_->GetVulkanDevice();
vkWaitForFences(device, 1, &submission_fence_, true, UINT64_MAX);
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