Graphics.Vulkan.Extensions.VK_KHR_external_fence_fd

Documentation

pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR :: VkStructureType

pattern VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR :: VkStructureType

pattern VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION :: Integral a => a

pattern VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: (Eq a, IsString a) => a

vkGetFenceFdKHR :: ("device" ::: VkDevice) -> ("pGetFdInfo" ::: Ptr VkFenceGetFdInfoKHR) -> ("pFd" ::: Ptr CInt) -> IO VkResult

vkGetFenceFdKHR - Get a POSIX file descriptor handle for a fence

Parameters

• device is the logical device that created the fence being exported.

• pGetFdInfo is a pointer to an instance of the VkFenceGetFdInfoKHR structure containing parameters of the export operation.
• pFd will return the file descriptor representing the fence payload.

Description

Each call to vkGetFenceFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor when it is no longer needed.

Note

Ownership can be released in many ways. For example, the application can call close() on the file descriptor, or transfer ownership back to Vulkan by using the file descriptor to import a fence payload.

If pGetFdInfo::handleType is VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT and the fence is signaled at the time vkGetFenceFdKHR is called, pFd may return the value -1 instead of a valid file descriptor.

Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Exporting a file descriptor from a fence may have side effects depending on the transference of the specified handle type, as described in Importing Fence State.

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure
• pFd must be a valid pointer to a int value

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_TOO_MANY_OBJECTS

• VK_ERROR_OUT_OF_HOST_MEMORY

See Also

VkDevice, VkFenceGetFdInfoKHR

vkImportFenceFdKHR :: ("device" ::: VkDevice) -> ("pImportFenceFdInfo" ::: Ptr VkImportFenceFdInfoKHR) -> IO VkResult

vkImportFenceFdKHR - Import a fence from a POSIX file descriptor

Parameters

• device is the logical device that created the fence.

• pImportFenceFdInfo points to a VkImportFenceFdInfoKHR structure specifying the fence and import parameters.

Description

Importing a fence payload from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Applications can import the same fence payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage

• fence must not be associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_INVALID_EXTERNAL_HANDLE

See Also

VkDevice, VkImportFenceFdInfoKHR

data VkImportFenceFdInfoKHR

VkImportFenceFdInfoKHR - (None)

Description

The handle types supported by handleType are:

+-----------------------+-----------------------+-----------------------+
| Handle Type           | Transference          | Permanence Supported  |
+=======================+=======================+=======================+
| @VK_EXTERNAL_FENCE_HA | Reference             | Temporary,Permanent   |
| NDLE_TYPE_OPAQUE_FD_B |                       |                       |
| IT@                   |                       |                       |
+-----------------------+-----------------------+-----------------------+
| @VK_EXTERNAL_FENCE_HA | Copy                  | Temporary             |
| NDLE_TYPE_SYNC_FD_BIT |                       |                       |
| @                     |                       |                       |
+-----------------------+-----------------------+-----------------------+

Handle Types Supported by VkImportFenceFdInfoKHR

Valid Usage

• handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table.

• fd must obey any requirements listed for handleType in external fence handle types compatibility.

If handleType is VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, the special value -1 for fd is treated like a valid sync file descriptor referring to an object that has already signaled. The import operation will succeed and the VkFence will have a temporarily imported payload as if a valid file descriptor had been provided.

Note

This special behavior for importing an invalid sync file descriptor allows easier interoperability with other system APIs which use the convention that an invalid sync file descriptor represents work that has already completed and doesn’t need to be waited for. It is consistent with the option for implementations to return a -1 file descriptor when exporting a VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT from a VkFence which is signaled.

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR

• pNext must be NULL
• fence must be a valid VkFence handle
• flags must be a valid combination of VkFenceImportFlagBits values
• handleType must be a valid VkExternalFenceHandleTypeFlagBits value

Host Synchronization

• Host access to fence must be externally synchronized

See Also

VkExternalFenceHandleTypeFlagBits, VkFence, VkFenceImportFlags, VkStructureType, vkImportFenceFdKHR

Constructors

