#ifndef NVPERF_TARGET_H #define NVPERF_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_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_))) typedef struct NVPW_InitializeTarget_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; } NVPW_InitializeTarget_Params; #define NVPW_InitializeTarget_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_InitializeTarget_Params, pPriv) /// Load the target library. NVPA_Status NVAPI NVPW_InitializeTarget(NVPW_InitializeTarget_Params* pParams); typedef struct NVPW_GetDeviceCount_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; size_t numDevices; } NVPW_GetDeviceCount_Params; #define NVPW_GetDeviceCount_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_GetDeviceCount_Params, numDevices) NVPA_Status NVAPI NVPW_GetDeviceCount(NVPW_GetDeviceCount_Params* pParams); typedef struct NVPW_Device_GetNames_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; size_t deviceIndex; const char* pDeviceName; const char* pChipName; } NVPW_Device_GetNames_Params; #define NVPW_Device_GetNames_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Device_GetNames_Params, pChipName) NVPA_Status NVAPI NVPW_Device_GetNames(NVPW_Device_GetNames_Params* pParams); typedef struct NVPW_PciBusId { /// The PCI domain on which the device bus resides. uint32_t domain; /// The bus on which the device resides. uint16_t bus; /// device ID. uint16_t device; } NVPW_PciBusId; #define NVPW_PciBusId_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_PciBusId, device) typedef struct NVPW_Device_GetPciBusIds_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] caller-allocated array of NVPW_PciBusId, indexed by NVPW deviceIndex NVPW_PciBusId* pBusIds; /// [in] size of the pBusIDs array; use result from NVPW_GetDeviceCount size_t numDevices; } NVPW_Device_GetPciBusIds_Params; #define NVPW_Device_GetPciBusIds_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Device_GetPciBusIds_Params, numDevices) NVPA_Status NVAPI NVPW_Device_GetPciBusIds(NVPW_Device_GetPciBusIds_Params* pParams); #define NVPW_DEVICE_MIG_GPU_INSTANCE_ID_INVALID 0xFFFFFFFFu #define NVPW_DEVICE_MIG_GPU_INSTANCE_ID_FULLCHIP 0xFFFFFFFEu typedef struct NVPW_Device_GetMigAttributes_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] size_t deviceIndex; /// [out] NVPA_Bool isMigPartition; /// [out] uint32_t gpuInstanceId; /// [out] uint32_t computeInstanceId; } NVPW_Device_GetMigAttributes_Params; #define NVPW_Device_GetMigAttributes_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Device_GetMigAttributes_Params, computeInstanceId) NVPA_Status NVAPI NVPW_Device_GetMigAttributes(NVPW_Device_GetMigAttributes_Params* pParams); typedef struct NVPW_Adapter_GetDeviceIndex_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] struct IDXGIAdapter* pAdapter; /// [in] size_t sliIndex; /// [out] size_t deviceIndex; } NVPW_Adapter_GetDeviceIndex_Params; #define NVPW_Adapter_GetDeviceIndex_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Adapter_GetDeviceIndex_Params, deviceIndex) NVPA_Status NVAPI NVPW_Adapter_GetDeviceIndex(NVPW_Adapter_GetDeviceIndex_Params* pParams); typedef struct NVPW_CounterData_GetNumRanges_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; const uint8_t* pCounterDataImage; size_t numRanges; } NVPW_CounterData_GetNumRanges_Params; #define NVPW_CounterData_GetNumRanges_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_CounterData_GetNumRanges_Params, numRanges) NVPA_Status NVAPI NVPW_CounterData_GetNumRanges(NVPW_CounterData_GetNumRanges_Params* pParams); typedef struct NVPW_CounterData_GetChipName_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] const uint8_t* pCounterDataImage; /// [in] size_t counterDataImageSize; /// [out] const char* pChipName; } NVPW_CounterData_GetChipName_Params; #define NVPW_CounterData_GetChipName_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_CounterData_GetChipName_Params, pChipName) NVPA_Status NVAPI NVPW_CounterData_GetChipName(NVPW_CounterData_GetChipName_Params* pParams); typedef struct NVPW_Config_GetNumPasses_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] const uint8_t* pConfig; /// [out] size_t numPipelinedPasses; /// [out] size_t numIsolatedPasses; } NVPW_Config_GetNumPasses_Params; #define NVPW_Config_GetNumPasses_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Config_GetNumPasses_Params, numIsolatedPasses) /// Total num passes = numPipelinedPasses + numIsolatedPasses * numNestingLevels NVPA_Status NVAPI NVPW_Config_GetNumPasses(NVPW_Config_GetNumPasses_Params* pParams); #define NVPW_API_SET_D3D11_PROFILER 0xca55c6738445db2bULL #define NVPW_API_SET_D3D12_PROFILER 0xc0c2d46dd7c7ad78ULL #define NVPW_API_SET_METRICSEVALUATOR 0x0368a8768d811af9ULL #define NVPW_API_SET_METRICS_GA10X_GRFX 0x6ebc121178b5ce0bULL #define NVPW_API_SET_METRICS_GV100_GRFX 0x9900da75d164fecfULL #define NVPW_API_SET_METRICS_GV11B_GRFX 0xeb8e26220106e227ULL #define NVPW_API_SET_METRICS_TU10X_GRFX 0xdf219cb838db6968ULL #define NVPW_API_SET_METRICS_TU11X_GRFX 0x0977d9342bd62743ULL #define NVPW_API_SET_OPENGL_PROFILER 0xe4cd9ea40f2ee777ULL #define NVPW_API_SET_VULKAN_PROFILER 0x8c56b6a03d779689ULL typedef struct NVPW_QueryVersionNumber_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; /// [in] uint64_t apiSet; /// [out] uint32_t major; /// [out] uint32_t minor; /// [out] uint32_t patch; /// [out] uint32_t relMajor; /// [out] uint32_t relMinor; /// [out] uint32_t relPatch; } NVPW_QueryVersionNumber_Params; #define NVPW_QueryVersionNumber_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_QueryVersionNumber_Params, relPatch) /// Query version number of an API set NVPA_Status NVAPI NVPW_QueryVersionNumber(NVPW_QueryVersionNumber_Params* pParams); typedef enum NVPW_Device_ClockStatus { /// clock status is unknown NVPW_DEVICE_CLOCK_STATUS_UNKNOWN, /// clocks are locked to rated tdp values NVPW_DEVICE_CLOCK_STATUS_LOCKED_TO_RATED_TDP, /// clocks are not locked and can boost above rated tdp NVPW_DEVICE_CLOCK_STATUS_BOOST_ENABLED, /// clocks are not locked and will not go above rated tdp NVPW_DEVICE_CLOCK_STATUS_BOOST_DISABLED, NVPW_DEVICE_CLOCK_STATUS__COUNT } NVPW_Device_ClockStatus; typedef struct NVPW_Device_GetClockStatus_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; size_t deviceIndex; /// [in] NVPW_Device_ClockStatus clockStatus; } NVPW_Device_GetClockStatus_Params; #define NVPW_Device_GetClockStatus_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Device_GetClockStatus_Params, clockStatus) NVPA_Status NVAPI NVPW_Device_GetClockStatus(NVPW_Device_GetClockStatus_Params* pParams); typedef enum NVPW_Device_ClockSetting { /// invalid op, specify valid clocks operation during profiling NVPW_DEVICE_CLOCK_SETTING_INVALID, /// default to driver/application config (normally unlocked and not boosted, but could be unlocked boosted, or /// locked to rated TDP) NVPW_DEVICE_CLOCK_SETTING_DEFAULT, /// lock clocks at rated tdp base values NVPW_DEVICE_CLOCK_SETTING_LOCK_TO_RATED_TDP, NVPW_DEVICE_CLOCK_SETTING__COUNT } NVPW_Device_ClockSetting; typedef struct NVPW_Device_SetClockSetting_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; size_t deviceIndex; /// [in] NVPW_Device_ClockSetting clockSetting; } NVPW_Device_SetClockSetting_Params; #define NVPW_Device_SetClockSetting_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Device_SetClockSetting_Params, clockSetting) NVPA_Status NVAPI NVPW_Device_SetClockSetting(NVPW_Device_SetClockSetting_Params* pParams); typedef struct NVPW_CounterData_GetRangeDescriptions_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; const uint8_t* pCounterDataImage; size_t rangeIndex; /// [inout] Number of descriptions allocated in ppDescriptions size_t numDescriptions; const char** ppDescriptions; } NVPW_CounterData_GetRangeDescriptions_Params; #define NVPW_CounterData_GetRangeDescriptions_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_CounterData_GetRangeDescriptions_Params, ppDescriptions) NVPA_Status NVAPI NVPW_CounterData_GetRangeDescriptions(NVPW_CounterData_GetRangeDescriptions_Params* pParams); typedef struct NVPW_Profiler_CounterData_GetRangeDescriptions_Params { /// [in] size_t structSize; /// [in] assign to NULL void* pPriv; const uint8_t* pCounterDataImage; size_t rangeIndex; /// [inout] Number of descriptions allocated in ppDescriptions size_t numDescriptions; const char** ppDescriptions; } NVPW_Profiler_CounterData_GetRangeDescriptions_Params; #define NVPW_Profiler_CounterData_GetRangeDescriptions_Params_STRUCT_SIZE NVPA_STRUCT_SIZE(NVPW_Profiler_CounterData_GetRangeDescriptions_Params, ppDescriptions) NVPA_Status NVAPI NVPW_Profiler_CounterData_GetRangeDescriptions(NVPW_Profiler_CounterData_GetRangeDescriptions_Params* pParams); #ifdef __cplusplus } // extern "C" #endif #if defined(__GNUC__) && defined(NVPA_SHARED_LIB) #pragma GCC visibility pop #endif #endif // NVPERF_TARGET_H