Remove support for VkSemaphore

backends/vulkan/runtime/api/Context.cpp

@@ -38,8 +38,7 @@ Context::Context(vkapi::Adapter* adapter, const ContextConfig& config)
       querypool_(config_.query_pool_config, nullptr),
       // Command buffer submission
       cmd_mutex_{},
-      cmd_(VK_NULL_HANDLE, VK_NULL_HANDLE, 0u),
-      prev_semaphore_(VK_NULL_HANDLE),
+      cmd_(VK_NULL_HANDLE, 0u),
       submit_count_{0u},
       // Memory Management
       buffer_clearlist_mutex_{},
@@ -196,21 +195,14 @@ void Context::register_blit(
 }
 
 void Context::submit_cmd_to_gpu(VkFence fence_handle, const bool final_use) {
-  // Wait semaphore would be previous command buffer's signal semaphore
-  VkSemaphore wait_semaphore = prev_semaphore_;
-  // Signal semaphore for the the current command buffer
-  VkSemaphore signal_semaphore = cmd_.get_signal_semaphore();
-  // Next command buffer would wait on this command buffer's signal semaphore
-  prev_semaphore_ = signal_semaphore;
-
   if (cmd_) {
     cmd_.end();
     adapter_p_->submit_cmd(
         queue_,
         cmd_.get_submit_handle(final_use),
         fence_handle,
-        wait_semaphore,
-        signal_semaphore);
+        VK_NULL_HANDLE,
+        VK_NULL_HANDLE);
 
     submit_count_ = 0u;
   }
