Graphics.Vulkan.Core10.PipelineCache

Documentation

newtype VkPipelineCacheCreateFlags

VkPipelineCacheCreateFlags - Reserved for future use

Description

VkPipelineCacheCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

See Also

VkPipelineCacheCreateInfo

Constructors

VkPipelineCacheCreateFlags VkFlags

Instances

Eq VkPipelineCacheCreateFlags

Methods

(==) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool

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

Ord VkPipelineCacheCreateFlags

Methods

compare :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Ordering

(<) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool

(<=) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool

(>) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool

(>=) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool

max :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

min :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

Read VkPipelineCacheCreateFlags

Methods

readsPrec :: Int -> ReadS VkPipelineCacheCreateFlags

readList :: ReadS [VkPipelineCacheCreateFlags]

readPrec :: ReadPrec VkPipelineCacheCreateFlags

readListPrec :: ReadPrec [VkPipelineCacheCreateFlags]

Show VkPipelineCacheCreateFlags

Methods

showsPrec :: Int -> VkPipelineCacheCreateFlags -> ShowS

show :: VkPipelineCacheCreateFlags -> String

showList :: [VkPipelineCacheCreateFlags] -> ShowS

Storable VkPipelineCacheCreateFlags

Methods

sizeOf :: VkPipelineCacheCreateFlags -> Int

alignment :: VkPipelineCacheCreateFlags -> Int

peekElemOff :: Ptr VkPipelineCacheCreateFlags -> Int -> IO VkPipelineCacheCreateFlags

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

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

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

peek :: Ptr VkPipelineCacheCreateFlags -> IO VkPipelineCacheCreateFlags

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

Bits VkPipelineCacheCreateFlags

Methods

(.&.) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

(.|.) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

xor :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

complement :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags

shift :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

rotate :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

zeroBits :: VkPipelineCacheCreateFlags

bit :: Int -> VkPipelineCacheCreateFlags

setBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

clearBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

complementBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

testBit :: VkPipelineCacheCreateFlags -> Int -> Bool

bitSizeMaybe :: VkPipelineCacheCreateFlags -> Maybe Int

bitSize :: VkPipelineCacheCreateFlags -> Int

isSigned :: VkPipelineCacheCreateFlags -> Bool

shiftL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

unsafeShiftL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

shiftR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

unsafeShiftR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

rotateL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

rotateR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags

popCount :: VkPipelineCacheCreateFlags -> Int

FiniteBits VkPipelineCacheCreateFlags

Methods

finiteBitSize :: VkPipelineCacheCreateFlags -> Int

countLeadingZeros :: VkPipelineCacheCreateFlags -> Int

countTrailingZeros :: VkPipelineCacheCreateFlags -> Int

type VkPipelineCache = Ptr VkPipelineCache_T

VkPipelineCache - Opaque handle to a pipeline cache object

Description

See Also

vkCreateComputePipelines, vkCreateGraphicsPipelines, vkCreatePipelineCache, vkDestroyPipelineCache, vkGetPipelineCacheData, vkMergePipelineCaches

vkCreatePipelineCache :: ("device" ::: VkDevice) -> ("pCreateInfo" ::: Ptr VkPipelineCacheCreateInfo) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> ("pPipelineCache" ::: Ptr VkPipelineCache) -> IO VkResult

vkCreatePipelineCache - Creates a new pipeline cache

Parameters

• device is the logical device that creates the pipeline cache object.

• pCreateInfo is a pointer to a VkPipelineCacheCreateInfo structure that contains the initial parameters for the pipeline cache object.
• pAllocator controls host memory allocation as described in the Memory Allocation chapter.
• pPipelineCache is a pointer to a VkPipelineCache handle in which the resulting pipeline cache object is returned.

Description

Note

Applications can track and manage the total host memory size of a pipeline cache object using the pAllocator. Applications can limit the amount of data retrieved from a pipeline cache object in vkGetPipelineCacheData. Implementations should not internally limit the total number of entries added to a pipeline cache object or the total host memory consumed.

