Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- createPipelineCache :: forall io. MonadIO io => Device -> PipelineCacheCreateInfo -> ("allocator" ::: Maybe AllocationCallbacks) -> io PipelineCache
- withPipelineCache :: forall io r. MonadIO io => Device -> PipelineCacheCreateInfo -> Maybe AllocationCallbacks -> (io PipelineCache -> (PipelineCache -> io ()) -> r) -> r
- destroyPipelineCache :: forall io. MonadIO io => Device -> PipelineCache -> ("allocator" ::: Maybe AllocationCallbacks) -> io ()
- getPipelineCacheData :: forall io. MonadIO io => Device -> PipelineCache -> io (Result, "data" ::: ByteString)
- mergePipelineCaches :: forall io. MonadIO io => Device -> ("dstCache" ::: PipelineCache) -> ("srcCaches" ::: Vector PipelineCache) -> io ()
- data PipelineCacheCreateInfo = PipelineCacheCreateInfo {}
- newtype PipelineCache = PipelineCache Word64
- newtype PipelineCacheCreateFlagBits where
- type PipelineCacheCreateFlags = PipelineCacheCreateFlagBits
Documentation
:: forall io. MonadIO io | |
=> Device |
|
-> PipelineCacheCreateInfo |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io PipelineCache |
vkCreatePipelineCache - Creates a new pipeline cache
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
getPipelineCacheData
. 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
createGraphicsPipelines
createRayTracingPipelinesKHR
,
createRayTracingPipelinesNV
, and
createComputePipelines
commands. If the
pipeline cache passed into these commands is not
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.
If flags
of pCreateInfo
includes
PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
,
all commands that modify the returned pipeline cache object must be
externally synchronized.
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 vkCreate*Pipelines
commands.
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
pCreateInfo
must be a valid pointer to a validPipelineCacheCreateInfo
structure - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure -
pPipelineCache
must be a valid pointer to aPipelineCache
handle
Return Codes
See Also
AllocationCallbacks
,
Device
, PipelineCache
,
PipelineCacheCreateInfo
withPipelineCache :: forall io r. MonadIO io => Device -> PipelineCacheCreateInfo -> Maybe AllocationCallbacks -> (io PipelineCache -> (PipelineCache -> io ()) -> r) -> r Source #
A convenience wrapper to make a compatible pair of calls to
createPipelineCache
and destroyPipelineCache
To ensure that destroyPipelineCache
is always called: pass
bracket
(or the allocate function from your
favourite resource management library) as the last argument.
To just extract the pair pass (,)
as the last argument.
:: forall io. MonadIO io | |
=> Device |
|
-> PipelineCache |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io () |
vkDestroyPipelineCache - Destroy a pipeline cache object
Valid Usage
- If
AllocationCallbacks
were provided whenpipelineCache
was created, a compatible set of callbacks must be provided here
- If no
AllocationCallbacks
were provided whenpipelineCache
was created,pAllocator
must beNULL
Valid Usage (Implicit)
-
device
must be a validDevice
handle
- If
pipelineCache
is notNULL_HANDLE
,pipelineCache
must be a validPipelineCache
handle - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure - If
pipelineCache
is a valid handle, it must have been created, allocated, or retrieved fromdevice
Host Synchronization
- Host access to
pipelineCache
must be externally synchronized
See Also
:: forall io. MonadIO io | |
=> Device |
|
-> PipelineCache |
|
-> io (Result, "data" ::: ByteString) |
vkGetPipelineCacheData - Get the data store from a pipeline cache
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 getPipelineCacheData
will return
INCOMPLETE
. Any data written to pData
is
valid and can be provided as the pInitialData
member of the
PipelineCacheCreateInfo
structure passed to createPipelineCache
.
Two calls to getPipelineCacheData
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:
Offset | Size | Meaning |
---|---|---|
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 PipelineCacheHeaderVersion
value written as a stream of bytes, with the least significant byte first |
8 | 4 | a vendor ID equal to
PhysicalDeviceProperties ::vendorID written
as a stream of bytes, with the least significant byte first |
12 | 4 | a device ID equal to
PhysicalDeviceProperties ::deviceID written
as a stream of bytes, with the least significant byte first |
16 | UUID_SIZE
| a pipeline cache ID equal to
PhysicalDeviceProperties ::pipelineCacheUUID |
Layout for pipeline cache header version
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
PipelineCacheHeaderVersion
.
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 validDevice
handle
-
pipelineCache
must be a validPipelineCache
handle -
pDataSize
must be a valid pointer to asize_t
value - If the value
referenced by
pDataSize
is not0
, andpData
is notNULL
,pData
must be a valid pointer to an array ofpDataSize
bytes -
pipelineCache
must have been created, allocated, or retrieved fromdevice
Return Codes
See Also
:: forall io. MonadIO io | |
=> Device |
|
-> ("dstCache" ::: PipelineCache) |
|
-> ("srcCaches" ::: Vector PipelineCache) |
|
-> io () |
vkMergePipelineCaches - Combine the data stores of pipeline caches
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
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
dstCache
must be a validPipelineCache
handle -
pSrcCaches
must be a valid pointer to an array ofsrcCacheCount
validPipelineCache
handles -
srcCacheCount
must be greater than0
-
dstCache
must have been created, allocated, or retrieved fromdevice
- Each element of
pSrcCaches
must have been created, allocated, or retrieved fromdevice
Host Synchronization
- Host access to
dstCache
must be externally synchronized
Return Codes
See Also
data PipelineCacheCreateInfo Source #
VkPipelineCacheCreateInfo - Structure specifying parameters of a newly created pipeline cache
Valid Usage
- If
initialDataSize
is not0
, it must be equal to the size ofpInitialData
, as returned bygetPipelineCacheData
whenpInitialData
was originally retrieved
- If
initialDataSize
is not0
,pInitialData
must have been retrieved from a previous call togetPipelineCacheData
-
If the
pipelineCreationCacheControl
feature is not enabled,
flags
must not includePIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
Valid Usage (Implicit)
-
sType
must beSTRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
-
pNext
must beNULL
-
flags
must be a valid combination ofPipelineCacheCreateFlagBits
values - If
initialDataSize
is not0
,pInitialData
must be a valid pointer to an array ofinitialDataSize
bytes
See Also
PipelineCacheCreateFlags
,
StructureType
, createPipelineCache
PipelineCacheCreateInfo | |
|
Instances
newtype PipelineCache Source #
VkPipelineCache - Opaque handle to a pipeline cache object
See Also
createComputePipelines
,
createGraphicsPipelines
,
createPipelineCache
,
createRayTracingPipelinesKHR
,
createRayTracingPipelinesNV
,
destroyPipelineCache
,
getPipelineCacheData
,
mergePipelineCaches
Instances
newtype PipelineCacheCreateFlagBits Source #
VkPipelineCacheCreateFlagBits - Bitmask specifying the behavior of the pipeline cache
See Also
pattern PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT :: PipelineCacheCreateFlagBits |
|