| // Copyright 2026 The Fuchsia 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 "src/ui/lib/escher/impl/semaphore_pool.h" | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <type_traits> | |
| #include "src/ui/lib/escher/impl/vulkan_utils.h" | |
| #include "src/ui/lib/escher/util/fuchsia_utils.h" | |
| #include "src/ui/lib/escher/util/trace_macros.h" | |
| namespace escher { | |
| static_assert(Semaphore::kInvalidKoid == ZX_KOID_INVALID); | |
| static_assert(std::is_same_v<zx_koid_t, uint64_t>); | |
| SemaphorePool::SemaphorePool(vk::Device device, vk::detail::DispatchLoaderDynamic dispatch_loader) | |
| : device_(device), dispatch_loader_(dispatch_loader) {} | |
| SemaphorePool::~SemaphorePool() { | |
| FX_DCHECK(outstanding_semaphores_ == 0) | |
| << "SemaphorePool destroyed with " << outstanding_semaphores_ | |
| << " outstanding semaphores still in use!"; | |
| // SemaphorePtr objects are destroyed with the free list vectors, which drops their ref count | |
| // to zero. This triggers Semaphore::OnZeroRefCount() which will attempt to return the semaphore | |
| // to a partially destroyed pool, if its pool_ pointer is not cleared. | |
| for (auto& sem : cleaned_free_list_) { | |
| sem->pool_ = nullptr; | |
| } | |
| for (auto& sem : uncleaned_free_list_) { | |
| sem->pool_ = nullptr; | |
| } | |
| } | |
| SemaphorePtr SemaphorePool::Allocate() { | |
| ++outstanding_semaphores_; | |
| // Prefer pulling an already-clean semaphore from the cleaned list to achieve 0 imports on | |
| // the critical path. | |
| if (!cleaned_free_list_.empty()) { | |
| auto sem = std::move(cleaned_free_list_.back()); | |
| cleaned_free_list_.pop_back(); | |
| return sem; | |
| } | |
| // Fall back to the uncleaned list and perform a lazy clean to guarantee it is safe before reuse. | |
| if (!uncleaned_free_list_.empty()) { | |
| auto sem = std::move(uncleaned_free_list_.back()); | |
| uncleaned_free_list_.pop_back(); | |
| zx::event cleaning_event = CreateEvent(); | |
| vk::ImportSemaphoreZirconHandleInfoFUCHSIA info; | |
| info.semaphore = sem->vk_semaphore(); | |
| info.zirconHandle = cleaning_event.release(); | |
| info.handleType = vk::ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA; | |
| { | |
| TRACE_DURATION("gfx", | |
| "SemaphorePool::Allocate[importSemaphoreZirconHandleFUCHSIA] (cleaning)"); | |
| ESCHER_CHECKED_VK_RESULT(device_.importSemaphoreZirconHandleFUCHSIA(info, dispatch_loader_)); | |
| } | |
| return sem; | |
| } | |
| // Pool is completely empty; allocate a brand new semaphore. | |
| return Semaphore::New(device_, this); | |
| } | |
| SemaphorePtr SemaphorePool::AllocateAndImport(zx::event event_to_import) { | |
| ++outstanding_semaphores_; | |
| // Prefer pulling from the uncleaned list because the subsequent import will naturally | |
| // overwrite and clean it, avoiding a double-import. | |
| SemaphorePtr sem; | |
| if (!uncleaned_free_list_.empty()) { | |
| sem = std::move(uncleaned_free_list_.back()); | |
| uncleaned_free_list_.pop_back(); | |
| } else if (!cleaned_free_list_.empty()) { | |
| sem = std::move(cleaned_free_list_.back()); | |
| cleaned_free_list_.pop_back(); | |
| } else { | |
| sem = Semaphore::New(device_, this); | |
| } | |
| const zx_koid_t koid = GetEventKoid(event_to_import); | |
| vk::ImportSemaphoreZirconHandleInfoFUCHSIA info; | |
| info.semaphore = sem->vk_semaphore(); | |
| info.zirconHandle = event_to_import.release(); | |
| info.handleType = vk::ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA; | |
| { | |
| TRACE_DURATION("gfx", "SemaphorePool::AllocateAndImport[importSemaphoreZirconHandleFUCHSIA]"); | |
| ESCHER_CHECKED_VK_RESULT(device_.importSemaphoreZirconHandleFUCHSIA(info, dispatch_loader_)); | |
| } | |
| sem->set_koid(koid); | |
| return sem; | |
| } | |
| void SemaphorePool::ReturnSemaphore(SemaphorePtr semaphore) { | |
| --outstanding_semaphores_; | |
| // If the semaphore previously required an import, we return it directly to the uncleaned list. | |
| // Semaphores with previous imports will likely be required to import a Zircon event again | |
| // when reused, so it makes sense not to clean them here. | |
| if (semaphore->is_imported()) { | |
| // Reset the KOID (and derived `is_imported()` state) during retirement so that if this | |
| // semaphore is later lazy-cleaned and returned by `Allocate()` as an unimported semaphore, it | |
| // does not carry a stale KOID. | |
| semaphore->set_koid(Semaphore::kInvalidKoid); | |
| uncleaned_free_list_.push_back(std::move(semaphore)); | |
| return; | |
| } | |
| // If the semaphore did not previously import a Zircon event, it is "cleaned" with a fresh | |
| // Zircon event to guarantee it is unsignaled and returned to the cleaned list. | |
| zx::event cleaning_event = CreateEvent(); | |
| vk::ImportSemaphoreZirconHandleInfoFUCHSIA info; | |
| info.semaphore = semaphore->vk_semaphore(); | |
| info.zirconHandle = cleaning_event.release(); | |
| info.handleType = vk::ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA; | |
| { | |
| TRACE_DURATION("gfx", | |
| "SemaphorePool::ReturnSemaphore[importSemaphoreZirconHandleFUCHSIA] (cleaning)"); | |
| ESCHER_CHECKED_VK_RESULT(device_.importSemaphoreZirconHandleFUCHSIA(info, dispatch_loader_)); | |
| } | |
| cleaned_free_list_.push_back(std::move(semaphore)); | |
| } | |
| } // namespace escher |