Graphics.Vulkan.Extensions.VK_EXT_validation_cache

Documentation

newtype VkValidationCacheHeaderVersionEXT

VkValidationCacheHeaderVersionEXT - Encode validation cache version

See Also

UNKNOWN:vkCreateValdiationCacheEXT, vkGetValidationCacheDataEXT

Constructors

VkValidationCacheHeaderVersionEXT Int32

Instances

Eq VkValidationCacheHeaderVersionEXT

Methods

(==) :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> Bool

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

Ord VkValidationCacheHeaderVersionEXT

Methods

compare :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> Ordering

(<) :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> Bool

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

(>) :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> Bool

(>=) :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> Bool

max :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT

min :: VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT -> VkValidationCacheHeaderVersionEXT

Read VkValidationCacheHeaderVersionEXT

Methods

readsPrec :: Int -> ReadS VkValidationCacheHeaderVersionEXT

readList :: ReadS [VkValidationCacheHeaderVersionEXT]

readPrec :: ReadPrec VkValidationCacheHeaderVersionEXT

readListPrec :: ReadPrec [VkValidationCacheHeaderVersionEXT]

Show VkValidationCacheHeaderVersionEXT

Methods

showsPrec :: Int -> VkValidationCacheHeaderVersionEXT -> ShowS

show :: VkValidationCacheHeaderVersionEXT -> String

showList :: [VkValidationCacheHeaderVersionEXT] -> ShowS

Storable VkValidationCacheHeaderVersionEXT

Methods

sizeOf :: VkValidationCacheHeaderVersionEXT -> Int

alignment :: VkValidationCacheHeaderVersionEXT -> Int

peekElemOff :: Ptr VkValidationCacheHeaderVersionEXT -> Int -> IO VkValidationCacheHeaderVersionEXT

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

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

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

peek :: Ptr VkValidationCacheHeaderVersionEXT -> IO VkValidationCacheHeaderVersionEXT

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

pattern VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT :: VkValidationCacheHeaderVersionEXT

VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT specifies version one of the validation cache.

newtype VkValidationCacheCreateFlagsEXT

VkValidationCacheCreateFlagsEXT - Reserved for future use

Description

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

See Also

VkValidationCacheCreateInfoEXT

Constructors

VkValidationCacheCreateFlagsEXT VkFlags

Instances

Eq VkValidationCacheCreateFlagsEXT

Methods

(==) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool

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

Ord VkValidationCacheCreateFlagsEXT

Methods

compare :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Ordering

(<) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool

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

(>) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool

(>=) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool

max :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

min :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

Read VkValidationCacheCreateFlagsEXT

Methods

readsPrec :: Int -> ReadS VkValidationCacheCreateFlagsEXT

readList :: ReadS [VkValidationCacheCreateFlagsEXT]

readPrec :: ReadPrec VkValidationCacheCreateFlagsEXT

readListPrec :: ReadPrec [VkValidationCacheCreateFlagsEXT]

Show VkValidationCacheCreateFlagsEXT

Methods

showsPrec :: Int -> VkValidationCacheCreateFlagsEXT -> ShowS

show :: VkValidationCacheCreateFlagsEXT -> String

showList :: [VkValidationCacheCreateFlagsEXT] -> ShowS

Storable VkValidationCacheCreateFlagsEXT

Methods

sizeOf :: VkValidationCacheCreateFlagsEXT -> Int

alignment :: VkValidationCacheCreateFlagsEXT -> Int

peekElemOff :: Ptr VkValidationCacheCreateFlagsEXT -> Int -> IO VkValidationCacheCreateFlagsEXT

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

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

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

peek :: Ptr VkValidationCacheCreateFlagsEXT -> IO VkValidationCacheCreateFlagsEXT

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

Bits VkValidationCacheCreateFlagsEXT

Methods

(.&.) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

(.|.) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

xor :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

complement :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT

shift :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

rotate :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

zeroBits :: VkValidationCacheCreateFlagsEXT

bit :: Int -> VkValidationCacheCreateFlagsEXT

setBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

clearBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

complementBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

testBit :: VkValidationCacheCreateFlagsEXT -> Int -> Bool

bitSizeMaybe :: VkValidationCacheCreateFlagsEXT -> Maybe Int

bitSize :: VkValidationCacheCreateFlagsEXT -> Int

isSigned :: VkValidationCacheCreateFlagsEXT -> Bool

shiftL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

unsafeShiftL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

shiftR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

unsafeShiftR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

rotateL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

rotateR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT

popCount :: VkValidationCacheCreateFlagsEXT -> Int

FiniteBits VkValidationCacheCreateFlagsEXT

Methods

finiteBitSize :: VkValidationCacheCreateFlagsEXT -> Int

countLeadingZeros :: VkValidationCacheCreateFlagsEXT -> Int

countTrailingZeros :: VkValidationCacheCreateFlagsEXT -> Int

pattern VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT :: VkStructureType

pattern VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT :: VkStructureType

pattern VK_OBJECT_TYPE_VALIDATION_CACHE_EXT :: VkObjectType

pattern VK_EXT_VALIDATION_CACHE_SPEC_VERSION :: Integral a => a

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

pattern VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT :: VkDebugReportObjectTypeEXT

type VkValidationCacheEXT = Ptr VkValidationCacheEXT_T

VkValidationCacheEXT - Opaque handle to a validation cache object

Description

See Also

VkShaderModuleValidationCacheCreateInfoEXT, vkCreateValidationCacheEXT, vkDestroyValidationCacheEXT, vkGetValidationCacheDataEXT, vkMergeValidationCachesEXT

vkCreateValidationCacheEXT :: ("device" ::: VkDevice) -> ("pCreateInfo" ::: Ptr VkValidationCacheCreateInfoEXT) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> ("pValidationCache" ::: Ptr VkValidationCacheEXT) -> IO VkResult

vkCreateValidationCacheEXT - Creates a new validation cache

Parameters

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

• pCreateInfo is a pointer to a VkValidationCacheCreateInfoEXT structure that contains 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 a VkValidationCacheEXT 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 vkGetValidationCacheDataEXT. 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 vkCreateShaderModule command as part of the VkShaderModuleCreateInfo pNext chain. If a VkShaderModuleValidationCacheCreateInfoEXT object is part of the VkShaderModuleCreateInfo::pNext chain, and its validationCache field is not VK_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 vkCreateShaderModule command.

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
• pValidationCache must be a valid pointer to a VkValidationCacheEXT handle

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkValidationCacheCreateInfoEXT, VkValidationCacheEXT

vkDestroyValidationCacheEXT :: ("device" ::: VkDevice) -> ("validationCache" ::: VkValidationCacheEXT) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> IO ()

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.

Description

Valid Usage

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

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

Valid Usage (Implicit)

• device must be a valid VkDevice handle

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

Host Synchronization

• Host access to validationCache must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkValidationCacheEXT

vkGetValidationCacheDataEXT :: ("device" ::: VkDevice) -> ("validationCache" ::: VkValidationCacheEXT) -> ("pDataSize" ::: Ptr CSize) -> ("pData" ::: Ptr ()) -> IO VkResult

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 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 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 vkGetValidationCacheDataEXT will return VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkValidationCacheCreateInfoEXT structure passed to vkCreateValidationCacheEXT.

Two calls to vkGetValidationCacheDataEXT 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:

+----+--------------+--------------------------------------------------+
| Of | Size         | Meaning                                          |
| fs |              |                                                  |
| et |              |                                                  |
+====+==============+==================================================+
| 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 'VkValidationCacheHeaderVersionEXT' value      |
|    |              | written as a stream of bytes, with the least     |
|    |              | significant byte first                           |
+----+--------------+--------------------------------------------------+
| 8  | @VK_UUID_SIZ | a layer commit ID expressed as a UUID, which     |
|    | E@           | uniquely identifies the version of the           |
|    |              | validation layers used to generate these         |
|    |              | validation results                               |
+----+--------------+--------------------------------------------------+