Once created, a pipeline cache can be passed to the vkCreateGraphicsPipelines and vkCreateComputePipelines commands. If the pipeline cache passed into these commands is not VK_NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the pipeline cache object in these commands is internally synchronized, and the same pipeline cache object can be used in multiple threads simultaneously.

Note

Implementations should make every effort to limit any critical sections to the actual accesses to the cache, which is expected to be significantly shorter than the duration of the vkCreateGraphicsPipelines and vkCreateComputePipelines commands.

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
• pPipelineCache must be a valid pointer to a VkPipelineCache handle

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkPipelineCache, VkPipelineCacheCreateInfo

vkDestroyPipelineCache :: ("device" ::: VkDevice) -> ("pipelineCache" ::: VkPipelineCache) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> IO ()

vkDestroyPipelineCache - Destroy a pipeline cache object

Parameters

• device is the logical device that destroys the pipeline cache object.

• pipelineCache is the handle of the pipeline cache to destroy.
• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage

• If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here

• If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
• If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

• Host access to pipelineCache must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkPipelineCache

vkGetPipelineCacheData :: ("device" ::: VkDevice) -> ("pipelineCache" ::: VkPipelineCache) -> ("pDataSize" ::: Ptr CSize) -> ("pData" ::: Ptr ()) -> IO VkResult

vkGetPipelineCacheData - Get the data store from a pipeline cache

Parameters

• device is the logical device that owns the pipeline cache.

• pipelineCache is the pipeline cache to retrieve data from.
• pDataSize is a pointer to a value related to the amount of data in the pipeline cache, as described below.
• pData is either NULL or a pointer to a buffer.

Description

If pData is NULL, then the maximum size of the data that can be retrieved from the pipeline cache, in bytes, is returned in pDataSize. Otherwise, pDataSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pData, and on return the variable is overwritten with the amount of data actually written to pData.

If pDataSize is less than the maximum size that can be retrieved by the pipeline cache, at most pDataSize bytes will be written to pData, and vkGetPipelineCacheData will return VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkPipelineCacheCreateInfo structure passed to vkCreatePipelineCache.

Two calls to vkGetPipelineCacheData with the same parameters must retrieve the same data unless a command that modifies the contents of the cache is called between them.

Applications can store the data retrieved from the pipeline cache, and use these data, possibly in a future run of the application, to populate new pipeline cache objects. The results of pipeline compiles, however, may depend on the vendor ID, device ID, driver version, and other details of the device. To enable applications to detect when previously retrieved data is incompatible with the device, the initial bytes written to pData must be a header consisting of the following members:

+----+--------------+--------------------------------------------------+
| Of | Size         | Meaning                                          |
| fs |              |                                                  |
| et |              |                                                  |
+====+==============+==================================================+
| 0  | 4            | length in bytes of the entire pipeline cache     |
|    |              | header written as a stream of bytes, with the    |
|    |              | least significant byte first                     |
+----+--------------+--------------------------------------------------+
| 4  | 4            | a                                                |
|    |              | 'Graphics.Vulkan.Core10.Constants.VkPipelineCach |
|    |              | eHeaderVersion'                                  |
|    |              | value written as a stream of bytes, with the     |
|    |              | least significant byte first                     |
+----+--------------+--------------------------------------------------+
| 8  | 4            | a vendor ID equal to                             |
|    |              | @VkPhysicalDeviceProperties@::@vendorID@ written |
|    |              | as a stream of bytes, with the least significant |
|    |              | byte first                                       |
+----+--------------+--------------------------------------------------+
| 12 | 4            | a device ID equal to                             |
|    |              | @VkPhysicalDeviceProperties@::@deviceID@ written |
|    |              | as a stream of bytes, with the least significant |
|    |              | byte first                                       |
+----+--------------+--------------------------------------------------+
| 16 | @VK_UUID_SIZ | a pipeline cache ID equal to                     |
|    | E@           | @VkPhysicalDeviceProperties@::@pipelineCacheUUID |
|    |              | @                                                |
+----+--------------+--------------------------------------------------+

