Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- createValidationCacheEXT :: forall io. MonadIO io => Device -> ValidationCacheCreateInfoEXT -> ("allocator" ::: Maybe AllocationCallbacks) -> io ValidationCacheEXT
- withValidationCacheEXT :: forall r. Device -> ValidationCacheCreateInfoEXT -> Maybe AllocationCallbacks -> (ValidationCacheEXT -> IO r) -> IO r
- destroyValidationCacheEXT :: forall io. MonadIO io => Device -> ValidationCacheEXT -> ("allocator" ::: Maybe AllocationCallbacks) -> io ()
- getValidationCacheDataEXT :: forall io. MonadIO io => Device -> ValidationCacheEXT -> io (Result, "data" ::: ByteString)
- mergeValidationCachesEXT :: forall io. MonadIO io => Device -> ("dstCache" ::: ValidationCacheEXT) -> ("srcCaches" ::: Vector ValidationCacheEXT) -> io ()
- data ValidationCacheCreateInfoEXT = ValidationCacheCreateInfoEXT {}
- data ShaderModuleValidationCacheCreateInfoEXT = ShaderModuleValidationCacheCreateInfoEXT {}
- newtype ValidationCacheCreateFlagsEXT = ValidationCacheCreateFlagsEXT Flags
- newtype ValidationCacheHeaderVersionEXT where
- type EXT_VALIDATION_CACHE_SPEC_VERSION = 1
- pattern EXT_VALIDATION_CACHE_SPEC_VERSION :: forall a. Integral a => a
- type EXT_VALIDATION_CACHE_EXTENSION_NAME = "VK_EXT_validation_cache"
- pattern EXT_VALIDATION_CACHE_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
- newtype ValidationCacheEXT = ValidationCacheEXT Word64
Documentation
createValidationCacheEXT :: forall io. MonadIO io => Device -> ValidationCacheCreateInfoEXT -> ("allocator" ::: Maybe AllocationCallbacks) -> io ValidationCacheEXT Source #
vkCreateValidationCacheEXT - Creates a new validation cache
Parameters
device
is the logical device that creates the validation cache object.
pCreateInfo
is a pointer to aValidationCacheCreateInfoEXT
structure containing the initial parameters for the validation cache object.pAllocator
controls host memory allocation as described in the Memory Allocation chapter.pValidationCache
is a pointer to aValidationCacheEXT
handle in which the resulting validation cache object is returned.
Description
Note
Applications can track and manage the total host memory size of a
validation cache object using the pAllocator
. Applications can limit
the amount of data retrieved from a validation cache object in
getValidationCacheDataEXT
. Implementations should not internally
limit the total number of entries added to a validation cache object or
the total host memory consumed.
Once created, a validation cache can be passed to the
createShaderModule
command by adding
this object to the
ShaderModuleCreateInfo
structure’s
pNext
chain. If a ShaderModuleValidationCacheCreateInfoEXT
object is
included in the
ShaderModuleCreateInfo
::pNext
chain,
and its validationCache
field is not
NULL_HANDLE
, the implementation
will query it for possible reuse opportunities and update it with new
content. The use of the validation cache object in these commands is
internally synchronized, and the same validation 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
createShaderModule
command.
Valid Usage (Implicit)
device
must be a validDevice
handle
pCreateInfo
must be a valid pointer to a validValidationCacheCreateInfoEXT
structure- If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure pValidationCache
must be a valid pointer to aValidationCacheEXT
handle
Return Codes
See Also
AllocationCallbacks
,
Device
, ValidationCacheCreateInfoEXT
,
ValidationCacheEXT
withValidationCacheEXT :: forall r. Device -> ValidationCacheCreateInfoEXT -> Maybe AllocationCallbacks -> (ValidationCacheEXT -> IO r) -> IO r Source #
A safe wrapper for createValidationCacheEXT
and
destroyValidationCacheEXT
using bracket
The allocated value must not be returned from the provided computation
destroyValidationCacheEXT :: forall io. MonadIO io => Device -> ValidationCacheEXT -> ("allocator" ::: Maybe AllocationCallbacks) -> io () Source #
vkDestroyValidationCacheEXT - Destroy a validation cache object
Parameters
device
is the logical device that destroys the validation cache object.
validationCache
is the handle of the validation cache to destroy.pAllocator
controls host memory allocation as described in the Memory Allocation chapter.
Valid Usage
- If
AllocationCallbacks
were provided whenvalidationCache
was created, a compatible set of callbacks must be provided here
- If no
AllocationCallbacks
were provided whenvalidationCache
was created,pAllocator
must beNULL
Valid Usage (Implicit)
device
must be a validDevice
handle
- If
validationCache
is notNULL_HANDLE
,validationCache
must be a validValidationCacheEXT
handle - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure - If
validationCache
is a valid handle, it must have been created, allocated, or retrieved fromdevice
Host Synchronization
- Host access to
validationCache
must be externally synchronized
See Also
getValidationCacheDataEXT :: forall io. MonadIO io => Device -> ValidationCacheEXT -> io (Result, "data" ::: ByteString) Source #
vkGetValidationCacheDataEXT - Get the data store from a validation cache
Parameters
device
is the logical device that owns the validation cache.
validationCache
is the validation cache to retrieve data from.pDataSize
is a pointer to a value related to the amount of data in the validation cache, as described below.pData
is eitherNULL
or a pointer to a buffer.
Description
If pData
is NULL
, then the maximum size of the data that can be
retrieved from the validation 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 validation cache, at most pDataSize
bytes will be written to
pData
, and getValidationCacheDataEXT
will return
INCOMPLETE
. Any data written to
pData
is valid and can be provided as the pInitialData
member of
the ValidationCacheCreateInfoEXT
structure passed to
createValidationCacheEXT
.
Two calls to getValidationCacheDataEXT
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 validation cache,
and use these data, possibly in a future run of the application, to
populate new validation cache objects. The results of validation,
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 validation cache header written as a stream of bytes, with the least significant byte first |
4 | 4 | a ValidationCacheHeaderVersionEXT value
written as a stream of bytes, with the least
significant byte first |
8 | UUID_SIZE
| a layer commit ID expressed as a UUID, which uniquely identifies the version of the validation layers used to generate these validation results |
Layout for validation cache header version
VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
The first four bytes encode the length of the entire validation cache header, in bytes. This value includes all fields in the header including the validation cache version field and the size of the length field.
The next four bytes encode the validation cache version, as described
for ValidationCacheHeaderVersionEXT
. A consumer of the validation
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
validationCache
must be a validValidationCacheEXT
handlepDataSize
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 validationCache
must have been created, allocated, or retrieved fromdevice
Return Codes
See Also
mergeValidationCachesEXT :: forall io. MonadIO io => Device -> ("dstCache" ::: ValidationCacheEXT) -> ("srcCaches" ::: Vector ValidationCacheEXT) -> io () Source #
vkMergeValidationCachesEXT - Combine the data stores of validation caches
Parameters
device
is the logical device that owns the validation cache objects.
dstCache
is the handle of the validation cache to merge results into.srcCacheCount
is the length of thepSrcCaches
array.pSrcCaches
is a pointer to an array of validation cache handles, which will be merged intodstCache
. The previous contents ofdstCache
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 validation caches and prune duplicate entries.
Valid Usage
dstCache
must not appear in the list of source caches
Valid Usage (Implicit)
device
must be a validDevice
handle
dstCache
must be a validValidationCacheEXT
handlepSrcCaches
must be a valid pointer to an array ofsrcCacheCount
validValidationCacheEXT
handlessrcCacheCount
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 ValidationCacheCreateInfoEXT Source #
VkValidationCacheCreateInfoEXT - Structure specifying parameters of a newly created validation cache
Valid Usage
- If
initialDataSize
is not0
, it must be equal to the size ofpInitialData
, as returned bygetValidationCacheDataEXT
whenpInitialData
was originally retrieved
- If
initialDataSize
is not0
,pInitialData
must have been retrieved from a previous call togetValidationCacheDataEXT
Valid Usage (Implicit)
sType
must beSTRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
pNext
must beNULL
flags
must be0
- If
initialDataSize
is not0
,pInitialData
must be a valid pointer to an array ofinitialDataSize
bytes
See Also
StructureType
,
ValidationCacheCreateFlagsEXT
, createValidationCacheEXT
ValidationCacheCreateInfoEXT | |
|
Instances
data ShaderModuleValidationCacheCreateInfoEXT Source #
VkShaderModuleValidationCacheCreateInfoEXT - Specify validation cache to use during shader module creation
Valid Usage (Implicit)
See Also
ShaderModuleValidationCacheCreateInfoEXT | |
|
Instances
newtype ValidationCacheCreateFlagsEXT Source #
VkValidationCacheCreateFlagsEXT - Reserved for future use
Description
ValidationCacheCreateFlagsEXT
is a bitmask type for setting a mask,
but is currently reserved for future use.
See Also
Instances
newtype ValidationCacheHeaderVersionEXT Source #
VkValidationCacheHeaderVersionEXT - Encode validation cache version
See Also
pattern VALIDATION_CACHE_HEADER_VERSION_ONE_EXT :: ValidationCacheHeaderVersionEXT |
|
Instances
type EXT_VALIDATION_CACHE_SPEC_VERSION = 1 Source #
pattern EXT_VALIDATION_CACHE_SPEC_VERSION :: forall a. Integral a => a Source #
type EXT_VALIDATION_CACHE_EXTENSION_NAME = "VK_EXT_validation_cache" Source #
pattern EXT_VALIDATION_CACHE_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a Source #
newtype ValidationCacheEXT Source #
VkValidationCacheEXT - Opaque handle to a validation cache object
See Also
ShaderModuleValidationCacheCreateInfoEXT
,
createValidationCacheEXT
,
destroyValidationCacheEXT
,
getValidationCacheDataEXT
,
mergeValidationCachesEXT