/*

* MIT License

*

* Copyright (c) 2016 Jeremy Main (jmain.jp@gmail.com)

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in all

* copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

* SOFTWARE.

*/

// nvmlquery.cpp : Demonstrate how to load the NVML API and query GPU utilization metrics

#include <Windows.h>

#include <stdio.h>

// The NVML.h header file can be downloaded as part of the NVML SDK from the NVIDIA web site

// ref: https://developer.nvidia.com/nvidia-management-library-nvml

//

#include "nvml/nvml.h"

// The default path to the NVML DLL

#define NVMLQUERY_DEFAULT_NVML_DLL_PATH "C:\\Program Files\\NVIDIA Corporation\\NVSMI\\NVML.DLL"

// NVML Function pointer prototypes

typedef nvmlReturn_t (*PFNnvmlInit)(void);

typedef nvmlReturn_t (*PFNnvmlShutdown)(void);

typedef char* (*PFNnvmlErrorString)(nvmlReturn_t result);

typedef nvmlReturn_t (*PFNnvmlDeviceGetCount)(unsigned int* deviceCount);

typedef nvmlReturn_t (*PFNnvmlDeviceGetHandleByIndex)(unsigned int index, nvmlDevice_t* device);

typedef nvmlReturn_t (*PFNnvmlDeviceGetUtilizationRates)(nvmlDevice_t device, nvmlUtilization_t* utilization);

typedef nvmlReturn_t (*PFNnvmlDeviceGetEncoderUtilization)(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs);

typedef nvmlReturn_t (*PFNnvmlDeviceGetDecoderUtilization)(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs);

typedef nvmlReturn_t (*PFNnvmlDeviceGetMemoryInfo)(nvmlDevice_t device, nvmlMemory_t* memory);

typedef nvmlReturn_t (*PFNnvmlDeviceGetName)(nvmlDevice_t device, char* name, unsigned int length);

// NVML Function pointer instances

PFNnvmlInit pfn_nvmlInit = NULL ;

PFNnvmlShutdown pfn_nvmlShutdown = NULL ;

PFNnvmlErrorString pfn_nvmlErrorString = NULL ;

PFNnvmlDeviceGetCount pfn_nvmlDeviceGetCount = NULL ;

PFNnvmlDeviceGetHandleByIndex pfn_nvmlDeviceGetHandleByIndex = NULL ;

PFNnvmlDeviceGetUtilizationRates pfn_nvmlDeviceGetUtilizationRates = NULL ;

PFNnvmlDeviceGetEncoderUtilization pfn_nvmlDeviceGetEncoderUtilization = NULL ;

PFNnvmlDeviceGetDecoderUtilization pfn_nvmlDeviceGetDecoderUtilization = NULL ;

PFNnvmlDeviceGetMemoryInfo pfn_nvmlDeviceGetMemoryInfo = NULL ;

PFNnvmlDeviceGetName pfn_nvmlDeviceGetName = NULL ;

// display information about the calling function and related error

void ShowErrorDetails(const nvmlReturn_t nvRetVal, const char* pFunctionName)

{

char* pErrorDescription = NULL ;

pErrorDescription = pfn_nvmlErrorString(nvRetVal) ;

printf("[%s] - %s\r\n", pFunctionName, pErrorDescription) ;

}

// Application entry point

int main(int argc, char* argv[])

