A Vulkan semaphore that can be exported as a platform specific file descriptor. More...

#include <external_semaphore_vk.h>

Public Member Functions
	ExternalSemaphoreVK (const std::shared_ptr< Context > &context)
	Create a new un-signaled semaphore that can be exported as a sync file descriptor. More...

	~ExternalSemaphoreVK ()

	ExternalSemaphoreVK (const ExternalSemaphoreVK &)=delete

ExternalSemaphoreVK &	operator= (const ExternalSemaphoreVK &)=delete

bool	IsValid () const
	If a valid fence could be created. More...

fml::UniqueFD	CreateFD () const
	Create a new sync file descriptor for the underlying semaphore. More...

const vk::Semaphore &	GetHandle () const

const SharedHandleVK< vk::Semaphore > &	GetSharedHandle () const

Detailed Description

A Vulkan semaphore that can be exported as a platform specific file descriptor.

The semaphore are exported as sync file descriptors.

Warning: Only semaphore that have been signaled or have a single operation pending can be exported. Make sure to submit a fence signalling operation to a queue before attempted to obtain a file descriptor for the fence.

Definition at line 27 of file external_semaphore_vk.h.

Constructor & Destructor Documentation

◆ ExternalSemaphoreVK() [1/2]

impeller::ExternalSemaphoreVK::ExternalSemaphoreVK ( const std::shared_ptr< Context > & context )

explicit

Create a new un-signaled semaphore that can be exported as a sync file descriptor.

Parameters

[in] context The device context.

Definition at line 13 of file external_semaphore_vk.cc.

                                            {
   if (!context) {
     return;
   }
   vk::StructureChain<vk::SemaphoreCreateInfo, vk::ExportSemaphoreCreateInfoKHR>
       info;
  
   info.get<vk::ExportSemaphoreCreateInfoKHR>().handleTypes =
       vk::ExternalSemaphoreHandleTypeFlagBits::eSyncFd;
  
   const auto& context_vk = ContextVK::Cast(*context);
   auto [result, semaphore] =
       context_vk.GetDevice().createSemaphoreUnique(info.get());
   if (result != vk::Result::eSuccess) {
     VALIDATION_LOG << "Could not create external fence: "
                    << vk::to_string(result);
     return;
   }
  
   context_vk.SetDebugName(semaphore.get(), "ExternalSemaphoreSyncFD");
  
   semaphore_ = MakeSharedVK(std::move(semaphore));
 }

References impeller::BackendCast< ContextVK, Context >::Cast(), impeller::MakeSharedVK(), and VALIDATION_LOG.

◆ ~ExternalSemaphoreVK()

impeller::ExternalSemaphoreVK::~ExternalSemaphoreVK ( )

default

◆ ExternalSemaphoreVK() [2/2]

impeller::ExternalSemaphoreVK::ExternalSemaphoreVK ( const ExternalSemaphoreVK & )

delete

Member Function Documentation

◆ CreateFD()

fml::UniqueFD impeller::ExternalSemaphoreVK::CreateFD ( ) const

Create a new sync file descriptor for the underlying semaphore.

The semaphore must already be signaled or have a signal operation pending in a queue. There are no checks for this in the implementation and only Vulkan validation will catch such a misuse and undefined behavior.

Warning: Implementations are also allowed to return invalid file descriptors in case a semaphore has already been signaled. So it is not necessary an error to obtain an invalid descriptor from this call. For APIs that are meant to consume such descriptors, pass -1 as the file handle.

Since this call can return an invalid FD even in case of success, make sure to make the IsValid check before attempting to export a FD.

Returns: A (potentially invalid even in case of success) file descriptor.

Definition at line 44 of file external_semaphore_vk.cc.

                                                 {
   if (!IsValid()) {
     return {};
   }
   vk::SemaphoreGetFdInfoKHR info;
   info.semaphore = semaphore_->Get();
   info.handleType = vk::ExternalSemaphoreHandleTypeFlagBits::eSyncFd;
   auto [result, fd] =
       semaphore_->GetUniqueWrapper().getOwner().getSemaphoreFdKHR(info);
   if (result != vk::Result::eSuccess) {
     VALIDATION_LOG << "Could not export external fence FD: "
                    << vk::to_string(result);
     return {};
   }
   return fml::UniqueFD{fd};
 }

References IsValid(), and VALIDATION_LOG.

◆ GetHandle()

const vk::Semaphore & impeller::ExternalSemaphoreVK::GetHandle ( ) const

Definition at line 61 of file external_semaphore_vk.cc.

                                                         {
   return semaphore_->Get();
 }

◆ GetSharedHandle()

const SharedHandleVK< vk::Semaphore > & impeller::ExternalSemaphoreVK::GetSharedHandle ( ) const

Definition at line 65 of file external_semaphore_vk.cc.

           {
   return semaphore_;
 }

◆ IsValid()

bool impeller::ExternalSemaphoreVK::IsValid ( ) const

If a valid fence could be created.

Returns: True if valid, False otherwise.

Definition at line 40 of file external_semaphore_vk.cc.

                                         {
   return !!semaphore_;
 }

Referenced by CreateFD().

◆ operator=()

ExternalSemaphoreVK& impeller::ExternalSemaphoreVK::operator= ( const ExternalSemaphoreVK & )