Safe Haskell | None |
---|---|
Language | Haskell2010 |
Name
VK_KHR_performance_query - device extension
VK_KHR_performance_query
- Name String
VK_KHR_performance_query
- Extension Type
- Device extension
- Registered Extension Number
- 117
- Revision
- 1
- Extension and Version Dependencies
- Requires Vulkan 1.0
- Requires
VK_KHR_get_physical_device_properties2
- Special Use
- Contact
Other Extension Metadata
- Last Modified Date
- 2019-10-08
- IP Status
- No known IP claims.
- Contributors
- Jesse Barker, Unity Technologies
- Kenneth Benzie, Codeplay
- Jan-Harald Fredriksen, ARM
- Jeff Leger, Qualcomm
- Jesse Hall, Google
- Tobias Hector, AMD
- Neil Henning, Codeplay
- Baldur Karlsson
- Lionel Landwerlin, Intel
- Peter Lohrmann, AMD
- Alon Or-bach, Samsung
- Daniel Rakos, AMD
- Niklas Smedberg, Unity Technologies
- Igor Ostrowski, Intel
Description
The VK_KHR_performance_query
extension adds a mechanism to allow
querying of performance counters for use in applications and by
profiling tools.
Each queue family may expose counters that can be enabled on a queue
of that family. We extend QueryType
to
add a new query type for performance queries, and chain a structure on
QueryPoolCreateInfo
to specify the performance
queries to enable.
New Commands
enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
releaseProfilingLockKHR
New Structures
PerformanceCounterDescriptionKHR
PerformanceCounterKHR
Extending
PhysicalDeviceFeatures2
,DeviceCreateInfo
:Extending
PhysicalDeviceProperties2
:Extending
QueryPoolCreateInfo
:Extending
SubmitInfo
:
New Unions
New Enums
PerformanceCounterDescriptionFlagBitsKHR
PerformanceCounterScopeKHR
PerformanceCounterStorageKHR
PerformanceCounterUnitKHR
New Bitmasks
New Enum Constants
KHR_PERFORMANCE_QUERY_SPEC_VERSION
Extending
QueryType
:Extending
StructureType
:STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR
STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR
STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR
STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR
STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR
STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR
STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
Issues
1) Should this extension include a mechanism to begin a query in command buffer A and end the query in command buffer B?
RESOLVED No - queries are tied to command buffer creation and thus have to be encapsulated within a single command buffer.
2) Should this extension include a mechanism to begin and end queries globally on the queue, not using the existing command buffer commands?
RESOLVED No - for the same reasoning as the resolution of 1).
3) Should this extension expose counters that require multiple passes?
RESOLVED Yes - users should re-submit a command buffer with the same commands in it multiple times, specifying the pass to count as the query parameter in VkPerformanceQuerySubmitInfoKHR.
4) How to handle counters across parallel workloads?
RESOLVED In the spirit of Vulkan, a counter description flag
PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR
denotes
that the accuracy of a counter result is affected by parallel workloads.
5) How to handle secondary command buffers?
RESOLVED Secondary command buffers inherit any counter pass index specified in the parent primary command buffer. Note: this is no longer an issue after change from issue 10 resolution
6) What commands does the profiling lock have to be held for?
RESOLVED For any command buffer that is being queried with a performance query pool, the profiling lock must be held while that command buffer is in the recording, executable, or pending state.
7) Should we support
cmdCopyQueryPoolResults
?
RESOLVED Yes.
8) Should we allow performance queries to interact with multiview?
RESOLVED Yes, but the performance queries must be performed once for each pass per view.
9) Should a queryCount > 1
be usable for performance queries?
RESOLVED Yes. Some vendors will have costly performance counter
query pool creation, and would rather if a certain set of counters were
to be used multiple times that a queryCount > 1
can be used to
amortize the instantiation cost.
10) Should we introduce an indirect mechanism to set the counter pass index?
RESOLVED Specify the counter pass index at submit time instead to avoid requiring re-recording of command buffers when multiple counter passes needed.
Examples
The following example shows how to find what performance counters a queue family supports, setup a query pool to record these performance counters, how to add the query pool to the command buffer to record information, and how to get the results from the query pool.
// A previously created physical device VkPhysicalDevice physicalDevice; // One of the queue families our device supports uint32_t queueFamilyIndex; uint32_t counterCount; // Get the count of counters supported vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, &counterCount, NULL, NULL); VkPerformanceCounterKHR* counters = malloc(sizeof(VkPerformanceCounterKHR) * counterCount); VkPerformanceCounterDescriptionKHR* counterDescriptions = malloc(sizeof(VkPerformanceCounterDescriptionKHR) * counterCount); // Get the counters supported vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, &counterCount, counters, counterDescriptions); // Try to enable the first 8 counters uint32_t enabledCounters[8]; const uint32_t enabledCounterCount = min(counterCount, 8)); for (uint32_t i = 0; i < enabledCounterCount; i++) { enabledCounters[i] = i; } // A previously created device that had the performanceCounterQueryPools feature // set to VK_TRUE VkDevice device; VkQueryPoolPerformanceCreateInfoKHR performanceQueryCreateInfo = { VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, NULL, // Specify the queue family that this performance query is performed on queueFamilyIndex, // The number of counters to enable enabledCounterCount, // The array of indices of counters to enable enabledCounters }; // Get the number of passes our counters will require. uint32_t numPasses; vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, &performanceQueryCreateInfo, &numPasses); VkQueryPoolCreateInfo queryPoolCreateInfo = { VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, &performanceQueryCreateInfo, 0, // Using our new query type here VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, 1, 0 }; VkQueryPool queryPool; VkResult result = vkCreateQueryPool( device, &queryPoolCreateInfo, NULL, &queryPool); assert(VK_SUCCESS == result); // A queue from queueFamilyIndex VkQueue queue; // A command buffer we want to record counters on VkCommandBuffer commandBuffer; VkCommandBufferBeginInfo commandBufferBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, 0, NULL }; VkAcquireProfilingLockInfoKHR lockInfo = { VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, NULL, 0, UINT64_MAX // Wait forever for the lock }; // Acquire the profiling lock before we record command buffers // that will use performance queries result = vkAcquireProfilingLockKHR(device, &lockInfo); assert(VK_SUCCESS == result); result = vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo); assert(VK_SUCCESS == result); vkCmdResetQueryPool( commandBuffer, queryPool, 0, 1); vkCmdBeginQuery( commandBuffer, queryPool, 0, 0); // Perform the commands you want to get performance information on // ... // Perform a barrier to ensure all previous commands were complete before // ending the query vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 0, NULL); vkCmdEndQuery( commandBuffer, queryPool, 0); result = vkEndCommandBuffer(commandBuffer); assert(VK_SUCCESS == result); for (uint32_t counterPass = 0; counterPass < numPasses; counterPass++) { VkPerformanceQuerySubmitInfoKHR performanceQuerySubmitInfo = { VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, NULL, counterPass }; // Submit the command buffer and wait for its completion // ... } // Release the profiling lock after the command buffer is no longer in the // pending state. vkReleaseProfilingLockKHR(device); result = vkResetCommandBuffer(commandBuffer, 0); assert(VK_SUCCESS == result); // Create an array to hold the results of all counters VkPerformanceCounterResultKHR* recordedCounters = malloc( sizeof(VkPerformanceCounterResultKHR) * enabledCounterCount); result = vkGetQueryPoolResults( device, queryPool, 0, 1, sizeof(VkPerformanceCounterResultKHR) * enabledCounterCount, recordedCounters, sizeof(VkPerformanceCounterResultKHR), NULL); // recordedCounters is filled with our counters, we'll look at one for posterity switch (counters[0].storage) { case VK_PERFORMANCE_COUNTER_STORAGE_INT32: // use recordCounters[0].int32 to get at the counter result! break; case VK_PERFORMANCE_COUNTER_STORAGE_INT64: // use recordCounters[0].int64 to get at the counter result! break; case VK_PERFORMANCE_COUNTER_STORAGE_UINT32: // use recordCounters[0].uint32 to get at the counter result! break; case VK_PERFORMANCE_COUNTER_STORAGE_UINT64: // use recordCounters[0].uint64 to get at the counter result! break; case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32: // use recordCounters[0].float32 to get at the counter result! break; case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64: // use recordCounters[0].float64 to get at the counter result! break; }
Version History
- Revision 1, 2019-10-08
See Also
AcquireProfilingLockFlagBitsKHR
, AcquireProfilingLockFlagsKHR
,
AcquireProfilingLockInfoKHR
,
PerformanceCounterDescriptionFlagBitsKHR
,
PerformanceCounterDescriptionFlagsKHR
,
PerformanceCounterDescriptionKHR
, PerformanceCounterKHR
,
PerformanceCounterResultKHR
, PerformanceCounterScopeKHR
,
PerformanceCounterStorageKHR
, PerformanceCounterUnitKHR
,
PerformanceQuerySubmitInfoKHR
,
PhysicalDevicePerformanceQueryFeaturesKHR
,
PhysicalDevicePerformanceQueryPropertiesKHR
,
QueryPoolPerformanceCreateInfoKHR
, acquireProfilingLockKHR
,
enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
,
getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
,
releaseProfilingLockKHR
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
- enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR :: forall io. MonadIO io => PhysicalDevice -> ("queueFamilyIndex" ::: Word32) -> io (Result, "counters" ::: Vector PerformanceCounterKHR, "counterDescriptions" ::: Vector PerformanceCounterDescriptionKHR)
- getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR :: forall io. MonadIO io => PhysicalDevice -> ("performanceQueryCreateInfo" ::: QueryPoolPerformanceCreateInfoKHR) -> io ("numPasses" ::: Word32)
- acquireProfilingLockKHR :: forall io. MonadIO io => Device -> AcquireProfilingLockInfoKHR -> io ()
- releaseProfilingLockKHR :: forall io. MonadIO io => Device -> io ()
- pattern QUERY_SCOPE_COMMAND_BUFFER_KHR :: PerformanceCounterScopeKHR
- pattern QUERY_SCOPE_RENDER_PASS_KHR :: PerformanceCounterScopeKHR
- pattern QUERY_SCOPE_COMMAND_KHR :: PerformanceCounterScopeKHR
- pattern PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR :: PerformanceCounterDescriptionFlagBitsKHR
- pattern PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR :: PerformanceCounterDescriptionFlagBitsKHR
- data PhysicalDevicePerformanceQueryFeaturesKHR = PhysicalDevicePerformanceQueryFeaturesKHR {}
- data PhysicalDevicePerformanceQueryPropertiesKHR = PhysicalDevicePerformanceQueryPropertiesKHR {}
- data PerformanceCounterKHR = PerformanceCounterKHR {}
- data PerformanceCounterDescriptionKHR = PerformanceCounterDescriptionKHR {}
- data QueryPoolPerformanceCreateInfoKHR = QueryPoolPerformanceCreateInfoKHR {}
- data AcquireProfilingLockInfoKHR = AcquireProfilingLockInfoKHR {}
- data PerformanceQuerySubmitInfoKHR = PerformanceQuerySubmitInfoKHR {}
- data PerformanceCounterResultKHR
- newtype PerformanceCounterScopeKHR where
- newtype PerformanceCounterUnitKHR where
- PerformanceCounterUnitKHR Int32
- pattern PERFORMANCE_COUNTER_UNIT_GENERIC_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_BYTES_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_KELVIN_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_WATTS_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_VOLTS_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_AMPS_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_HERTZ_KHR :: PerformanceCounterUnitKHR
- pattern PERFORMANCE_COUNTER_UNIT_CYCLES_KHR :: PerformanceCounterUnitKHR
- newtype PerformanceCounterStorageKHR where
- PerformanceCounterStorageKHR Int32
- pattern PERFORMANCE_COUNTER_STORAGE_INT32_KHR :: PerformanceCounterStorageKHR
- pattern PERFORMANCE_COUNTER_STORAGE_INT64_KHR :: PerformanceCounterStorageKHR
- pattern PERFORMANCE_COUNTER_STORAGE_UINT32_KHR :: PerformanceCounterStorageKHR
- pattern PERFORMANCE_COUNTER_STORAGE_UINT64_KHR :: PerformanceCounterStorageKHR
- pattern PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR :: PerformanceCounterStorageKHR
- pattern PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR :: PerformanceCounterStorageKHR
- type PerformanceCounterDescriptionFlagsKHR = PerformanceCounterDescriptionFlagBitsKHR
- newtype PerformanceCounterDescriptionFlagBitsKHR where
- type AcquireProfilingLockFlagsKHR = AcquireProfilingLockFlagBitsKHR
- newtype AcquireProfilingLockFlagBitsKHR = AcquireProfilingLockFlagBitsKHR Flags
- type KHR_PERFORMANCE_QUERY_SPEC_VERSION = 1
- pattern KHR_PERFORMANCE_QUERY_SPEC_VERSION :: forall a. Integral a => a
- type KHR_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_KHR_performance_query"
- pattern KHR_PERFORMANCE_QUERY_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
Documentation
enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR Source #
:: forall io. MonadIO io | |
=> PhysicalDevice |
|
-> ("queueFamilyIndex" ::: Word32) |
|
-> io (Result, "counters" ::: Vector PerformanceCounterKHR, "counterDescriptions" ::: Vector PerformanceCounterDescriptionKHR) |
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR - Reports properties of the performance query counters available on a queue family of a device
Description
If pCounters
is NULL
and pCounterDescriptions
is NULL
, then the
number of counters available is returned in pCounterCount
. Otherwise,
pCounterCount
must point to a variable set by the user to the number
of elements in the pCounters
, pCounterDescriptions
, or both arrays
and on return the variable is overwritten with the number of structures
actually written out. If pCounterCount
is less than the number of
counters available, at most pCounterCount
structures will be written
and INCOMPLETE
will be returned instead of
SUCCESS
.
Valid Usage (Implicit)
-
physicalDevice
must be a validPhysicalDevice
handle
-
pCounterCount
must be a valid pointer to auint32_t
value -
If the value referenced by
pCounterCount
is not0
, andpCounters
is notNULL
,pCounters
must be a valid pointer to an array ofpCounterCount
PerformanceCounterKHR
structures -
If the value referenced by
pCounterCount
is not0
, andpCounterDescriptions
is notNULL
,pCounterDescriptions
must be a valid pointer to an array ofpCounterCount
PerformanceCounterDescriptionKHR
structures
Return Codes
See Also
PerformanceCounterDescriptionKHR
, PerformanceCounterKHR
,
PhysicalDevice
getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR Source #
:: forall io. MonadIO io | |
=> PhysicalDevice |
|
-> ("performanceQueryCreateInfo" ::: QueryPoolPerformanceCreateInfoKHR) |
|
-> io ("numPasses" ::: Word32) |
vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR - Reports the number of passes require for a performance query pool type
Description
The pPerformanceQueryCreateInfo
member
QueryPoolPerformanceCreateInfoKHR
::queueFamilyIndex
must be a
queue family of physicalDevice
. The number of passes required to
capture the counters specified in the pPerformanceQueryCreateInfo
member QueryPoolPerformanceCreateInfoKHR
::pCounters
is returned in
pNumPasses
.
Valid Usage (Implicit)
See Also
acquireProfilingLockKHR Source #
:: forall io. MonadIO io | |
=> Device |
|
-> AcquireProfilingLockInfoKHR |
|
-> io () |
vkAcquireProfilingLockKHR - Acquires the profiling lock
Description
Implementations may allow multiple actors to hold the profiling lock concurrently.
Return Codes
See Also
releaseProfilingLockKHR Source #
vkReleaseProfilingLockKHR - Releases the profiling lock
Valid Usage
- The profiling lock of
device
must have been held via a previous successful call toacquireProfilingLockKHR
Valid Usage (Implicit)
-
device
must be a validDevice
handle
See Also
pattern QUERY_SCOPE_COMMAND_KHR :: PerformanceCounterScopeKHR Source #
pattern PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR :: PerformanceCounterDescriptionFlagBitsKHR Source #
pattern PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR :: PerformanceCounterDescriptionFlagBitsKHR Source #
data PhysicalDevicePerformanceQueryFeaturesKHR Source #
VkPhysicalDevicePerformanceQueryFeaturesKHR - Structure describing performance query support for an implementation
Valid Usage (Implicit)
See Also
Instances
data PhysicalDevicePerformanceQueryPropertiesKHR Source #
VkPhysicalDevicePerformanceQueryPropertiesKHR - Structure describing performance query properties for an implementation
Members
The members of the PhysicalDevicePerformanceQueryPropertiesKHR
structure describe the following implementation-dependent properties:
Valid Usage (Implicit)
If the PhysicalDevicePerformanceQueryPropertiesKHR
structure is
included in the pNext
chain of
PhysicalDeviceProperties2
,
it is filled with the implementation-dependent properties.
See Also
PhysicalDevicePerformanceQueryPropertiesKHR | |
|
Instances
data PerformanceCounterKHR Source #
VkPerformanceCounterKHR - Structure providing information about a counter
Valid Usage (Implicit)
See Also
PerformanceCounterScopeKHR
, PerformanceCounterStorageKHR
,
PerformanceCounterUnitKHR
,
StructureType
,
enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
PerformanceCounterKHR | |
|
Instances
data PerformanceCounterDescriptionKHR Source #
VkPerformanceCounterDescriptionKHR - Structure providing more detailed information about a counter
Valid Usage (Implicit)
See Also
PerformanceCounterDescriptionFlagsKHR
,
StructureType
,
enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
PerformanceCounterDescriptionKHR | |
|
Instances
data QueryPoolPerformanceCreateInfoKHR Source #
VkQueryPoolPerformanceCreateInfoKHR - Structure specifying parameters of a newly created performance query pool
Valid Usage
- The performanceCounterQueryPools feature must be enabled
-
Each element of
pCounterIndices
must be in the range of counters reported byenumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
for the queue family specified inqueueFamilyIndex
Valid Usage (Implicit)
-
sType
must beSTRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
-
pCounterIndices
must be a valid pointer to an array ofcounterIndexCount
uint32_t
values -
counterIndexCount
must be greater than0
See Also
StructureType
,
getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
QueryPoolPerformanceCreateInfoKHR | |
|
Instances
data AcquireProfilingLockInfoKHR Source #
VkAcquireProfilingLockInfoKHR - Structure specifying parameters to acquire the profiling lock
Valid Usage (Implicit)
If timeout
is 0, acquireProfilingLockKHR
will not block while
attempting to acquire the profling lock. If timeout
is UINT64_MAX
,
the function will not return until the profiling lock was acquired.
See Also
AcquireProfilingLockFlagsKHR
,
StructureType
,
acquireProfilingLockKHR
AcquireProfilingLockInfoKHR | |
|
Instances
data PerformanceQuerySubmitInfoKHR Source #
VkPerformanceQuerySubmitInfoKHR - Structure indicating which counter pass index is active for performance queries
Description
If the SubmitInfo
::pNext
chain does not include
this structure, the batch defaults to use counter pass index 0.
Valid Usage (Implicit)
See Also
PerformanceQuerySubmitInfoKHR | |
|
Instances
data PerformanceCounterResultKHR Source #
Int32Counter Int32 | |
Int64Counter Int64 | |
Uint32Counter Word32 | |
Uint64Counter Word64 | |
Float32Counter Float | |
Float64Counter Double |
Instances
Show PerformanceCounterResultKHR Source # | |
Defined in Vulkan.Extensions.VK_KHR_performance_query showsPrec :: Int -> PerformanceCounterResultKHR -> ShowS # show :: PerformanceCounterResultKHR -> String # showList :: [PerformanceCounterResultKHR] -> ShowS # | |
ToCStruct PerformanceCounterResultKHR Source # | |
Defined in Vulkan.Extensions.VK_KHR_performance_query withCStruct :: PerformanceCounterResultKHR -> (Ptr PerformanceCounterResultKHR -> IO b) -> IO b Source # pokeCStruct :: Ptr PerformanceCounterResultKHR -> PerformanceCounterResultKHR -> IO b -> IO b Source # withZeroCStruct :: (Ptr PerformanceCounterResultKHR -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PerformanceCounterResultKHR -> IO b -> IO b Source # cStructSize :: Int Source # | |
Zero PerformanceCounterResultKHR Source # | |
newtype PerformanceCounterScopeKHR Source #
pattern PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR :: PerformanceCounterScopeKHR |
|
pattern PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR :: PerformanceCounterScopeKHR |
|
pattern PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR :: PerformanceCounterScopeKHR |
|
Instances
newtype PerformanceCounterUnitKHR Source #
Instances
newtype PerformanceCounterStorageKHR Source #
Instances
newtype PerformanceCounterDescriptionFlagBitsKHR Source #
VkPerformanceCounterDescriptionFlagBitsKHR - Bitmask specifying usage behavior for a counter
See Also
pattern PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR :: PerformanceCounterDescriptionFlagBitsKHR |
|
pattern PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR :: PerformanceCounterDescriptionFlagBitsKHR |
|
Instances
newtype AcquireProfilingLockFlagBitsKHR Source #
Instances
type KHR_PERFORMANCE_QUERY_SPEC_VERSION = 1 Source #
pattern KHR_PERFORMANCE_QUERY_SPEC_VERSION :: forall a. Integral a => a Source #
type KHR_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_KHR_performance_query" Source #
pattern KHR_PERFORMANCE_QUERY_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a Source #