• Home
• org.lwjgl
• lwjgl-vulkan
• 3.3.0
• source code
• INTELPerformanceQuery.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.lwjgl.vulkan.INTELPerformanceQuery Maven / Gradle / Ivy

/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import java.nio.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * This extension allows an application to capture performance data to be interpreted by a external application or library.
 * 
 * 
Such a library is available at : https://github.com/intel/metrics-discovery
 * 
 * 
Performance analysis tools such as Graphics Performance Analyzers make use of this extension and the metrics-discovery library to present the data in a human readable way.
 * 
 * 
Example Code
 * 
 * 

 * // A previously created device
 * VkDevice device;
 * 
 * // A queue derived from the device
 * VkQueue queue;
 * 
 * VkInitializePerformanceApiInfoINTEL performanceApiInfoIntel = {
 *   VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL,
 *   NULL,
 *   NULL
 * };
 * 
 * vkInitializePerformanceApiINTEL(
 *   device,
 *   &performanceApiInfoIntel);
 * 
 * VkQueryPoolPerformanceQueryCreateInfoINTEL queryPoolIntel = {
 *   VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL,
 *   NULL,
 *   VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL,
 * };
 * 
 * VkQueryPoolCreateInfo queryPoolCreateInfo = {
 *   VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
 *   &queryPoolIntel,
 *   0,
 *   VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL,
 *   1,
 *   0
 * };
 * 
 * VkQueryPool queryPool;
 * 
 * VkResult result = vkCreateQueryPool(
 *   device,
 *   &queryPoolCreateInfo,
 *   NULL,
 *   &queryPool);
 * 
 * assert(VK_SUCCESS == result);
 * 
 * // A command buffer we want to record counters on
 * VkCommandBuffer commandBuffer;
 * 
 * VkCommandBufferBeginInfo commandBufferBeginInfo = {
 *   VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 *   NULL,
 *   VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
 *   NULL
 * };
 * 
 * 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);
 * 
 * VkPerformanceConfigurationAcquireInfoINTEL performanceConfigurationAcquireInfo = {
 *   VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
 *   NULL,
 *   VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL
 * };
 * 
 * VkPerformanceConfigurationINTEL performanceConfigurationIntel;
 * 
 * result = vkAcquirePerformanceConfigurationINTEL(
 *   device,
 *   &performanceConfigurationAcquireInfo,
 *   &performanceConfigurationIntel);
 * 
 * vkQueueSetPerformanceConfigurationINTEL(queue, performanceConfigurationIntel);
 * 
 * assert(VK_SUCCESS == result);
 * 
 * // Submit the command buffer and wait for its completion
 * // ...
 * 
 * result = vkReleasePerformanceConfigurationINTEL(
 *   device,
 *   performanceConfigurationIntel);
 * 
 * assert(VK_SUCCESS == result);
 * 
 * // Get the report size from metrics-discovery's QueryReportSize
 * 
 * result = vkGetQueryPoolResults(
 *   device,
 *   queryPool,
 *   0, 1, QueryReportSize,
 *   data, QueryReportSize, 0);
 * 
 * assert(VK_SUCCESS == result);
 * 
 * // The data can then be passed back to metrics-discovery from which
 * // human readable values can be queried.
 * 
 * 
VK_INTEL_performance_query
 * 
 * 

 * 
Name String
 * 
{@code VK_INTEL_performance_query}
 * 
Extension Type
 * 
Device extension
 * 
Registered Extension Number
 * 
211
 * 
Revision
 * 
2
 * 
Extension and Version Dependencies
 * 

 * 
Requires Vulkan 1.0
 * 
 * 
Special Use
 * 

 * 
Developer tools
 * 
 * 
Contact
 * 

 * 
Lionel Landwerlin llandwerlin
 * 
 * 
 * 
 * 
Other Extension Metadata
 * 
 * 

 * 
Last Modified Date
 * 
2018-05-16
 * 