Layout for pipeline cache header version
@VK_PIPELINE_CACHE_HEADER_VERSION_ONE@

The first four bytes encode the length of the entire pipeline cache header, in bytes. This value includes all fields in the header including the pipeline cache version field and the size of the length field.

The next four bytes encode the pipeline cache version, as described for VkPipelineCacheHeaderVersion. A consumer of the pipeline cache should use the cache version to interpret the remainder of the cache header.

If pDataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to pDataSize.

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pipelineCache must be a valid VkPipelineCache handle
• pDataSize must be a valid pointer to a size_t value
• If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
• pipelineCache must have been created, allocated, or retrieved from device

Return Codes

Success

- VK_SUCCESS

• VK_INCOMPLETE

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkDevice, VkPipelineCache

vkMergePipelineCaches :: ("device" ::: VkDevice) -> ("dstCache" ::: VkPipelineCache) -> ("srcCacheCount" ::: Word32) -> ("pSrcCaches" ::: Ptr VkPipelineCache) -> IO VkResult

vkMergePipelineCaches - Combine the data stores of pipeline caches

Parameters

• device is the logical device that owns the pipeline cache objects.

• dstCache is the handle of the pipeline cache to merge results into.
• srcCacheCount is the length of the pSrcCaches array.
• pSrcCaches is an array of pipeline cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.

Description

Note

The details of the merge operation are implementation dependent, but implementations should merge the contents of the specified pipelines and prune duplicate entries.

Valid Usage

• dstCache must not appear in the list of source caches

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• dstCache must be a valid VkPipelineCache handle
• pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles
• srcCacheCount must be greater than 0
• dstCache must have been created, allocated, or retrieved from device
• Each element of pSrcCaches must have been created, allocated, or retrieved from device

Host Synchronization

• Host access to dstCache must be externally synchronized

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkDevice, VkPipelineCache

data VkPipelineCacheCreateInfo

VkPipelineCacheCreateInfo - Structure specifying parameters of a newly created pipeline cache

Description

Valid Usage

• If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved

• If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO

• pNext must be NULL
• flags must be 0
• If initialDataSize is not 0, pInitialData must be a valid pointer to an array of initialDataSize bytes

See Also

VkPipelineCacheCreateFlags, VkStructureType, vkCreatePipelineCache

Constructors

VkPipelineCacheCreateInfo

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

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

• vkFlags :: VkPipelineCacheCreateFlags

  flags is reserved for future use.

• vkInitialDataSize :: CSize

  initialDataSize is the number of bytes in pInitialData. If initialDataSize is zero, the pipeline cache will initially be empty.

• vkPInitialData :: Ptr ()

  pInitialData is a pointer to previously retrieved pipeline cache data. If the pipeline cache data is incompatible (as defined below) with the device, the pipeline cache will be initially empty. If initialDataSize is zero, pInitialData is ignored.

Instances

Eq VkPipelineCacheCreateInfo

Methods

(==) :: VkPipelineCacheCreateInfo -> VkPipelineCacheCreateInfo -> Bool

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

Show VkPipelineCacheCreateInfo

Methods

showsPrec :: Int -> VkPipelineCacheCreateInfo -> ShowS

show :: VkPipelineCacheCreateInfo -> String

showList :: [VkPipelineCacheCreateInfo] -> ShowS

Storable VkPipelineCacheCreateInfo

Methods

sizeOf :: VkPipelineCacheCreateInfo -> Int

alignment :: VkPipelineCacheCreateInfo -> Int

peekElemOff :: Ptr VkPipelineCacheCreateInfo -> Int -> IO VkPipelineCacheCreateInfo

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

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

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

peek :: Ptr VkPipelineCacheCreateInfo -> IO VkPipelineCacheCreateInfo

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