Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Name
VK_NV_cuda_kernel_launch - device extension
VK_NV_cuda_kernel_launch
- Name String
VK_NV_cuda_kernel_launch
- Extension Type
- Device extension
- Registered Extension Number
- 308
- Revision
- 2
- Ratification Status
- Not ratified
- Extension and Version Dependencies
- __This is a provisional extension and must be used with caution. See the description of provisional header files for enablement and stability details.__
- Contact
Other Extension Metadata
- Last Modified Date
- 2020-09-30
- Contributors
- Eric Werness, NVIDIA
Description
Interoperability between APIs can sometimes create additional overhead depending on the platform used. This extension targets deployment of existing CUDA kernels via Vulkan, with a way to directly upload PTX kernels and dispatch the kernels from Vulkan’s command buffer without the need to use interoperability between the Vulkan and CUDA contexts. However, we do encourage actual development using the native CUDA runtime for the purpose of debugging and profiling.
The application will first have to create a CUDA module using
createCudaModuleNV
then create the CUDA function entry point with
createCudaFunctionNV
.
Then in order to dispatch this function, the application will create a
command buffer where it will launch the kernel with
cmdCudaLaunchKernelNV
.
When done, the application will then destroy the function handle, as
well as the CUDA module handle with destroyCudaFunctionNV
and
destroyCudaModuleNV
.
To reduce the impact of compilation time, this extension offers the
capability to return a binary cache from the PTX that was provided. For
this, a first query for the required cache size is made with
getCudaModuleCacheNV
with a NULL
pointer to a buffer and with a
valid pointer receiving the size; then another call of the same function
with a valid pointer to a buffer to retrieve the data. The resulting
cache could then be user later for further runs of this application by
sending this cache instead of the PTX code (using the same
createCudaModuleNV
), thus significantly speeding up the initialization
of the CUDA module.
As with PipelineCache
, the binary cache depends
on the hardware architecture. Therefore the application must assume the
cache might fail, and thus need to handle falling back to the original
PTX code as necessary. Most often, the cache will succeed if the same
GPU driver and architecture is used between the cache generation from
PTX and the use of this cache. But most often, in the event of a new
driver version or a if using a different GPU But in the event of a new
driver version or if using a different GPU architecture, the cache is
likely to become invalid.
New Object Types
New Commands
New Structures
CudaLaunchInfoNV
CudaModuleCreateInfoNV
Extending
PhysicalDeviceFeatures2
,DeviceCreateInfo
:Extending
PhysicalDeviceProperties2
:
New Enum Constants
NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION
Extending
DebugReportObjectTypeEXT
:Extending
ObjectType
:Extending
StructureType
:
Issues
None.
Version History
- Revision 1, 2020-03-01 (Tristan Lorach)
- Revision 2, 2020-09-30 (Tristan Lorach)
See Also
CudaFunctionCreateInfoNV
, CudaFunctionNV
,
CudaLaunchInfoNV
, CudaModuleCreateInfoNV
,
CudaModuleNV
,
PhysicalDeviceCudaKernelLaunchFeaturesNV
,
PhysicalDeviceCudaKernelLaunchPropertiesNV
, cmdCudaLaunchKernelNV
,
createCudaFunctionNV
, createCudaModuleNV
, destroyCudaFunctionNV
,
destroyCudaModuleNV
, getCudaModuleCacheNV
Document Notes
For more information, see the Vulkan Specification
This page is a generated document. Fixes and changes should be made to the generator scripts, not directly.
Synopsis
- createCudaModuleNV :: forall io. MonadIO io => Device -> CudaModuleCreateInfoNV -> ("allocator" ::: Maybe AllocationCallbacks) -> io CudaModuleNV
- withCudaModuleNV :: forall io r. MonadIO io => Device -> CudaModuleCreateInfoNV -> Maybe AllocationCallbacks -> (io CudaModuleNV -> (CudaModuleNV -> io ()) -> r) -> r
- getCudaModuleCacheNV :: forall io. MonadIO io => Device -> CudaModuleNV -> io (Result, "cacheData" ::: ByteString)
- createCudaFunctionNV :: forall io. MonadIO io => Device -> CudaFunctionCreateInfoNV -> ("allocator" ::: Maybe AllocationCallbacks) -> io CudaFunctionNV
- withCudaFunctionNV :: forall io r. MonadIO io => Device -> CudaFunctionCreateInfoNV -> Maybe AllocationCallbacks -> (io CudaFunctionNV -> (CudaFunctionNV -> io ()) -> r) -> r
- destroyCudaModuleNV :: forall io. MonadIO io => Device -> CudaModuleNV -> ("allocator" ::: Maybe AllocationCallbacks) -> io ()
- destroyCudaFunctionNV :: forall io. MonadIO io => Device -> CudaFunctionNV -> ("allocator" ::: Maybe AllocationCallbacks) -> io ()
- cmdCudaLaunchKernelNV :: forall io. MonadIO io => CommandBuffer -> CudaLaunchInfoNV -> io ()
- data CudaModuleCreateInfoNV = CudaModuleCreateInfoNV {}
- data CudaFunctionCreateInfoNV = CudaFunctionCreateInfoNV {}
- data CudaLaunchInfoNV = CudaLaunchInfoNV {}
- data PhysicalDeviceCudaKernelLaunchFeaturesNV = PhysicalDeviceCudaKernelLaunchFeaturesNV {}
- data PhysicalDeviceCudaKernelLaunchPropertiesNV = PhysicalDeviceCudaKernelLaunchPropertiesNV {}
- type NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION = 2
- pattern NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION :: forall a. Integral a => a
- type NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME = "VK_NV_cuda_kernel_launch"
- pattern NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
- newtype CudaModuleNV = CudaModuleNV Word64
- newtype CudaFunctionNV = CudaFunctionNV Word64
- newtype DebugReportObjectTypeEXT where
- DebugReportObjectTypeEXT Int32
- pattern DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT :: DebugReportObjectTypeEXT
- pattern DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT :: DebugReportObjectTypeEXT
Documentation
:: forall io. MonadIO io | |
=> Device |
|
-> CudaModuleCreateInfoNV |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io CudaModuleNV |
vkCreateCudaModuleNV - Creates a new CUDA module object
Description
Once a CUDA module has been created, you may create the function entry point that must refer to one function in the module.
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
pCreateInfo
must be a valid pointer to a validCudaModuleCreateInfoNV
structure - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure -
pModule
must be a valid pointer to aCudaModuleNV
handle
Return Codes
See Also
VK_NV_cuda_kernel_launch,
AllocationCallbacks
,
CudaModuleCreateInfoNV
, CudaModuleNV
,
Device
withCudaModuleNV :: forall io r. MonadIO io => Device -> CudaModuleCreateInfoNV -> Maybe AllocationCallbacks -> (io CudaModuleNV -> (CudaModuleNV -> io ()) -> r) -> r Source #
A convenience wrapper to make a compatible pair of calls to
createCudaModuleNV
and destroyCudaModuleNV
To ensure that destroyCudaModuleNV
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 |
|
-> CudaModuleNV |
|
-> io (Result, "cacheData" ::: ByteString) |
vkGetCudaModuleCacheNV - Get CUDA module cache
Valid Usage
-
pCacheSize
must be a pointer containing the amount of bytes to be copied inpCacheData
. IfpCacheData
is NULL, the function will return in this pointer the total amount of bytes required to later perform the copy intopCacheData
.
-
pCacheData
may be a pointer to a buffer in which the binary cache will be copied. The amount of bytes copied is defined by the value inpCacheSize
. This pointer may be NULL. In this case, the function will write the total amount of required data inpCacheSize
.
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
module
must be a validCudaModuleNV
handle -
pCacheSize
must be a valid pointer to asize_t
value - If the value
referenced by
pCacheSize
is not0
, andpCacheData
is notNULL
,pCacheData
must be a valid pointer to an array ofpCacheSize
bytes -
module
must have been created, allocated, or retrieved fromdevice
Return Codes
See Also
:: forall io. MonadIO io | |
=> Device |
|
-> CudaFunctionCreateInfoNV |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io CudaFunctionNV |
vkCreateCudaFunctionNV - Creates a new CUDA function object
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
pCreateInfo
must be a valid pointer to a validCudaFunctionCreateInfoNV
structure - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure -
pFunction
must be a valid pointer to aCudaFunctionNV
handle
Return Codes
See Also
VK_NV_cuda_kernel_launch,
AllocationCallbacks
,
CudaFunctionCreateInfoNV
, CudaFunctionNV
,
Device
withCudaFunctionNV :: forall io r. MonadIO io => Device -> CudaFunctionCreateInfoNV -> Maybe AllocationCallbacks -> (io CudaFunctionNV -> (CudaFunctionNV -> io ()) -> r) -> r Source #
A convenience wrapper to make a compatible pair of calls to
createCudaFunctionNV
and destroyCudaFunctionNV
To ensure that destroyCudaFunctionNV
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 |
|
-> CudaModuleNV |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io () |
vkDestroyCudaModuleNV - Destroy a CUDA module
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
module
must be a validCudaModuleNV
handle - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure -
module
must have been created, allocated, or retrieved fromdevice
See Also
VK_NV_cuda_kernel_launch,
AllocationCallbacks
,
CudaModuleNV
, Device
destroyCudaFunctionNV Source #
:: forall io. MonadIO io | |
=> Device |
|
-> CudaFunctionNV |
|
-> ("allocator" ::: Maybe AllocationCallbacks) |
|
-> io () |
vkDestroyCudaFunctionNV - Destroy a CUDA function
Valid Usage (Implicit)
-
device
must be a validDevice
handle
-
function
must be a validCudaFunctionNV
handle - If
pAllocator
is notNULL
,pAllocator
must be a valid pointer to a validAllocationCallbacks
structure -
function
must have been created, allocated, or retrieved fromdevice
See Also
VK_NV_cuda_kernel_launch,
AllocationCallbacks
,
CudaFunctionNV
,
Device
cmdCudaLaunchKernelNV Source #
:: forall io. MonadIO io | |
=> CommandBuffer |
|
-> CudaLaunchInfoNV |
|
-> io () |
vkCmdCudaLaunchKernelNV - Dispatch compute work items
Description
When the command is executed, a global workgroup consisting of
gridDimX
× gridDimY
× gridDimZ
local workgroups is assembled.
Valid Usage (Implicit)
-
commandBuffer
must be a validCommandBuffer
handle
-
pLaunchInfo
must be a valid pointer to a validCudaLaunchInfoNV
structure -
commandBuffer
must be in the recording state - The
CommandPool
thatcommandBuffer
was allocated from must support graphics, or compute operations - This command must only be called outside of a video coding scope
Host Synchronization
- Host access to the
CommandPool
thatcommandBuffer
was allocated from must be externally synchronized
Command Properties
'
Command Buffer Levels | Render Pass Scope | Video Coding Scope | Supported Queue Types | Command Type |
---|---|---|---|---|
Primary Secondary | Both | Outside | Graphics Compute | Action |
See Also
data CudaModuleCreateInfoNV Source #
VkCudaModuleCreateInfoNV - Structure specifying the parameters to create a CUDA Module
Valid Usage (Implicit)
See Also
Instances
data CudaFunctionCreateInfoNV Source #
VkCudaFunctionCreateInfoNV - Structure specifying the parameters to create a CUDA Function
Valid Usage (Implicit)
See Also
VK_NV_cuda_kernel_launch,
CudaModuleNV
,
StructureType
,
createCudaFunctionNV
CudaFunctionCreateInfoNV | |
|
Instances
Show CudaFunctionCreateInfoNV Source # | |
Defined in Vulkan.Extensions.VK_NV_cuda_kernel_launch showsPrec :: Int -> CudaFunctionCreateInfoNV -> ShowS # show :: CudaFunctionCreateInfoNV -> String # showList :: [CudaFunctionCreateInfoNV] -> ShowS # | |
FromCStruct CudaFunctionCreateInfoNV Source # | |
ToCStruct CudaFunctionCreateInfoNV Source # | |
Defined in Vulkan.Extensions.VK_NV_cuda_kernel_launch withCStruct :: CudaFunctionCreateInfoNV -> (Ptr CudaFunctionCreateInfoNV -> IO b) -> IO b Source # pokeCStruct :: Ptr CudaFunctionCreateInfoNV -> CudaFunctionCreateInfoNV -> IO b -> IO b Source # withZeroCStruct :: (Ptr CudaFunctionCreateInfoNV -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr CudaFunctionCreateInfoNV -> IO b -> IO b Source # cStructSize :: Int Source # | |
Zero CudaFunctionCreateInfoNV Source # | |
data CudaLaunchInfoNV Source #
VkCudaLaunchInfoNV - Structure specifying the parameters to launch a CUDA kernel
Valid Usage
-
gridDimX
must be less than or equal toPhysicalDeviceLimits
::maxComputeWorkGroupCount
[0]
-
gridDimY
must be less than or equal toPhysicalDeviceLimits
::maxComputeWorkGroupCount
[1] -
gridDimZ
must be less than or equal toPhysicalDeviceLimits
::maxComputeWorkGroupCount
[2] -
paramCount
must be the total amount of parameters listed in thepParams
table. -
pParams
must be a pointer to a table ofparamCount
parameters, corresponding to the arguments offunction
. -
extraCount
must be 0 -
pExtras
must be NULL
Valid Usage (Implicit)
-
sType
must beSTRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV
-
pNext
must beNULL
-
function
must be a validCudaFunctionNV
handle - If
paramCount
is not0
,pParams
must be a valid pointer to an array ofparamCount
bytes - If
extraCount
is not0
,pExtras
must be a valid pointer to an array ofextraCount
bytes
See Also
VK_NV_cuda_kernel_launch,
CudaFunctionNV
,
StructureType
,
cmdCudaLaunchKernelNV
CudaLaunchInfoNV | |
|
Instances
Show CudaLaunchInfoNV Source # | |
Defined in Vulkan.Extensions.VK_NV_cuda_kernel_launch showsPrec :: Int -> CudaLaunchInfoNV -> ShowS # show :: CudaLaunchInfoNV -> String # showList :: [CudaLaunchInfoNV] -> ShowS # | |
FromCStruct CudaLaunchInfoNV Source # | |
ToCStruct CudaLaunchInfoNV Source # | |
Defined in Vulkan.Extensions.VK_NV_cuda_kernel_launch withCStruct :: CudaLaunchInfoNV -> (Ptr CudaLaunchInfoNV -> IO b) -> IO b Source # pokeCStruct :: Ptr CudaLaunchInfoNV -> CudaLaunchInfoNV -> IO b -> IO b Source # withZeroCStruct :: (Ptr CudaLaunchInfoNV -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr CudaLaunchInfoNV -> IO b -> IO b Source # cStructSize :: Int Source # | |
Zero CudaLaunchInfoNV Source # | |
Defined in Vulkan.Extensions.VK_NV_cuda_kernel_launch |
data PhysicalDeviceCudaKernelLaunchFeaturesNV Source #
VkPhysicalDeviceCudaKernelLaunchFeaturesNV - Structure describing whether cuda kernel launch is supported by the implementation
Members
This structure describes the following features:
Description
If the PhysicalDeviceCudaKernelLaunchFeaturesNV
structure is included
in the pNext
chain of the
PhysicalDeviceFeatures2
structure passed to
getPhysicalDeviceFeatures2
,
it is filled in to indicate whether each corresponding feature is
supported. PhysicalDeviceCudaKernelLaunchFeaturesNV
can also be used
in the pNext
chain of DeviceCreateInfo
to
selectively enable these features.
Valid Usage (Implicit)
See Also
Instances
data PhysicalDeviceCudaKernelLaunchPropertiesNV Source #
VkPhysicalDeviceCudaKernelLaunchPropertiesNV - Structure describing the compute capability version available
Members
The members of the PhysicalDeviceCudaKernelLaunchPropertiesNV
structure describe the following features:
Description
If the PhysicalDeviceCudaKernelLaunchPropertiesNV
structure is
included in the pNext
chain of the
PhysicalDeviceProperties2
structure passed to
getPhysicalDeviceProperties2
,
it is filled in with each corresponding implementation-dependent
property.
Valid Usage (Implicit)
See Also
Instances
type NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION = 2 Source #
pattern NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION :: forall a. Integral a => a Source #
type NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME = "VK_NV_cuda_kernel_launch" Source #
pattern NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a Source #
newtype CudaModuleNV Source #
VkCudaModuleNV - Opaque handle to a CUDA module object
See Also
VK_NV_cuda_kernel_launch,
CudaFunctionCreateInfoNV
,
createCudaModuleNV
,
destroyCudaModuleNV
,
getCudaModuleCacheNV
Instances
newtype CudaFunctionNV Source #
VkCudaFunctionNV - Opaque handle to a CUDA function object
See Also
VK_NV_cuda_kernel_launch,
CudaLaunchInfoNV
,
createCudaFunctionNV
,
destroyCudaFunctionNV
Instances
newtype DebugReportObjectTypeEXT Source #
VkDebugReportObjectTypeEXT - Specify the type of an object handle
Description
'
DebugReportObjectTypeEXT
and Vulkan Handle Relationship
Note
The primary expected use of
ERROR_VALIDATION_FAILED_EXT
is for
validation layer testing. It is not expected that an application would
see this error code during normal use of the validation layers.
See Also
VK_EXT_debug_marker,
VK_EXT_debug_report,
DebugMarkerObjectNameInfoEXT
,
DebugMarkerObjectTagInfoEXT
,
debugReportMessageEXT