IP Status
 * 
No known IP claims.
 * 
Contributors
 * 

 * 
Lionel Landwerlin, Intel
 * 
Piotr Maciejewski, Intel
 * 
 * 
 */
public class INTELPerformanceQuery {

    /** The extension specification version. */
    public static final int VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION = 2;

    /** The extension name. */
    public static final String VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME = "VK_INTEL_performance_query";

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL}
     * 
{@link #VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,
        VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL                   = 1000210000,
        VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL          = 1000210001,
        VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL                  = 1000210002,
        VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL           = 1000210003,
        VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL                = 1000210004,
        VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL   = 1000210005;

    /** Extends {@code VkQueryType}. */
    public static final int VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000;

    /** Extends {@code VkObjectType}. */
    public static final int VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000;

    /**
     * VkPerformanceConfigurationTypeINTEL - Type of performance configuration
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceConfigurationAcquireInfoINTEL}
     */
    public static final int VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0;

    /**
     * VkQueryPoolSamplingModeINTEL - Enum specifying how performance queries should be captured
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL} is the default mode in which the application calls {@link VK10#vkCmdBeginQuery CmdBeginQuery} and {@link VK10#vkCmdEndQuery CmdEndQuery} to record performance data.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkQueryPoolPerformanceQueryCreateInfoINTEL}
     */
    public static final int VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0;

    /**
     * VkPerformanceOverrideTypeINTEL - Performance override type
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL} turns all rendering operations into noop.
     * 
{@link #VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL} stalls the stream of commands until all previously emitted commands have completed and all caches been flushed and invalidated.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceOverrideInfoINTEL}
     */
    public static final int
        VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL    = 0,
        VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1;

    /**
     * VkPerformanceParameterTypeINTEL - Parameters that can be queried
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL} has a boolean result which tells whether hardware counters can be captured.
     * 
{@link #VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL} has a 32 bits integer result which tells how many bits can be written into the {@link VkPerformanceValueINTEL} value.
     * 
     * 
     * 
See Also
     * 
     * 
{@link #vkGetPerformanceParameterINTEL GetPerformanceParameterINTEL}
     */
    public static final int
        VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL    = 0,
        VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1;

    /**
     * VkPerformanceValueTypeINTEL - Type of the parameters that can be queried
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceValueINTEL}
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL PERFORMANCE_VALUE_TYPE_UINT32_INTEL}
     * 
{@link #VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL PERFORMANCE_VALUE_TYPE_UINT64_INTEL}
     * 
{@link #VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL PERFORMANCE_VALUE_TYPE_FLOAT_INTEL}
     * 
{@link #VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL PERFORMANCE_VALUE_TYPE_BOOL_INTEL}
     * 
{@link #VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL PERFORMANCE_VALUE_TYPE_STRING_INTEL}
     * 
     */
    public static final int
        VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
        VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
        VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL  = 2,
        VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL   = 3,
        VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4;

    protected INTELPerformanceQuery() {
        throw new UnsupportedOperationException();
    }

    // --- [ vkInitializePerformanceApiINTEL ] ---

    /** Unsafe version of: {@link #vkInitializePerformanceApiINTEL InitializePerformanceApiINTEL} */
    public static int nvkInitializePerformanceApiINTEL(VkDevice device, long pInitializeInfo) {
        long __functionAddress = device.getCapabilities().vkInitializePerformanceApiINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), pInitializeInfo, __functionAddress);
    }

    /**
     * Initialize a device for performance queries.
     * 
     * 
C Specification
     * 
     * 
Prior to creating a performance query pool, initialize the device for performance queries with the call:
     * 
     * 

     * VkResult vkInitializePerformanceApiINTEL(
     *     VkDevice                                    device,
     *     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pInitializeInfo} must be a valid pointer to a valid {@link VkInitializePerformanceApiInfoINTEL} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkInitializePerformanceApiInfoINTEL}
     *
     * @param device          the logical device used for the queries.
     * @param pInitializeInfo a pointer to a {@link VkInitializePerformanceApiInfoINTEL} structure specifying initialization parameters.
     */
    @NativeType("VkResult")
    public static int vkInitializePerformanceApiINTEL(VkDevice device, @NativeType("VkInitializePerformanceApiInfoINTEL const *") VkInitializePerformanceApiInfoINTEL pInitializeInfo) {
        return nvkInitializePerformanceApiINTEL(device, pInitializeInfo.address());
    }

    // --- [ vkUninitializePerformanceApiINTEL ] ---

    /**
     * Uninitialize a device for performance queries.
     * 
     * 
C Specification
     * 
     * 
Once performance query operations have completed, uninitalize the device for performance queries with the call:
     * 
     * 

     * void vkUninitializePerformanceApiINTEL(
     *     VkDevice                                    device);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
     *
     * @param device the logical device used for the queries.
     */
    public static void vkUninitializePerformanceApiINTEL(VkDevice device) {
        long __functionAddress = device.getCapabilities().vkUninitializePerformanceApiINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(device.address(), __functionAddress);
    }

    // --- [ vkCmdSetPerformanceMarkerINTEL ] ---

    /** Unsafe version of: {@link #vkCmdSetPerformanceMarkerINTEL CmdSetPerformanceMarkerINTEL} */
    public static int nvkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, long pMarkerInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetPerformanceMarkerINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(commandBuffer.address(), pMarkerInfo, __functionAddress);
    }

    /**
     * Markers.
     * 
     * 
C Specification
     * 
     * 
To help associate query results with a particular point at which an application emitted commands, markers can be set into the command buffers with the call:
     * 
     * 

     * VkResult vkCmdSetPerformanceMarkerINTEL(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pMarkerInfo} must be a valid pointer to a valid {@link VkPerformanceMarkerInfoINTEL} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, compute, or transfer operations
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics Compute Transfer
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceMarkerInfoINTEL}
     */
    @NativeType("VkResult")
    public static int vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, @NativeType("VkPerformanceMarkerInfoINTEL const *") VkPerformanceMarkerInfoINTEL pMarkerInfo) {
        return nvkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo.address());
    }

    // --- [ vkCmdSetPerformanceStreamMarkerINTEL ] ---

    /** Unsafe version of: {@link #vkCmdSetPerformanceStreamMarkerINTEL CmdSetPerformanceStreamMarkerINTEL} */
    public static int nvkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, long pMarkerInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetPerformanceStreamMarkerINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(commandBuffer.address(), pMarkerInfo, __functionAddress);
    }

    /**
     * Markers.
     * 
     * 
C Specification
     * 
     * 
When monitoring the behavior of an application wihtin the dataset generated by the entire set of applications running on the system, it is useful to identify draw calls within a potentially huge amount of performance data. To do so, application can generate stream markers that will be used to trace back a particular draw call with a particular performance data item.
     * 
     * 

     * VkResult vkCmdSetPerformanceStreamMarkerINTEL(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pMarkerInfo} must be a valid pointer to a valid {@link VkPerformanceStreamMarkerInfoINTEL} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, compute, or transfer operations
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics Compute Transfer
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceStreamMarkerInfoINTEL}
     */
    @NativeType("VkResult")
    public static int vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, @NativeType("VkPerformanceStreamMarkerInfoINTEL const *") VkPerformanceStreamMarkerInfoINTEL pMarkerInfo) {
        return nvkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo.address());
    }

    // --- [ vkCmdSetPerformanceOverrideINTEL ] ---

    /** Unsafe version of: {@link #vkCmdSetPerformanceOverrideINTEL CmdSetPerformanceOverrideINTEL} */
    public static int nvkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, long pOverrideInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetPerformanceOverrideINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(commandBuffer.address(), pOverrideInfo, __functionAddress);
    }

    /**
     * Performance override settings.
     * 
     * 
C Specification
     * 
     * 
Some applications might want measure the effect of a set of commands with a different settings. It is possible to override a particular settings using :
     * 
     * 

     * VkResult vkCmdSetPerformanceOverrideINTEL(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
     * 
     * 
Valid Usage
     * 
     * 

     * 
{@code pOverrideInfo} must not be used with a {@code VkPerformanceOverrideTypeINTEL} that is not reported available by {@code vkGetPerformanceParameterINTEL}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pOverrideInfo} must be a valid pointer to a valid {@link VkPerformanceOverrideInfoINTEL} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, compute, or transfer operations
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics Compute Transfer
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceOverrideInfoINTEL}
     *
     * @param commandBuffer the command buffer where the override takes place.
     * @param pOverrideInfo a pointer to a {@link VkPerformanceOverrideInfoINTEL} structure selecting the parameter to override.
     */
    @NativeType("VkResult")
    public static int vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, @NativeType("VkPerformanceOverrideInfoINTEL const *") VkPerformanceOverrideInfoINTEL pOverrideInfo) {
        return nvkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo.address());
    }

    // --- [ vkAcquirePerformanceConfigurationINTEL ] ---

    /** Unsafe version of: {@link #vkAcquirePerformanceConfigurationINTEL AcquirePerformanceConfigurationINTEL} */
    public static int nvkAcquirePerformanceConfigurationINTEL(VkDevice device, long pAcquireInfo, long pConfiguration) {
        long __functionAddress = device.getCapabilities().vkAcquirePerformanceConfigurationINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(device.address(), pAcquireInfo, pConfiguration, __functionAddress);
    }

    /**
     * Acquire the performance query capability.
     * 
     * 
C Specification
     * 
     * 
To acquire a device performance configuration, call:
     * 
     * 

     * VkResult vkAcquirePerformanceConfigurationINTEL(
     *     VkDevice                                    device,
     *     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
     *     VkPerformanceConfigurationINTEL*            pConfiguration);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pAcquireInfo} must be a valid pointer to a valid {@link VkPerformanceConfigurationAcquireInfoINTEL} structure
     * 
{@code pConfiguration} must be a valid pointer to a {@code VkPerformanceConfigurationINTEL} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceConfigurationAcquireInfoINTEL}
     *
     * @param device         the logical device that the performance query commands will be submitted to.
     * @param pAcquireInfo   a pointer to a {@link VkPerformanceConfigurationAcquireInfoINTEL} structure, specifying the performance configuration to acquire.
     * @param pConfiguration a pointer to a {@code VkPerformanceConfigurationINTEL} handle in which the resulting configuration object is returned.
     */
    @NativeType("VkResult")
    public static int vkAcquirePerformanceConfigurationINTEL(VkDevice device, @NativeType("VkPerformanceConfigurationAcquireInfoINTEL const *") VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo, @NativeType("VkPerformanceConfigurationINTEL *") LongBuffer pConfiguration) {
        if (CHECKS) {
            check(pConfiguration, 1);
        }
        return nvkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo.address(), memAddress(pConfiguration));
    }

    // --- [ vkReleasePerformanceConfigurationINTEL ] ---

    /**
     * Release a configuration to capture performance data.
     * 
     * 
C Specification
     * 
     * 
To release a device performance configuration, call:
     * 
     * 

     * VkResult vkReleasePerformanceConfigurationINTEL(
     *     VkDevice                                    device,
     *     VkPerformanceConfigurationINTEL             configuration);
     * 
     * 
Valid Usage
     * 
     * 

     * 
{@code configuration} must not be released before all command buffers submitted while the configuration was set are in pending state
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
If {@code configuration} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code configuration} must be a valid {@code VkPerformanceConfigurationINTEL} handle
     * 
If {@code configuration} is a valid handle, it must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code configuration} must be externally synchronized
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     *
     * @param device        the device associated to the configuration object to release.
     * @param configuration the configuration object to release.
     */
    @NativeType("VkResult")
    public static int vkReleasePerformanceConfigurationINTEL(VkDevice device, @NativeType("VkPerformanceConfigurationINTEL") long configuration) {
        long __functionAddress = device.getCapabilities().vkReleasePerformanceConfigurationINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJI(device.address(), configuration, __functionAddress);
    }

    // --- [ vkQueueSetPerformanceConfigurationINTEL ] ---

    /**
     * Set a performance query.
     * 
     * 
C Specification
     * 
     * 
To set a performance configuration, call:
     * 
     * 

     * VkResult vkQueueSetPerformanceConfigurationINTEL(
     *     VkQueue                                     queue,
     *     VkPerformanceConfigurationINTEL             configuration);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code queue} must be a valid {@code VkQueue} handle
     * 
{@code configuration} must be a valid {@code VkPerformanceConfigurationINTEL} handle
     * 
Both of {@code configuration}, and {@code queue} must have been created, allocated, or retrieved from the same {@code VkDevice}
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
-
-
Any
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     *
     * @param queue         the queue on which the configuration will be used.
     * @param configuration the configuration to use.
     */
    @NativeType("VkResult")
    public static int vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, @NativeType("VkPerformanceConfigurationINTEL") long configuration) {
        long __functionAddress = queue.getCapabilities().vkQueueSetPerformanceConfigurationINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJI(queue.address(), configuration, __functionAddress);
    }

    // --- [ vkGetPerformanceParameterINTEL ] ---

    /** Unsafe version of: {@link #vkGetPerformanceParameterINTEL GetPerformanceParameterINTEL} */
    public static int nvkGetPerformanceParameterINTEL(VkDevice device, int parameter, long pValue) {
        long __functionAddress = device.getCapabilities().vkGetPerformanceParameterINTEL;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), parameter, pValue, __functionAddress);
    }

    /**
     * Query performance capabilities of the device.
     * 
     * 
C Specification
     * 
     * 
Some performance query features of a device can be discovered with the call:
     * 
     * 

     * VkResult vkGetPerformanceParameterINTEL(
     *     VkDevice                                    device,
     *     VkPerformanceParameterTypeINTEL             parameter,
     *     VkPerformanceValueINTEL*                    pValue);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code parameter} must be a valid {@code VkPerformanceParameterTypeINTEL} value
     * 
{@code pValue} must be a valid pointer to a {@link VkPerformanceValueINTEL} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPerformanceValueINTEL}
     *
     * @param device    the logical device to query.
     * @param parameter the parameter to query.
     * @param pValue    a pointer to a {@link VkPerformanceValueINTEL} structure in which the type and value of the parameter are returned.
     */
    @NativeType("VkResult")
    public static int vkGetPerformanceParameterINTEL(VkDevice device, @NativeType("VkPerformanceParameterTypeINTEL") int parameter, @NativeType("VkPerformanceValueINTEL *") VkPerformanceValueINTEL pValue) {
        return nvkGetPerformanceParameterINTEL(device, parameter, pValue.address());
    }

    /** Array version of: {@link #vkAcquirePerformanceConfigurationINTEL AcquirePerformanceConfigurationINTEL} */
    @NativeType("VkResult")
    public static int vkAcquirePerformanceConfigurationINTEL(VkDevice device, @NativeType("VkPerformanceConfigurationAcquireInfoINTEL const *") VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo, @NativeType("VkPerformanceConfigurationINTEL *") long[] pConfiguration) {
        long __functionAddress = device.getCapabilities().vkAcquirePerformanceConfigurationINTEL;
        if (CHECKS) {
            check(__functionAddress);
            check(pConfiguration, 1);
        }
        return callPPPI(device.address(), pAcquireInfo.address(), pConfiguration, __functionAddress);
    }

}