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.

	~ExternalSemaphoreVK ()

	ExternalSemaphoreVK (const ExternalSemaphoreVK &)=delete

ExternalSemaphoreVK &	operator= (const ExternalSemaphoreVK &)=delete

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

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

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 & )