{

int iRetValue = -1 ;

nvmlReturn_t nvRetValue = NVML_ERROR_UNINITIALIZED ;

// Load the NVML DLL using the default NVML DLL install path

// NOTE: This DLL is included in the NVIDIA driver installation by default

HINSTANCE hDLLhandle = NULL ;

hDLLhandle = LoadLibrary(NVMLQUERY_DEFAULT_NVML_DLL_PATH) ;

// if the DLL can not be found, exit

if (NULL == hDLLhandle)

{

printf("NVML DLL is not installed or not found at the default path.\r\n") ;

return iRetValue ;

}

// Get the function pointers from the DLL

pfn_nvmlInit = (PFNnvmlInit)GetProcAddress(hDLLhandle, "nvmlInit") ;

pfn_nvmlShutdown = (PFNnvmlShutdown)GetProcAddress(hDLLhandle, "nvmlShutdown") ;

pfn_nvmlErrorString = (PFNnvmlErrorString)GetProcAddress(hDLLhandle, "nvmlErrorString") ;

pfn_nvmlDeviceGetCount = (PFNnvmlDeviceGetCount)GetProcAddress(hDLLhandle, "nvmlDeviceGetCount") ;

pfn_nvmlDeviceGetHandleByIndex = (PFNnvmlDeviceGetHandleByIndex)GetProcAddress(hDLLhandle, "nvmlDeviceGetHandleByIndex") ;

pfn_nvmlDeviceGetName = (PFNnvmlDeviceGetName)GetProcAddress(hDLLhandle, "nvmlDeviceGetName") ;

pfn_nvmlDeviceGetUtilizationRates = (PFNnvmlDeviceGetUtilizationRates)GetProcAddress(hDLLhandle, "nvmlDeviceGetUtilizationRates") ;

pfn_nvmlDeviceGetEncoderUtilization = (PFNnvmlDeviceGetEncoderUtilization)GetProcAddress(hDLLhandle, "nvmlDeviceGetEncoderUtilization") ;

pfn_nvmlDeviceGetDecoderUtilization = (PFNnvmlDeviceGetDecoderUtilization)GetProcAddress(hDLLhandle, "nvmlDeviceGetDecoderUtilization") ;

pfn_nvmlDeviceGetMemoryInfo = (PFNnvmlDeviceGetMemoryInfo)GetProcAddress(hDLLhandle, "nvmlDeviceGetMemoryInfo") ;

// Before any of the NVML functions can be used nvmlInit() must be called

nvRetValue = pfn_nvmlInit() ;

if (NVML_SUCCESS != nvRetValue)

{

// Can not call the NVML specific error string handler if the initialization failed

printf ("[%s] error code :%d\r\n", "nvmlInit", nvRetValue) ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// Now that NVML has been initalized, before exiting normally or when handling

// an error condition, ensure nvmlShutdown() is called

// For each of the GPUs detected by NVML, query the device name, GPU, GPU memory, video encoder and decoder utilization

// Get the number of GPUs

unsigned int uiNumGPUs = 0 ;

nvRetValue = pfn_nvmlDeviceGetCount(&uiNumGPUs) ;

if (NVML_SUCCESS != nvRetValue)

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetCount") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// In the case that no GPUs were detected

if (0 == uiNumGPUs)

{

printf("No NVIDIA GPUs were detected.\r\n") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// Flags to denote unsupported queries

bool bGPUUtilSupported = true ;

bool bEncoderUtilSupported = true ;

bool bDecoderUtilSupported = true ;

// Print out a header for the utilization output

printf("Device #, Name, GPU(%%), Frame Buffer(%%), Video Encode(%%), Video Decode(%%)\r\n") ;

// Iterate through all of the GPUs

for (unsigned int iDevIDX = 0; iDevIDX < uiNumGPUs; iDevIDX++)

{

// Get the GPU device handle

nvmlDevice_t nvGPUDeviceHandle = NULL ;

nvRetValue = pfn_nvmlDeviceGetHandleByIndex(iDevIDX, &nvGPUDeviceHandle) ;

if (NVML_SUCCESS != nvRetValue)

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetHandleByIndex") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// Get the device name

char cDevicename[NVML_DEVICE_NAME_BUFFER_SIZE] = {'\0'} ;

nvRetValue = pfn_nvmlDeviceGetName(nvGPUDeviceHandle, cDevicename, NVML_DEVICE_NAME_BUFFER_SIZE) ;

if (NVML_SUCCESS != nvRetValue)

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetName") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// NOTE: nvUtil.memory is the memory controller utilization not the frame buffer utilization

nvmlUtilization_t nvUtilData ;

nvRetValue = pfn_nvmlDeviceGetUtilizationRates(nvGPUDeviceHandle, &nvUtilData) ;

if (NVML_SUCCESS != nvRetValue)

{

// Where the GPU utilization is not supported, the query will return an "Not Supported", handle it and continue

if (NVML_ERROR_NOT_SUPPORTED == nvRetValue)

{

bGPUUtilSupported = false ;

}

else

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetUtilizationRates") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

}

// Get the GPU frame buffer memory information

nvmlMemory_t GPUmemoryInfo ;

ZeroMemory(&GPUmemoryInfo, sizeof(GPUmemoryInfo)) ;

nvRetValue = pfn_nvmlDeviceGetMemoryInfo(nvGPUDeviceHandle, &GPUmemoryInfo) ;

if (NVML_SUCCESS != nvRetValue)

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetMemoryInfo") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// compute the amount of frame buffer memory that has been used

unsigned long long ullFrameBufferUsedBytes = 0L;

ullFrameBufferUsedBytes = GPUmemoryInfo.total - GPUmemoryInfo.free ;

unsigned long ulFrameBufferTotalKBytes = 0L;

unsigned long ulFrameBufferUsedKBytes = 0L;

// verify that the unsigned long long to unsigned long cast will not result in lost data

if (ULONG_MAX < GPUmemoryInfo.total)

{

printf("ERROR: GPU memory size exceeds variable limit\r\n") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

// convert the frame buffer value to KBytes

ulFrameBufferTotalKBytes = (unsigned long)(GPUmemoryInfo.total / 1024L) ;

ulFrameBufferUsedKBytes = (unsigned long)(ulFrameBufferTotalKBytes - (GPUmemoryInfo.free / 1024L)) ;

// calculate the frame buffer memory utilization

double dMemUtilzation = (((double)ulFrameBufferUsedKBytes / (double)ulFrameBufferTotalKBytes) * 100.0) ;

// Get the video encoder utilization (where supported)

unsigned int uiVidEncoderUtil = 0u ;

unsigned int uiVideEncoderLastSample = 0u ;

nvRetValue = pfn_nvmlDeviceGetEncoderUtilization(nvGPUDeviceHandle, &uiVidEncoderUtil, &uiVideEncoderLastSample) ;

if (NVML_SUCCESS != nvRetValue)

{

// Where the video encoder utilization is not supported, the query will return an "Not Supported", handle it and continue

if (NVML_ERROR_NOT_SUPPORTED == nvRetValue)

{

bEncoderUtilSupported = false ;

}

else

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetEncoderUtilization") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

}

// Get the video decoder utilization (where supported)

unsigned int uiVidDecoderUtil = 0u ;

unsigned int uiVidDecoderLastSample = 0u ;

nvRetValue = pfn_nvmlDeviceGetDecoderUtilization(nvGPUDeviceHandle, &uiVidDecoderUtil, &uiVidDecoderLastSample) ;

if (NVML_SUCCESS != nvRetValue)

{

// Where the video decoder utilization is not supported, the query will return an "Not Supported", handle it and continue

if (NVML_ERROR_NOT_SUPPORTED == nvRetValue)

{

bDecoderUtilSupported = false ;

}

else

{

ShowErrorDetails(nvRetValue, "nvmlDeviceGetDecoderUtilization") ;

pfn_nvmlShutdown() ;

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

}

}

// Output the utilization results depending on which of the counters has data available

// I have opted to display "-" to denote an unsupported value rather than simply display "0"

// to clarify that the GPU/driver does not support the query.

if (!bEncoderUtilSupported || !bDecoderUtilSupported)

{

if (!bGPUUtilSupported)

{

printf("Device %d, %s, -, %.0f, -, -\r\n", iDevIDX, cDevicename, dMemUtilzation) ;

}

else

{

printf("Device %d, %s, %d, %.0f, -, -\r\n", iDevIDX, cDevicename, nvUtilData.gpu, dMemUtilzation) ;

}

}

else

{

if (!bGPUUtilSupported)

{

printf("Device %d, %s, -, %.0f, %d, %d\r\n", iDevIDX, cDevicename, dMemUtilzation, uiVidEncoderUtil, uiVidDecoderUtil) ;

}

else

{

printf("Device %d, %s, %d, %.0f, %d, %d\r\n", iDevIDX, cDevicename, nvUtilData.gpu, dMemUtilzation, uiVidEncoderUtil, uiVidDecoderUtil) ;

}

}

}

// Shutdown NVML

nvRetValue = pfn_nvmlShutdown() ;

if (NVML_SUCCESS != nvRetValue)

{

ShowErrorDetails(nvRetValue, "nvmlShutdown") ;

}

// release the DLL handle

FreeLibrary(hDLLhandle) ;

hDLLhandle = NULL ;

return iRetValue ;

iRetValue = (NVML_SUCCESS == nvRetValue) ? 0 : -1 ;

return iRetValue;

}