Layout for validation cache header version
@VK_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 VkValidationCacheHeaderVersionEXT. 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 valid VkDevice handle

• validationCache must be a valid VkValidationCacheEXT 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
• validationCache 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, VkValidationCacheEXT

vkMergeValidationCachesEXT :: ("device" ::: VkDevice) -> ("dstCache" ::: VkValidationCacheEXT) -> ("srcCacheCount" ::: Word32) -> ("pSrcCaches" ::: Ptr VkValidationCacheEXT) -> IO VkResult

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 the pSrcCaches array.
• pSrcCaches is an array of validation 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 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 valid VkDevice handle

• dstCache must be a valid VkValidationCacheEXT handle
• pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT 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, VkValidationCacheEXT

data VkValidationCacheCreateInfoEXT

VkValidationCacheCreateInfoEXT - Structure specifying parameters of a newly created validation cache

Description

Valid Usage

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

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

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT

• 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

VkStructureType, VkValidationCacheCreateFlagsEXT, vkCreateValidationCacheEXT

Constructors

VkValidationCacheCreateInfoEXT

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

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

• vkFlags :: VkValidationCacheCreateFlagsEXT

  flags is reserved for future use.

• vkInitialDataSize :: CSize

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

• vkPInitialData :: Ptr ()

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

Instances

Eq VkValidationCacheCreateInfoEXT

Methods

(==) :: VkValidationCacheCreateInfoEXT -> VkValidationCacheCreateInfoEXT -> Bool

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

Show VkValidationCacheCreateInfoEXT

Methods

showsPrec :: Int -> VkValidationCacheCreateInfoEXT -> ShowS

show :: VkValidationCacheCreateInfoEXT -> String

showList :: [VkValidationCacheCreateInfoEXT] -> ShowS

Storable VkValidationCacheCreateInfoEXT

Methods

sizeOf :: VkValidationCacheCreateInfoEXT -> Int

alignment :: VkValidationCacheCreateInfoEXT -> Int

peekElemOff :: Ptr VkValidationCacheCreateInfoEXT -> Int -> IO VkValidationCacheCreateInfoEXT

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

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

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

peek :: Ptr VkValidationCacheCreateInfoEXT -> IO VkValidationCacheCreateInfoEXT

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

data VkShaderModuleValidationCacheCreateInfoEXT

VkShaderModuleValidationCacheCreateInfoEXT - Specify validation cache to use during shader module creation

Description

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT

• validationCache must be a valid VkValidationCacheEXT handle

See Also

VkStructureType, VkValidationCacheEXT

Constructors

VkShaderModuleValidationCacheCreateInfoEXT

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

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

• vkValidationCache :: VkValidationCacheEXT

  validationCache is the validation cache object from which the results of prior validation attempts will be written, and to which new validation results for this VkShaderModule will be written (if not already present).

Instances

Eq VkShaderModuleValidationCacheCreateInfoEXT

Methods

(==) :: VkShaderModuleValidationCacheCreateInfoEXT -> VkShaderModuleValidationCacheCreateInfoEXT -> Bool

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

Show VkShaderModuleValidationCacheCreateInfoEXT

Methods

showsPrec :: Int -> VkShaderModuleValidationCacheCreateInfoEXT -> ShowS

show :: VkShaderModuleValidationCacheCreateInfoEXT -> String

showList :: [VkShaderModuleValidationCacheCreateInfoEXT] -> ShowS

Storable VkShaderModuleValidationCacheCreateInfoEXT

Methods

sizeOf :: VkShaderModuleValidationCacheCreateInfoEXT -> Int

alignment :: VkShaderModuleValidationCacheCreateInfoEXT -> Int

peekElemOff :: Ptr VkShaderModuleValidationCacheCreateInfoEXT -> Int -> IO VkShaderModuleValidationCacheCreateInfoEXT

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

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

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

peek :: Ptr VkShaderModuleValidationCacheCreateInfoEXT -> IO VkShaderModuleValidationCacheCreateInfoEXT

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