VkImportFenceFdInfoKHR

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkFence :: VkFence

  fence is the fence into which the payload will be imported.

• vkFlags :: VkFenceImportFlags

  flags is a bitmask of VkFenceImportFlagBits specifying additional parameters for the fence payload import operation.

• vkHandleType :: VkExternalFenceHandleTypeFlagBits

  handleType specifies the type of fd.

• vkFd :: CInt

  fd is the external handle to import.

Instances

Eq VkImportFenceFdInfoKHR

Methods

(==) :: VkImportFenceFdInfoKHR -> VkImportFenceFdInfoKHR -> Bool

(/=) :: VkImportFenceFdInfoKHR -> VkImportFenceFdInfoKHR -> Bool

Show VkImportFenceFdInfoKHR

Methods

showsPrec :: Int -> VkImportFenceFdInfoKHR -> ShowS

show :: VkImportFenceFdInfoKHR -> String

showList :: [VkImportFenceFdInfoKHR] -> ShowS

Storable VkImportFenceFdInfoKHR

Methods

sizeOf :: VkImportFenceFdInfoKHR -> Int

alignment :: VkImportFenceFdInfoKHR -> Int

peekElemOff :: Ptr VkImportFenceFdInfoKHR -> Int -> IO VkImportFenceFdInfoKHR

pokeElemOff :: Ptr VkImportFenceFdInfoKHR -> Int -> VkImportFenceFdInfoKHR -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkImportFenceFdInfoKHR

pokeByteOff :: Ptr b -> Int -> VkImportFenceFdInfoKHR -> IO ()

peek :: Ptr VkImportFenceFdInfoKHR -> IO VkImportFenceFdInfoKHR

poke :: Ptr VkImportFenceFdInfoKHR -> VkImportFenceFdInfoKHR -> IO ()

data VkFenceGetFdInfoKHR

VkFenceGetFdInfoKHR - Structure describing a POSIX FD fence export operation

Description

The properties of the file descriptor returned depend on the value of handleType. See VkExternalFenceHandleTypeFlagBits for a description of the properties of the defined external fence handle types.

Valid Usage

• handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence’s current payload was created.

• If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.
• fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType.
• handleType must be defined as a POSIX file descriptor handle.

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR

• pNext must be NULL
• fence must be a valid VkFence handle
• handleType must be a valid VkExternalFenceHandleTypeFlagBits value

See Also

VkExternalFenceHandleTypeFlagBits, VkFence, VkStructureType, vkGetFenceFdKHR

Constructors

VkFenceGetFdInfoKHR

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkFence :: VkFence

  fence is the fence from which state will be exported.

• vkHandleType :: VkExternalFenceHandleTypeFlagBits

  handleType is the type of handle requested.

Instances

Eq VkFenceGetFdInfoKHR

Methods

(==) :: VkFenceGetFdInfoKHR -> VkFenceGetFdInfoKHR -> Bool

(/=) :: VkFenceGetFdInfoKHR -> VkFenceGetFdInfoKHR -> Bool

Show VkFenceGetFdInfoKHR

Methods

showsPrec :: Int -> VkFenceGetFdInfoKHR -> ShowS

show :: VkFenceGetFdInfoKHR -> String

showList :: [VkFenceGetFdInfoKHR] -> ShowS

Storable VkFenceGetFdInfoKHR

Methods

sizeOf :: VkFenceGetFdInfoKHR -> Int

alignment :: VkFenceGetFdInfoKHR -> Int

peekElemOff :: Ptr VkFenceGetFdInfoKHR -> Int -> IO VkFenceGetFdInfoKHR

pokeElemOff :: Ptr VkFenceGetFdInfoKHR -> Int -> VkFenceGetFdInfoKHR -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkFenceGetFdInfoKHR

pokeByteOff :: Ptr b -> Int -> VkFenceGetFdInfoKHR -> IO ()

peek :: Ptr VkFenceGetFdInfoKHR -> IO VkFenceGetFdInfoKHR

poke :: Ptr VkFenceGetFdInfoKHR -> VkFenceGetFdInfoKHR -> IO ()