#ifndef NVPERF_D3D12_TARGET_H #define NVPERF_D3D12_TARGET_H /* * Copyright 2014-2021 NVIDIA Corporation. All rights reserved. * * NOTICE TO USER: * * This source code is subject to NVIDIA ownership rights under U.S. and * international Copyright laws. * * This software and the information contained herein is PROPRIETARY and * CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions * of a form of NVIDIA software license agreement. * * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE * CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR * IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE * OR PERFORMANCE OF THIS SOURCE CODE. * * U.S. Government End Users. This source code is a "commercial item" as * that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of * "commercial computer software" and "commercial computer software * documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) * and is provided to the U.S. Government only as a commercial end item. * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the * source code with only those rights set forth herein. * * Any use of this source code in individual and commercial software must * include, in the user documentation and internal comments to the code, * the above Disclaimer and U.S. Government End Users Notice. */ #include #include #if defined(__GNUC__) && defined(NVPA_SHARED_LIB) #pragma GCC visibility push(default) #if !defined(NVPW_LOCAL) #define NVPW_LOCAL __attribute__ ((visibility ("hidden"))) #endif #else #if !defined(NVPW_LOCAL) #define NVPW_LOCAL #endif #endif #ifdef __cplusplus extern "C" { #endif /** * @file nvperf_d3d12_target.h */ /***************************************************************************//** * @name Common Types * @{ */ #ifndef NVPERF_NVPA_STATUS_DEFINED #define NVPERF_NVPA_STATUS_DEFINED /// Error codes. typedef enum NVPA_Status { /// Success NVPA_STATUS_SUCCESS = 0, /// Generic error. NVPA_STATUS_ERROR = 1, /// Internal error. Please file a bug! NVPA_STATUS_INTERNAL_ERROR = 2, /// NVPW_InitializeTarget() has not been called yet. NVPA_STATUS_NOT_INITIALIZED = 3, /// The NvPerf DLL/DSO could not be loaded during NVPW_Initialize*. NVPA_STATUS_NOT_LOADED = 4, /// The function was not found in this version of the NvPerf DLL/DSO. NVPA_STATUS_FUNCTION_NOT_FOUND = 5, /// The request was intentionally not supported. NVPA_STATUS_NOT_SUPPORTED = 6, /// The request was not implemented by this version. NVPA_STATUS_NOT_IMPLEMENTED = 7, /// Invalid argument. NVPA_STATUS_INVALID_ARGUMENT = 8, /// UNUSED NVPA_STATUS_INVALID_METRIC_ID = 9, /// No driver has been loaded via NVPW_*_LoadDriver(). NVPA_STATUS_DRIVER_NOT_LOADED = 10, /// Failed memory allocation. NVPA_STATUS_OUT_OF_MEMORY = 11, /// UNUSED NVPA_STATUS_INVALID_THREAD_STATE = 12, /// UNUSED NVPA_STATUS_FAILED_CONTEXT_ALLOC = 13, /// The specified GPU is not supported. NVPA_STATUS_UNSUPPORTED_GPU = 14, /// The installed NVIDIA driver is too old. NVPA_STATUS_INSUFFICIENT_DRIVER_VERSION = 15, /// UNUSED NVPA_STATUS_OBJECT_NOT_REGISTERED = 16, /// Profiling permission not granted; see https://developer.nvidia.com/nvidia-development-tools-solutions- /// ERR_NVGPUCTRPERM-permission-issue-performance-counters NVPA_STATUS_INSUFFICIENT_PRIVILEGE = 17, /// UNUSED NVPA_STATUS_INVALID_CONTEXT_STATE = 18, /// UNUSED NVPA_STATUS_INVALID_OBJECT_STATE = 19, /// The request could not be fulfilled because a system resource is already in use. NVPA_STATUS_RESOURCE_UNAVAILABLE = 20, /// UNUSED NVPA_STATUS_DRIVER_LOADED_TOO_LATE = 21, /// The provided buffer is not large enough. NVPA_STATUS_INSUFFICIENT_SPACE = 22, /// UNUSED NVPA_STATUS_OBJECT_MISMATCH = 23, /// Virtualized GPU (vGPU) is not supported. NVPA_STATUS_VIRTUALIZED_DEVICE_NOT_SUPPORTED = 24, /// Profiling permission on a vGPU was not granted. NVPA_STATUS_PROFILING_NOT_ALLOWED = 25, NVPA_STATUS__COUNT } NVPA_Status; #endif // NVPERF_NVPA_STATUS_DEFINED #ifndef NVPERF_NVPA_ACTIVITY_KIND_DEFINED #define NVPERF_NVPA_ACTIVITY_KIND_DEFINED /// The configuration's activity-kind dictates which types of data may be collected. typedef enum NVPA_ActivityKind { /// Invalid value. NVPA_ACTIVITY_KIND_INVALID = 0, /// A workload-centric activity for serialized and pipelined collection. /// /// Profiler is capable of collecting both serialized and pipelined metrics. The library introduces any /// synchronization required to collect serialized metrics. NVPA_ACTIVITY_KIND_PROFILER, /// A realtime activity for sampling counters from the CPU or GPU. NVPA_ACTIVITY_KIND_REALTIME_SAMPLED, /// A realtime activity for profiling counters from the CPU or GPU without CPU/GPU synchronizations. NVPA_ACTIVITY_KIND_REALTIME_PROFILER, NVPA_ACTIVITY_KIND__COUNT } NVPA_ActivityKind; #endif // NVPERF_NVPA_ACTIVITY_KIND_DEFINED #ifndef NVPERF_NVPA_BOOL_DEFINED #define NVPERF_NVPA_BOOL_DEFINED /// The type used for boolean values. typedef uint8_t NVPA_Bool; #endif // NVPERF_NVPA_BOOL_DEFINED #ifndef NVPA_STRUCT_SIZE #define NVPA_STRUCT_SIZE(type_, lastfield_) (offsetof(type_, lastfield_) + sizeof(((type_*)0)->lastfield_)) #endif // NVPA_STRUCT_SIZE #ifndef NVPERF_NVPA_GETPROCADDRESS_DEFINED #define NVPERF_NVPA_GETPROCADDRESS_DEFINED typedef NVPA_Status (*NVPA_GenericFn)(void); /// /// Gets the address of an NvPerf API function. /// /// \return A function pointer to the function, or NULL if the function is not available. /// /// \param pFunctionName [in] Name of the function to retrieve. NVPA_GenericFn NVPA_GetProcAddress(const char* pFunctionName); #endif #ifndef NVPERF_NVPW_SETLIBRARYLOADPATHS_DEFINED #define NVPERF_NVPW_SETLIBRARYLOADPATHS_DEFINED typedef struct NVPW_SetLibraryLoadPaths_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] number of paths in ppPaths size_t numPaths; /// [in] array of null-terminated paths const char** ppPaths; } NVPW_SetLibraryLoadPaths_Params; #define NVPW_SetLibraryLoadPaths_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_SetLibraryLoadPaths_Params, ppPaths) /// Sets library search path for \ref NVPW_InitializeHost() and \ref NVPW_InitializeTarget(). /// \ref NVPW_InitializeHost() and \ref NVPW_InitializeTarget load the NvPerf DLL/DSO. This function sets /// ordered paths that will be searched with the LoadLibrary() or dlopen() call. /// If load paths are set by this function, the default set of load paths /// will not be attempted. /// Each path must point at a directory (not a file name). /// This function is not thread-safe. /// Example Usage: /// \code /// const char* paths[] = { /// "path1", "path2", etc /// }; /// NVPW_SetLibraryLoadPaths_Params params{NVPW_SetLibraryLoadPaths_Params_STRUCT_SIZE}; /// params.numPaths = sizeof(paths)/sizeof(paths[0]); /// params.ppPaths = paths; /// NVPW_SetLibraryLoadPaths(¶ms); /// NVPW_InitializeHost(); /// params.numPaths = 0; /// params.ppPaths = NULL; /// NVPW_SetLibraryLoadPaths(¶ms); /// \endcode NVPA_Status NVAPI NVPW_SetLibraryLoadPaths(NVPW_SetLibraryLoadPaths_Params* pParams); typedef struct NVPW_SetLibraryLoadPathsW_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] number of paths in ppwPaths size_t numPaths; /// [in] array of null-terminated paths const wchar_t** ppwPaths; } NVPW_SetLibraryLoadPathsW_Params; #define NVPW_SetLibraryLoadPathsW_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_SetLibraryLoadPathsW_Params, ppwPaths) /// Sets library search path for \ref NVPW_InitializeHost() and \ref NVPW_InitializeTarget(). /// \ref NVPW_InitializeHost() and \ref NVPW_InitializeTarget load the NvPerf DLL/DSO. This function sets /// ordered paths that will be searched with the LoadLibrary() or dlopen() call. /// If load paths are set by this function, the default set of load paths /// will not be attempted. /// Each path must point at a directory (not a file name). /// This function is not thread-safe. /// Example Usage: /// \code /// const wchar_t* wpaths[] = { /// L"path1", L"path2", etc /// }; /// NVPW_SetLibraryLoadPathsW_Params params{NVPW_SetLibraryLoadPathsW_Params_STRUCT_SIZE}; /// params.numPaths = sizeof(wpaths)/sizeof(wpaths[0]); /// params.ppwPaths = wpaths; /// NVPW_SetLibraryLoadPathsW(¶ms); /// NVPW_InitializeHost(); /// params.numPaths = 0; /// params.ppwPaths = NULL; /// NVPW_SetLibraryLoadPathsW(¶ms); /// \endcode NVPA_Status NVAPI NVPW_SetLibraryLoadPathsW(NVPW_SetLibraryLoadPathsW_Params* pParams); #endif /** * @} ******************************************************************************/ // Device enumeration functions must be preceded by NVPA__LoadDriver(); any API is fine. #ifndef NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_DEFINED #define NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_DEFINED /// GPU architecture support level typedef enum NVPW_GpuArchitectureSupportLevel { NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_UNKNOWN = 0, NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_UNSUPPORTED, NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_SUPPORTED } NVPW_GpuArchitectureSupportLevel; #endif //NVPW_GPU_ARCHITECTURE_SUPPORT_LEVEL_DEFINED #ifndef NVPW_SLI_SUPPORT_LEVEL_DEFINED #define NVPW_SLI_SUPPORT_LEVEL_DEFINED /// SLI configuration support level typedef enum NVPW_SliSupportLevel { NVPW_SLI_SUPPORT_LEVEL_UNKNOWN = 0, NVPW_SLI_SUPPORT_LEVEL_UNSUPPORTED, /// Only Non-SLI configurations are supported. NVPW_SLI_SUPPORT_LEVEL_SUPPORTED_NON_SLI_CONFIGURATION } NVPW_SliSupportLevel; #endif //NVPW_SLI_SUPPORT_LEVEL_DEFINED #define NVPW_FIELD_EXISTS(pParams_, name_) \ ((pParams_)->structSize >= (const size_t)((const uint8_t*)(&(pParams_)->name_) + sizeof(pParams_)->name_ - (const uint8_t*)(pParams_))) /***************************************************************************//** * @name External Types * @{ */ struct ID3D12CommandQueue; struct ID3D12GraphicsCommandList; typedef struct _LUID LUID; /** * @} ******************************************************************************/ /***************************************************************************//** * @name Common * @{ */ typedef struct NVPW_D3D12_LoadDriver_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; } NVPW_D3D12_LoadDriver_Params; #define NVPW_D3D12_LoadDriver_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_LoadDriver_Params, pPriv) NVPA_Status NVAPI NVPW_D3D12_LoadDriver(NVPW_D3D12_LoadDriver_Params* pParams); typedef struct NVPW_D3D12_Device_GetDeviceIndex_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12Device* pDevice; /// [in] size_t sliIndex; /// [out] size_t deviceIndex; } NVPW_D3D12_Device_GetDeviceIndex_Params; #define NVPW_D3D12_Device_GetDeviceIndex_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Device_GetDeviceIndex_Params, deviceIndex) NVPA_Status NVAPI NVPW_D3D12_Device_GetDeviceIndex(NVPW_D3D12_Device_GetDeviceIndex_Params* pParams); /** * @} ******************************************************************************/ typedef struct NVPW_D3D12_GetLUID_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t deviceIndex; /// [out] LUID* luid; } NVPW_D3D12_GetLUID_Params; #define NVPW_D3D12_GetLUID_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_GetLUID_Params, luid) NVPA_Status NVAPI NVPW_D3D12_GetLUID(NVPW_D3D12_GetLUID_Params* pParams); /***************************************************************************//** * @name Range Profiler * @{ */ typedef struct NVPW_D3D12_Profiler_CounterDataImageOptions { /// [in] size_t structSize; /// The CounterDataPrefix generated from e.g. NVPW_CounterDataBuilder_GetCounterDataPrefix(). Must be align(8). const uint8_t* pCounterDataPrefix; size_t counterDataPrefixSize; /// max number of ranges that can be specified uint32_t maxNumRanges; /// max number of RangeTree nodes; must be >= maxNumRanges uint32_t maxNumRangeTreeNodes; /// max string length of each RangeName, including the trailing NUL character uint32_t maxRangeNameLength; } NVPW_D3D12_Profiler_CounterDataImageOptions; #define NVPW_D3D12_Profiler_CounterDataImageOptions_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CounterDataImageOptions, maxRangeNameLength) typedef struct NVPW_D3D12_Profiler_CounterDataImage_CalculateSize_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t counterDataImageOptionsSize; /// [in] const NVPW_D3D12_Profiler_CounterDataImageOptions* pOptions; /// [out] size_t counterDataImageSize; } NVPW_D3D12_Profiler_CounterDataImage_CalculateSize_Params; #define NVPW_D3D12_Profiler_CounterDataImage_CalculateSize_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CounterDataImage_CalculateSize_Params, counterDataImageSize) NVPA_Status NVAPI NVPW_D3D12_Profiler_CounterDataImage_CalculateSize(NVPW_D3D12_Profiler_CounterDataImage_CalculateSize_Params* pParams); typedef struct NVPW_D3D12_Profiler_CounterDataImage_Initialize_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t counterDataImageOptionsSize; /// [in] const NVPW_D3D12_Profiler_CounterDataImageOptions* pOptions; /// [in] size_t counterDataImageSize; /// [in] The buffer to be written. uint8_t* pCounterDataImage; } NVPW_D3D12_Profiler_CounterDataImage_Initialize_Params; #define NVPW_D3D12_Profiler_CounterDataImage_Initialize_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CounterDataImage_Initialize_Params, pCounterDataImage) NVPA_Status NVAPI NVPW_D3D12_Profiler_CounterDataImage_Initialize(NVPW_D3D12_Profiler_CounterDataImage_Initialize_Params* pParams); typedef struct NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t counterDataImageSize; /// [in] uint8_t* pCounterDataImage; /// [out] size_t counterDataScratchBufferSize; } NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize_Params; #define NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize_Params, counterDataScratchBufferSize) NVPA_Status NVAPI NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize(NVPW_D3D12_Profiler_CounterDataImage_CalculateScratchBufferSize_Params* pParams); typedef struct NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t counterDataImageSize; /// [in] uint8_t* pCounterDataImage; /// [in] size_t counterDataScratchBufferSize; /// [in] The scratch buffer to be written. uint8_t* pCounterDataScratchBuffer; } NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer_Params; #define NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer_Params, pCounterDataScratchBuffer) NVPA_Status NVAPI NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer(NVPW_D3D12_Profiler_CounterDataImage_InitializeScratchBuffer_Params* pParams); typedef struct NVPW_D3D12_Profiler_CalcTraceBufferSize_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] Maximum number of Push/Pop pairs that can be recorded in a single pass. size_t maxRangesPerPass; /// [in] for sizing internal buffers size_t avgRangeNameLength; /// [out] TraceBuffer size for a single pass. Pass this to /// NVPW_D3D12_Profiler_BeginSession_Params::traceBufferSize. size_t traceBufferSize; } NVPW_D3D12_Profiler_CalcTraceBufferSize_Params; #define NVPW_D3D12_Profiler_CalcTraceBufferSize_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CalcTraceBufferSize_Params, traceBufferSize) NVPA_Status NVAPI NVPW_D3D12_Profiler_CalcTraceBufferSize(NVPW_D3D12_Profiler_CalcTraceBufferSize_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_BeginSession_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] Set to 1 if every pass is synchronized with CPU; for asynchronous collection, increase to /// (softwarePipelineDepth + 2). size_t numTraceBuffers; /// [in] Size of the per-pass TraceBuffer in bytes. The profiler allocates a numTraceBuffers * traceBufferSize /// internally. size_t traceBufferSize; /// [in] Maximum number of ranges that can be recorded in a single pass. size_t maxRangesPerPass; /// [in] Maximum number of kernel launches that can be recorded in a single pass. Must be >= maxRangesPerPass. size_t maxLaunchesPerPass; } NVPW_D3D12_Profiler_Queue_BeginSession_Params; #define NVPW_D3D12_Profiler_Queue_BeginSession_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_BeginSession_Params, maxLaunchesPerPass) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_BeginSession(NVPW_D3D12_Profiler_Queue_BeginSession_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_EndSession_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] Maximum number of milliseconds to wait for pending GPU operations. Pass 0xFFFFFFFF to wait forever uint32_t timeout; /// [out] NVPA_Bool timeoutExpired; } NVPW_D3D12_Profiler_Queue_EndSession_Params; #define NVPW_D3D12_Profiler_Queue_EndSession_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_EndSession_Params, timeoutExpired) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_EndSession(NVPW_D3D12_Profiler_Queue_EndSession_Params* pParams); typedef struct NVPW_D3D12_Queue_ServicePendingGpuOperations_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] The number of operations to process. Passing `0` will block until EndSession is called uint32_t numOperations; /// [in] Maximum number of milliseconds to wait for pending GPU operations. Pass 0xFFFFFFFF to wait forever uint32_t timeout; /// [out] NVPA_Bool timeoutExpired; } NVPW_D3D12_Queue_ServicePendingGpuOperations_Params; #define NVPW_D3D12_Queue_ServicePendingGpuOperations_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Queue_ServicePendingGpuOperations_Params, timeoutExpired) NVPA_Status NVAPI NVPW_D3D12_Queue_ServicePendingGpuOperations(NVPW_D3D12_Queue_ServicePendingGpuOperations_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_SetConfig_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] Config created by e.g. NVPW_RawMetricsConfig_GetConfigImage(). Must be align(8). const uint8_t* pConfig; size_t configSize; /// [in] the lowest nesting level to be profiled; must be >= 1 uint16_t minNestingLevel; /// [in] the number of nesting levels to profile; must be >= 1 uint16_t numNestingLevels; /// [in] Set this to zero for in-app replay. Set this to the output of EndPass() for application replay. size_t passIndex; /// [in] Set this to minNestingLevel for in-app replay. Set this to the output of EndPass() for application /// replay. uint16_t targetNestingLevel; } NVPW_D3D12_Profiler_Queue_SetConfig_Params; #define NVPW_D3D12_Profiler_Queue_SetConfig_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_SetConfig_Params, targetNestingLevel) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_SetConfig(NVPW_D3D12_Profiler_Queue_SetConfig_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_ClearConfig_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; } NVPW_D3D12_Profiler_Queue_ClearConfig_Params; #define NVPW_D3D12_Profiler_Queue_ClearConfig_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_ClearConfig_Params, pCommandQueue) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_ClearConfig(NVPW_D3D12_Profiler_Queue_ClearConfig_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_BeginPass_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; } NVPW_D3D12_Profiler_Queue_BeginPass_Params; #define NVPW_D3D12_Profiler_Queue_BeginPass_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_BeginPass_Params, pCommandQueue) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_BeginPass(NVPW_D3D12_Profiler_Queue_BeginPass_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_EndPass_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [out] The passIndex that will be collected by the *next* BeginPass. size_t passIndex; /// [out] The targetNestingLevel that will be collected by the *next* BeginPass. uint16_t targetNestingLevel; /// [out] becomes true when the last pass has been queued to the GPU NVPA_Bool allPassesSubmitted; } NVPW_D3D12_Profiler_Queue_EndPass_Params; #define NVPW_D3D12_Profiler_Queue_EndPass_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_EndPass_Params, allPassesSubmitted) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_EndPass(NVPW_D3D12_Profiler_Queue_EndPass_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_PushRange_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] specifies the range that subsequent launches' counters will be assigned to; must not be NULL const char* pRangeName; /// [in] assign to strlen(pRangeName) if known; if set to zero, the library will call strlen() size_t rangeNameLength; } NVPW_D3D12_Profiler_Queue_PushRange_Params; #define NVPW_D3D12_Profiler_Queue_PushRange_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_PushRange_Params, rangeNameLength) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_PushRange(NVPW_D3D12_Profiler_Queue_PushRange_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_PopRange_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; } NVPW_D3D12_Profiler_Queue_PopRange_Params; #define NVPW_D3D12_Profiler_Queue_PopRange_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_PopRange_Params, pCommandQueue) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_PopRange(NVPW_D3D12_Profiler_Queue_PopRange_Params* pParams); typedef struct NVPW_D3D12_Profiler_CommandList_PushRange_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12GraphicsCommandList* pCommandList; /// [in] specifies the range that subsequent launches' counters will be assigned to; must not be NULL const char* pRangeName; /// [in] assign to strlen(pRangeName) if known; if set to zero, the library will call strlen() size_t rangeNameLength; } NVPW_D3D12_Profiler_CommandList_PushRange_Params; #define NVPW_D3D12_Profiler_CommandList_PushRange_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CommandList_PushRange_Params, rangeNameLength) NVPA_Status NVAPI NVPW_D3D12_Profiler_CommandList_PushRange(NVPW_D3D12_Profiler_CommandList_PushRange_Params* pParams); typedef struct NVPW_D3D12_Profiler_CommandList_PopRange_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12GraphicsCommandList* pCommandList; } NVPW_D3D12_Profiler_CommandList_PopRange_Params; #define NVPW_D3D12_Profiler_CommandList_PopRange_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_CommandList_PopRange_Params, pCommandList) NVPA_Status NVAPI NVPW_D3D12_Profiler_CommandList_PopRange(NVPW_D3D12_Profiler_CommandList_PopRange_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_DecodeCounters_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in] size_t counterDataImageSize; /// [in] uint8_t* pCounterDataImage; /// [in] size_t counterDataScratchBufferSize; /// [in] uint8_t* pCounterDataScratchBuffer; /// [out] number of ranges whose data was dropped in the processed pass size_t numRangesDropped; /// [out] number of bytes not written to TraceBuffer due to buffer full size_t numTraceBytesDropped; /// [out] true if a pass was successfully decoded NVPA_Bool onePassCollected; /// [out] becomes true when the last pass has been decoded NVPA_Bool allPassesCollected; /// [out] the Config decoded by this call const uint8_t* pConfigDecoded; /// [out] the passIndex decoded size_t passIndexDecoded; } NVPW_D3D12_Profiler_Queue_DecodeCounters_Params; #define NVPW_D3D12_Profiler_Queue_DecodeCounters_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_DecodeCounters_Params, passIndexDecoded) NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_DecodeCounters(NVPW_D3D12_Profiler_Queue_DecodeCounters_Params* pParams); typedef struct NVPW_D3D12_Profiler_Queue_GetCounterAvailability_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct ID3D12CommandQueue* pCommandQueue; /// [in/out] If `pCounterAvailabilityImage` is NULL, then the required size is returned in /// `counterAvailabilityImageSize`, otherwise `counterAvailabilityImageSize` should be set to the size of /// `pCounterAvailabilityImage`, and on return it would be overwritten with number of actual bytes copied size_t counterAvailabilityImageSize; /// [in] buffer receiving counter availability image, may be NULL uint8_t* pCounterAvailabilityImage; } NVPW_D3D12_Profiler_Queue_GetCounterAvailability_Params; #define NVPW_D3D12_Profiler_Queue_GetCounterAvailability_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_Queue_GetCounterAvailability_Params, pCounterAvailabilityImage) /// This API may fail, if any profiling or sampling session is active on the specified ID3D12CommandQueue or its /// device NVPA_Status NVAPI NVPW_D3D12_Profiler_Queue_GetCounterAvailability(NVPW_D3D12_Profiler_Queue_GetCounterAvailability_Params* pParams); /** * @} ******************************************************************************/ typedef struct NVPW_D3D12_Profiler_IsGpuSupported_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t deviceIndex; /// [out] NVPA_Bool isSupported; /// [out] NVPW_GpuArchitectureSupportLevel gpuArchitectureSupportLevel; /// [out] NVPW_SliSupportLevel sliSupportLevel; } NVPW_D3D12_Profiler_IsGpuSupported_Params; #define NVPW_D3D12_Profiler_IsGpuSupported_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_D3D12_Profiler_IsGpuSupported_Params, sliSupportLevel) /// NVPW_D3D12_LoadDriver must be called prior to this API NVPA_Status NVAPI NVPW_D3D12_Profiler_IsGpuSupported(NVPW_D3D12_Profiler_IsGpuSupported_Params* pParams); #ifdef __cplusplus } // extern "C" #endif #if defined(__GNUC__) && defined(NVPA_SHARED_LIB) #pragma GCC visibility pop #endif #endif // NVPERF_D3D12_TARGET_H