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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lwjgl-vulkan Show documentation
A new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.
There is a newer version: 3.3.4
Show newest version
/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import javax.annotation.*;

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 applications to insert markers in the command stream and associate them with custom data.
 * 
 * If a device lost error occurs, the application may then query the implementation for the last markers to cross specific implementation-defined pipeline stages, in order to narrow down which commands were executing at the time and might have caused the failure.
 * 
 * VK_NV_device_diagnostic_checkpoints
 * 
 * 
 * Name String
 * {@code VK_NV_device_diagnostic_checkpoints}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 207
 * Revision
 * 2
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.0
 * Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
 * 
 * Contact
 * 
 * Nuno Subtil nsubtil
 * 
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2018-07-16
 * Contributors
 * 
 * Oleg Kuznetsov, NVIDIA
 * Alex Dunn, NVIDIA
 * Jeff Bolz, NVIDIA
 * Eric Werness, NVIDIA
 * Daniel Koch, NVIDIA
 * 
 * 
 */
public class NVDeviceDiagnosticCheckpoints {

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

    /** The extension name. */
    public static final String VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME = "VK_NV_device_diagnostic_checkpoints";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV STRUCTURE_TYPE_CHECKPOINT_DATA_NV}
     * {@link #VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV                    = 1000206000,
        VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001;

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

    // --- [ vkCmdSetCheckpointNV ] ---

    /**
     * Insert diagnostic checkpoint in command stream.
     * 
     * C Specification
     * 
     * Device diagnostic checkpoints are inserted into the command stream by calling {@link #vkCmdSetCheckpointNV CmdSetCheckpointNV}.
     * 
     * 
     * void vkCmdSetCheckpointNV(
     *     VkCommandBuffer                             commandBuffer,
     *     const void*                                 pCheckpointMarker);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * {@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
     *
     * @param commandBuffer     the command buffer that will receive the marker
     * @param pCheckpointMarker an opaque application-provided value that will be associated with the checkpoint.
     */
    public static void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, @NativeType("void const *") long pCheckpointMarker) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetCheckpointNV;
        if (CHECKS) {
            check(__functionAddress);
            check(pCheckpointMarker);
        }
        callPPV(commandBuffer.address(), pCheckpointMarker, __functionAddress);
    }

    // --- [ vkGetQueueCheckpointDataNV ] ---

    /**
     * Unsafe version of: {@link #vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV}
     *
     * @param pCheckpointDataCount a pointer to an integer related to the number of checkpoint markers available or queried, as described below.
     */
    public static void nvkGetQueueCheckpointDataNV(VkQueue queue, long pCheckpointDataCount, long pCheckpointData) {
        long __functionAddress = queue.getCapabilities().vkGetQueueCheckpointDataNV;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(queue.address(), pCheckpointDataCount, pCheckpointData, __functionAddress);
    }

    /**
     * Retrieve diagnostic checkpoint data.
     * 
     * C Specification
     * 
     * If the device encounters an error during execution, the implementation will return a {@link VK10#VK_ERROR_DEVICE_LOST ERROR_DEVICE_LOST} error to the application at a certain point during host execution. When this happens, the application can call {@link #vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV} to retrieve information on the most recent diagnostic checkpoints that were executed by the device.
     * 
     * 
     * void vkGetQueueCheckpointDataNV(
     *     VkQueue                                     queue,
     *     uint32_t*                                   pCheckpointDataCount,
     *     VkCheckpointDataNV*                         pCheckpointData);
     * 
     * Description
     * 
     * If {@code pCheckpointData} is {@code NULL}, then the number of checkpoint markers available is returned in {@code pCheckpointDataCount}.
     * 
     * Otherwise, {@code pCheckpointDataCount} must point to a variable set by the user to the number of elements in the {@code pCheckpointData} array, and on return the variable is overwritten with the number of structures actually written to {@code pCheckpointData}.
     * 
     * If {@code pCheckpointDataCount} is less than the number of checkpoint markers available, at most {@code pCheckpointDataCount} structures will be written.
     * 
     * Valid Usage
     * 
     * 
     * The device that {@code queue} belongs to must be in the lost state
     * 
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code queue} must be a valid {@code VkQueue} handle
     * {@code pCheckpointDataCount} must be a valid pointer to a {@code uint32_t} value
     * If the value referenced by {@code pCheckpointDataCount} is not 0, and {@code pCheckpointData} is not {@code NULL}, {@code pCheckpointData} must be a valid pointer to an array of {@code pCheckpointDataCount} {@link VkCheckpointDataNV} structures
     * 
     * 
     * See Also
     * 
     * {@link VkCheckpointDataNV}
     *
     * @param queue                the {@code VkQueue} object the caller would like to retrieve checkpoint data for
     * @param pCheckpointDataCount a pointer to an integer related to the number of checkpoint markers available or queried, as described below.
     * @param pCheckpointData      either {@code NULL} or a pointer to an array of {@link VkCheckpointDataNV} structures.
     */
    public static void vkGetQueueCheckpointDataNV(VkQueue queue, @NativeType("uint32_t *") IntBuffer pCheckpointDataCount, @Nullable @NativeType("VkCheckpointDataNV *") VkCheckpointDataNV.Buffer pCheckpointData) {
        if (CHECKS) {
            check(pCheckpointDataCount, 1);
            checkSafe(pCheckpointData, pCheckpointDataCount.get(pCheckpointDataCount.position()));
        }
        nvkGetQueueCheckpointDataNV(queue, memAddress(pCheckpointDataCount), memAddressSafe(pCheckpointData));
    }

    /** Array version of: {@link #vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV} */
    public static void vkGetQueueCheckpointDataNV(VkQueue queue, @NativeType("uint32_t *") int[] pCheckpointDataCount, @Nullable @NativeType("VkCheckpointDataNV *") VkCheckpointDataNV.Buffer pCheckpointData) {
        long __functionAddress = queue.getCapabilities().vkGetQueueCheckpointDataNV;
        if (CHECKS) {
            check(__functionAddress);
            check(pCheckpointDataCount, 1);
            checkSafe(pCheckpointData, pCheckpointDataCount[0]);
        }
        callPPPV(queue.address(), pCheckpointDataCount, memAddressSafe(pCheckpointData), __functionAddress);
    }

}