@@ -226,8 +218,6 @@ void Context::flush() {
   if (cmd_) {
     cmd_.invalidate();
   }
-  // Reset previous command buffer semaphore
-  prev_semaphore_ = VK_NULL_HANDLE;
 
   std::lock_guard<std::mutex> bufferlist_lock(buffer_clearlist_mutex_);
   std::lock_guard<std::mutex> imagelist_lock(image_clearlist_mutex_);

backends/vulkan/runtime/api/Context.h

@@ -68,8 +68,6 @@ class Context final {
   // Command buffers submission
   std::mutex cmd_mutex_;
   vkapi::CommandBuffer cmd_;
-  // Semaphore for the previously submitted command buffer, if any
-  VkSemaphore prev_semaphore_;
   uint32_t submit_count_;
   // Memory Management
   std::mutex buffer_clearlist_mutex_;

backends/vulkan/runtime/graph/ComputeGraph.cpp

@@ -776,36 +776,22 @@ void ComputeGraph::submit_current_cmd_and_wait(const bool final_use) {
   context_->fences().return_fence(fence);
 }
 
-void ComputeGraph::submit_cmd(
-    vkapi::CommandBuffer& cmd_buf,
-    VkSemaphore wait_semaphore,
-    VkSemaphore signal_semaphore,
-    VkFence fence) {
+void ComputeGraph::submit_cmd(vkapi::CommandBuffer& cmd_buf, VkFence fence) {
   if (cmd_buf) {
     cmd_buf.end();
     context_->adapter_ptr()->submit_cmd(
-        context_->queue(),
-        cmd_buf.get_submit_handle(false),
-        fence,
-        wait_semaphore,
-        signal_semaphore);
+        context_->queue(), cmd_buf.get_submit_handle(false), fence);
   }
 }
 
 void ComputeGraph::submit_deferred_cmds_and_wait() {
-  VkSemaphore prev_semaphore = VK_NULL_HANDLE;
   vkapi::VulkanFence fence = context_->fences().get_fence();
 
   for (uint32_t i = 0; i < deferred_cmd_list_.size(); i++) {
     auto& cmd = deferred_cmd_list_[i];
-    VkSemaphore wait_semaphore = prev_semaphore;
-    VkSemaphore signal_semaphore = cmd.get_signal_semaphore();
-    prev_semaphore = signal_semaphore;
 
     submit_cmd(
         cmd,
-        wait_semaphore,
-        signal_semaphore,
         i == (deferred_cmd_list_.size() - 1) ? fence.get_submit_handle()
                                              : VK_NULL_HANDLE);
   }

backends/vulkan/runtime/graph/ComputeGraph.h

@@ -857,11 +857,7 @@ class ComputeGraph final {
   /*
    * Submit one command buffer to the GPU.
    */
-  void submit_cmd(
-      vkapi::CommandBuffer& cmd_buf,
-      VkSemaphore wait_semaphore,
-      VkSemaphore signal_semaphore,
-      VkFence fence);
+  void submit_cmd(vkapi::CommandBuffer& cmd_buf, VkFence fence);
 
   /*
    * Submits all the commands gathered in deferred_cmd_bufs_ to the GPU.

backends/vulkan/runtime/vk_api/Command.cpp

@@ -20,34 +20,28 @@ namespace vkapi {
 
 CommandBuffer::CommandBuffer(
     VkCommandBuffer handle,
-    VkSemaphore semaphore,
     const VkCommandBufferUsageFlags flags)
     : handle_(handle),
-      signal_semaphore_(semaphore),
       flags_(flags),
       state_(CommandBuffer::State::NEW),
       bound_{} {}
 
 CommandBuffer::CommandBuffer(CommandBuffer&& other) noexcept
     : handle_(other.handle_),
-      signal_semaphore_(other.signal_semaphore_),
       flags_(other.flags_),
       state_(other.state_),
       bound_(other.bound_) {
   other.handle_ = VK_NULL_HANDLE;
-  other.signal_semaphore_ = VK_NULL_HANDLE;
   other.bound_.reset();
 }
 
 CommandBuffer& CommandBuffer::operator=(CommandBuffer&& other) noexcept {
   handle_ = other.handle_;
-  signal_semaphore_ = other.signal_semaphore_;
   flags_ = other.flags_;
   state_ = other.state_;
   bound_ = other.bound_;
 
   other.handle_ = VK_NULL_HANDLE;
-  other.signal_semaphore_ = VK_NULL_HANDLE;
   other.bound_.reset();
   other.state_ = CommandBuffer::State::INVALID;
 
@@ -310,12 +304,6 @@ CommandPool::~CommandPool() {
   if (pool_ == VK_NULL_HANDLE) {
     return;
   }
-  for (auto& semaphore : semaphores_) {
-    if (semaphore != VK_NULL_HANDLE) {
-      vkDestroySemaphore(device_, semaphore, nullptr);
-    }
-  }
-
   vkDestroyCommandPool(device_, pool_, nullptr);
 }
 
@@ -326,15 +314,14 @@ CommandBuffer CommandPool::get_new_cmd(bool reusable) {
   allocate_new_batch(config_.cmd_pool_batch_size);
 
   VkCommandBuffer handle = buffers_[in_use_];
-  VkSemaphore semaphore = semaphores_[in_use_];
 
   VkCommandBufferUsageFlags cmd_flags = 0u;
   if (!reusable) {
     cmd_flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
   }
 
   in_use_++;
-  return CommandBuffer(handle, semaphore, cmd_flags);
+  return CommandBuffer(handle, cmd_flags);
 }
 
 void CommandPool::flush() {
@@ -350,7 +337,6 @@ void CommandPool::allocate_new_batch(const uint32_t count) {
   }
 
   buffers_.resize(buffers_.size() + count);
-  semaphores_.resize(buffers_.size() + count);
 
   const VkCommandBufferAllocateInfo allocate_info{
       VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
@@ -362,17 +348,6 @@ void CommandPool::allocate_new_batch(const uint32_t count) {
 
   VK_CHECK(vkAllocateCommandBuffers(
       device_, &allocate_info, buffers_.data() + in_use_));
-
-  const VkSemaphoreCreateInfo semaphoreCreateInfo = {
-      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0};
-
-  for (uint32_t i = 0; i < count; i++) {
-    VK_CHECK(vkCreateSemaphore(
-        device_,
-        &semaphoreCreateInfo,
-        nullptr,
-        semaphores_.data() + in_use_ + i));
-  }
 }
 
 } // namespace vkapi

backends/vulkan/runtime/vk_api/Command.h

@@ -26,10 +26,7 @@ namespace vkapi {
 
 class CommandBuffer final {
  public:
-  explicit CommandBuffer(
-      VkCommandBuffer,
-      VkSemaphore,
-      const VkCommandBufferUsageFlags);
+  explicit CommandBuffer(VkCommandBuffer, const VkCommandBufferUsageFlags);
 
   CommandBuffer(const CommandBuffer&) = delete;
   CommandBuffer& operator=(const CommandBuffer&) = delete;
@@ -73,8 +70,6 @@ class CommandBuffer final {
 
  private:
   VkCommandBuffer handle_;
-  // Semaphore to signal when the command buffer has completed execution
-  VkSemaphore signal_semaphore_;
   VkCommandBufferUsageFlags flags_;
   State state_;
   Bound bound_;
@@ -86,7 +81,6 @@ class CommandBuffer final {
 
   inline void invalidate() {
     handle_ = VK_NULL_HANDLE;
-    signal_semaphore_ = VK_NULL_HANDLE;
     bound_.reset();
   }
 
@@ -106,10 +100,6 @@ class CommandBuffer final {
 
   VkCommandBuffer get_submit_handle(const bool final_use = false);
 
-  VkSemaphore get_signal_semaphore() const {
-    return signal_semaphore_;
-  }
-
   inline operator bool() const {
     return handle_ != VK_NULL_HANDLE;
   }
@@ -140,8 +130,6 @@ class CommandPool final {
   // New Buffers
   std::mutex mutex_;
   std::vector<VkCommandBuffer> buffers_;
-  // Semaphores corresponding to the command buffers
-  std::vector<VkSemaphore> semaphores_;
   size_t in_use_;
 
  public: