如何获取显卡的GPU占用率和显存占用情况

转自：http://blog.csdn.net/pizi0475/article/details/45056605

在游戏的性能调优过程中，经常会需要获取CPU占用率、IO、显卡GPU占用率等基础性能数据，下面就简述一下获取nvdia显卡GPU占用率的方法。 nvdia 显卡在驱动安装后，可以通过nvapi.dll来获取显卡的相关信息。有关nvdia、AMD显卡sdk的相关资料在它们的网站上均有下载，但貌似非注册开发者可获取到的信息有限。

下面提供一个简单封装了的用来获取显卡信息的c++类，由于代码是根据网上可找到的有限资料写成，难免可能存在错误，如有问题欢迎指出。

 // KGpuMon.h  源代码
 #pragma once

 #define MAX_GPU_NUM     4L      // 监控的GPU个数（NVIDIA定义的最多GPU个数是64，这里最多只监控4个）
 #define MY_PROCESS_ERROR(Condition) do { if (!(Condition)) goto Exit0; } while (false)

 #define MAX_DISPLAY_CARDS               4       // 最多监控4块显卡（暂时应该够了吧）
 // 常量定义
 #define MAX_PHYSICAL_GPUS               64
 #define SHORT_STRING_MAX                64
 #define MAX_THERMAL_SENSORS_PER_GPU     3
 #define MAX_CLOCKS_PER_GPU              0x120
 #define MAX_PSTATES_PER_GPU             8
 #define MAX_USAGES_PER_GPU              33
 #define MAX_COOLER_PER_GPU              20
 #define MAX_MEMORY_VALUES_PER_GPU       5

 // 接口ID值
 #define ID_NvAPI_Initialize                     0x0150E828
 #define ID_NvAPI_GPU_GetFullName                0xCEEE8E9F
 #define ID_NvAPI_GPU_GetThermalSettings         0xE3640A56
 #define ID_NvAPI_EnumNvidiaDisplayHandle        0x9ABDD40D
 #define ID_NvAPI_GetPhysicalGPUsFromDisplay     0x34EF9506
 #define ID_NvAPI_EnumPhysicalGPUs               0xE5AC921F
 #define ID_NvAPI_GPU_GetTachReading             0x5F608315
 #define ID_NvAPI_GPU_GetAllClocks               0x1BD69F49
 #define ID_NvAPI_GPU_GetPStates                 0x60DED2ED
 #define ID_NvAPI_GPU_GetUsages                  0x189A1FDF
 #define ID_NvAPI_GPU_GetCoolerSettings          0xDA141340
 #define ID_NvAPI_GPU_SetCoolerLevels            0x891FA0AE
 #define ID_NvAPI_GPU_GetMemoryInfo              0x774AA982
 #define ID_NvAPI_GetDisplayDriverVersion        0xF951A4D1
 #define ID_NvAPI_GetInterfaceVersionString      0x01053FA5
 #define ID_NvAPI_GPU_GetPCIIdentifiers          0x2DDFB66E

 // 版本号参数定义
 #define GPU_THERMAL_SETTINGS_VER                (sizeof(NvGPUThermalSettings) | 0x10000)
 #define GPU_CLOCKS_VER                          (sizeof(NvClocks) | 0x20000)
 #define GPU_PSTATES_VER                         (sizeof(NvPStates) | 0x10000)
 #define GPU_USAGES_VER                          (sizeof(NvUsages) | 0x10000)
 #define GPU_COOLER_SETTINGS_VER                 (sizeof(NvGPUCoolerSettings) | 0x20000)
 #define GPU_MEMORY_INFO_VER                     (sizeof(NvMemoryInfo) | 0x20000)
 #define DISPLAY_DRIVER_VERSION_VER              (sizeof(NvDisplayDriverVersion) | 0x10000)
 #define GPU_COOLER_LEVELS_VER                   (sizeof(NvGPUCoolerLevels) | 0x10000)

 enum NvStatus
 {
     enumNvStatus_OK = 0,
     enumNvStatus_ERROR = -1,
     enumNvStatus_LIBRARY_NOT_FOUND = -2,
     enumNvStatus_NO_IMPLEMENTATION = -3,
     enumNvStatus_API_NOT_INTIALIZED = -4,
     enumNvStatus_INVALID_ARGUMENT = -5,
     enumNvStatus_NVIDIA_DEVICE_NOT_FOUND = -6,
     enumNvStatus_END_ENUMERATION = -7,
     enumNvStatus_INVALID_HANDLE = -8,
     enumNvStatus_INCOMPATIBLE_STRUCT_VERSION = -9,
     enumNvStatus_HANDLE_INVALIDATED = -10,
     enumNvStatus_OPENGL_CONTEXT_NOT_CURRENT = -11,
     enumNvStatus_NO_GL_EXPERT = -12,
     enumNvStatus_INSTRUMENTATION_DISABLED = -13,
     enumNvStatus_EXPECTED_LOGICAL_GPU_HANDLE = -100,
     enumNvStatus_EXPECTED_PHYSICAL_GPU_HANDLE = -101,
     enumNvStatus_EXPECTED_DISPLAY_HANDLE = -102,
     enumNvStatus_INVALID_COMBINATION = -103,
     enumNvStatus_NOT_SUPPORTED = -104,
     enumNvStatus_PORTID_NOT_FOUND = -105,
     enumNvStatus_EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106,
     enumNvStatus_INVALID_PERF_LEVEL = -107,
     enumNvStatus_DEVICE_BUSY = -108,
     enumNvStatus_NV_PERSIST_FILE_NOT_FOUND = -109,
     enumNvStatus_PERSIST_DATA_NOT_FOUND = -110,
     enumNvStatus_EXPECTED_TV_DISPLAY = -111,
     enumNvStatus_EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112,
     enumNvStatus_NO_ACTIVE_SLI_TOPOLOGY = -113,
     enumNvStatus_SLI_RENDERING_MODE_NOTALLOWED = -114,
     enumNvStatus_EXPECTED_DIGITAL_FLAT_PANEL = -115,
     enumNvStatus_ARGUMENT_EXCEED_MAX_SIZE = -116,
     enumNvStatus_DEVICE_SWITCHING_NOT_ALLOWED = -117,
     enumNvStatus_TESTING_CLOCKS_NOT_SUPPORTED = -118,
     enumNvStatus_UNKNOWN_UNDERSCAN_CONFIG = -119,
     enumNvStatus_TIMEOUT_RECONFIGURING_GPU_TOPO = -120,
     enumNvStatus_DATA_NOT_FOUND = -121,
     enumNvStatus_EXPECTED_ANALOG_DISPLAY = -122,
     enumNvStatus_NO_VIDLINK = -123,
     enumNvStatus_REQUIRES_REBOOT = -124,
     enumNvStatus_INVALID_HYBRID_MODE = -125,
     enumNvStatus_MIXED_TARGET_TYPES = -126,
     enumNvStatus_SYSWOW64_NOT_SUPPORTED = -127,
     enumNvStatus_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128,
     enumNvStatus_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129,
     enumNvStatus_OUT_OF_MEMORY = -130,
     enumNvStatus_WAS_STILL_DRAWING = -131,
     enumNvStatus_FILE_NOT_FOUND = -132,
     enumNvStatus_TOO_MANY_UNIQUE_STATE_OBJECTS = -133,
     enumNvStatus_INVALID_CALL = -134,
     enumNvStatus_D3D10_1_LIBRARY_NOT_FOUND = -135,
     enumNvStatus_FUNCTION_NOT_FOUND = -136
 };

 enum NvThermalController
 {
     enumNvThermalController_NONE = 0,
     enumNvThermalController_GPU_INTERNAL,
     enumNvThermalController_ADM1032,
     enumNvThermalController_MAX6649,
     enumNvThermalController_MAX1617,
     enumNvThermalController_LM99,
     enumNvThermalController_LM89,
     enumNvThermalController_LM64,
     enumNvThermalController_ADT7473,
     enumNvThermalController_SBMAX6649,
     enumNvThermalController_VBIOSEVT,
     enumNvThermalController_OS,
     enumNvThermalController_UNKNOWN = -1,
 };

 enum NvThermalTarget
 {
     enumNvThermalTarget_NONE = 0,
     enumNvThermalTarget_GPU = 1,
     enumNvThermalTarget_MEMORY = 2,
     enumNvThermalTarget_POWER_SUPPLY = 4,
     enumNvThermalTarget_BOARD = 8,
     enumNvThermalTarget_ALL = 15,
     enumNvThermalTarget_UNKNOWN = -1
 };

 typedef struct _NvSensor
 {
     NvThermalController Controller;
     unsigned int DefaultMinTemp;
     unsigned int DefaultMaxTemp;
     unsigned int CurrentTemp;
     NvThermalTarget Target;
 }NvSensor;

 typedef struct _NvGPUThermalSettings
 {
     unsigned int Version;
     unsigned int Count;
     NvSensor Sensor[MAX_THERMAL_SENSORS_PER_GPU];
 }NvGPUThermalSettings;

 typedef struct _NvClocks
 {
     unsigned int Version;
     unsigned int Clock[MAX_CLOCKS_PER_GPU];
 }NvClocks;

 typedef struct _NvPState
 {
     bool Present;
     int Percentage;
 }NvPState;

 typedef struct _NvPStates
 {
     unsigned int Version;
     unsigned int Flags;
     NvPState PStates[MAX_PSTATES_PER_GPU];
 }NvPStates;

 typedef struct _NvUsages
 {
     unsigned int Version;
     unsigned int Usages[MAX_USAGES_PER_GPU];
 }NvUsages;

 typedef struct _NvCooler
 {
     int Type;
     int Controller;
     int DefaultMin;
     int DefaultMax;
     int CurrentMin;
     int CurrentMax;
     int CurrentLevel;
     int DefaultPolicy;
     int CurrentPolicy;
     int Target;
     int ControlType;
     int Active;
 }NvCooler;

 typedef struct _NvGPUCoolerSettings
 {
     unsigned int Version;
     unsigned int Count;
     NvCooler Coolers[MAX_COOLER_PER_GPU];
 }NvGPUCoolerSettings;

 typedef struct _NvLevel
 {
     int Level;
     int Policy;
 }NvLevel;

 typedef struct _NvGPUCoolerLevels
 {
     unsigned int Version;
     NvLevel Levels[MAX_COOLER_PER_GPU];
 }NvGPUCoolerLevels;

 typedef struct _NvMemoryInfo
 {
     unsigned int Version;
     unsigned int Values[MAX_MEMORY_VALUES_PER_GPU];
 }NvMemoryInfo;

 typedef struct _NvDisplayDriverVersion
 {
     unsigned int Version;
     unsigned int DriverVersion;
     unsigned int BldChangeListNum;
     char szBuildBranch[SHORT_STRING_MAX];
     char szAdapter[SHORT_STRING_MAX];
 }NvDisplayDriverVersion;

 typedef int NvPhysicalGpuHandle;
 typedef int NvDisplayHandle;

 // 函数定义
 typedef void* (*nvapi_QueryInterfaceType)(unsigned int uiInterfaceID);
 typedef NvStatus (*NvAPI_InitializeType)();
 typedef NvStatus (*NvAPI_GPU_GetFullNameType)(const NvPhysicalGpuHandle gpuHandle, char *pszName);
 typedef NvStatus (*NvAPI_GPU_GetThermalSettingsType)(const NvPhysicalGpuHandle gpuHandle, int sensorIndex, NvGPUThermalSettings *pnvGPUThermalSettings);
 typedef NvStatus (*NvAPI_EnumNvidiaDisplayHandleType)(const int thisEnum, NvDisplayHandle *pDisplayHandle);
 typedef NvStatus (*NvAPI_GetPhysicalGPUsFromDisplayType)(const NvDisplayHandle displayHandle, NvPhysicalGpuHandle *pGpuHandles, unsigned int *pGpuCount);
 typedef NvStatus (*NvAPI_EnumPhysicalGPUsType)(NvPhysicalGpuHandle *pGpuHandles, int *pGpuCount);
 typedef NvStatus (*NvAPI_GPU_GetTachReadingType)(const NvPhysicalGpuHandle gpuHandle, int *pnValue);
 typedef NvStatus (*NvAPI_GPU_GetAllClocksType)(const NvPhysicalGpuHandle gpuHandle, NvClocks *pnvClocks);
 typedef NvStatus (*NvAPI_GPU_GetPStatesType)(const NvPhysicalGpuHandle gpuHandle, NvPStates *pnvPStates);
 typedef NvStatus (*NvAPI_GPU_GetUsagesType)(const NvPhysicalGpuHandle gpuHandle, NvUsages *pnvUsages);
 typedef NvStatus (*NvAPI_GPU_GetCoolerSettingsType)(const NvPhysicalGpuHandle gpuHandle, int coolerIndex, NvGPUCoolerSettings *pnvGPUCoolerSettings);
 typedef NvStatus (*NvAPI_GPU_SetCoolerLevelsType)(const NvPhysicalGpuHandle gpuHandle, int coolerIndex, NvGPUCoolerLevels *pnvGPUCoolerLevels);
 typedef NvStatus (*NvAPI_GPU_GetMemoryInfoType)(const NvDisplayHandle displayHandle, NvMemoryInfo *pnvMemoryInfo);
 typedef NvStatus (*NvAPI_GetDisplayDriverVersionType)(const NvDisplayHandle displayHandle, NvDisplayDriverVersion *pnvDisplayDriverVersion);
 typedef NvStatus (*NvAPI_GetInterfaceVersionStringType)(char *pszVersion);
 typedef NvStatus (*NvAPI_GPU_GetPCIIdentifiersType)(
     const NvPhysicalGpuHandle gpuHandle,
     unsigned int *puiDeviceId,
     unsigned int *puiSubSystemId,
     unsigned int *puiRevisionId,
     unsigned int *puiExtDeviceId
     );

 //*****************************以下是类内部使用的结构体************************************//
 /*
 * @brief GPU信息
 */
 typedef struct _GPU_INFO
 {
     NvPhysicalGpuHandle     nvGpuHandle;        // GPU句柄
     int                     nUsage;             // GPU占用率
 }GPU_INFO;

 /*
 * @brief 显卡信息
 */
 typedef struct _DISPLAY_CARD_INFO
 {
     NvDisplayHandle nvDisplayHandle;            // 显卡句柄
     int             nGpuCount;                  // Gpu个数
     DWORD           dwTotalMemory;              // 总显存大小（KB）
     DWORD           dwFreeMemory;               // 空闲显存大小（KB）

     GPU_INFO        sGpuInfo[MAX_GPU_NUM];      // GPU信息
 }DISPLAY_CARD_INFO;
 //*****************************************************************************************//

 /*
 * @brief 显卡相关信息（可用于导出的结构体）
 */
 typedef struct _DISPLAY_INFO
 {
     int         nGpuCount;                  // Gpu个数
     int         nGpuUsages[MAX_GPU_NUM];    // Gpu占用率
     DWORD       dwTotalMemory;              // 总显存大小（KB）
     DWORD       dwFreeMemory;               // 空闲显存大小（KB）
 }DISPLAY_INFO;

 class KGpuMon
 {
 public:
     KGpuMon(void);
     ~KGpuMon(void);

     BOOL Init();
     BOOL Unit();

     int GetDisplayCardCount();
     BOOL GetDisplayInfo(const int nCardIndex, DISPLAY_INFO *pDisplayInfo);
 private:
     int     EnumDisplayCards();
     BOOL    GetGpuHandles(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo);

     BOOL    GetDisplayCardGpuUsages(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo);
     BOOL    GetDisplayCardMemoryInfo(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo);
 private:
     nvapi_QueryInterfaceType m_pfnNvapi_QueryInterface;
     NvAPI_InitializeType m_pfnNvAPI_Initialize;
     NvAPI_GPU_GetFullNameType m_pfnNvAPI_GPU_GetFullName;
     NvAPI_GPU_GetThermalSettingsType m_pfnNvAPI_GPU_GetThermalSettings;
     NvAPI_EnumNvidiaDisplayHandleType m_pfnNvAPI_EnumNvidiaDisplayHandle;
     NvAPI_GetPhysicalGPUsFromDisplayType m_pfnNvAPI_GetPhysicalGPUsFromDisplay;
     NvAPI_EnumPhysicalGPUsType m_pfnNvAPI_EnumPhysicalGPUs;
     NvAPI_GPU_GetTachReadingType m_pfnNvAPI_GPU_GetTachReading;
     NvAPI_GPU_GetAllClocksType m_pfnNvAPI_GPU_GetAllClocks;
     NvAPI_GPU_GetPStatesType m_pfnNvAPI_GPU_GetPStates;
     NvAPI_GPU_GetUsagesType m_pfnNvAPI_GPU_GetUsages;
     NvAPI_GPU_GetCoolerSettingsType m_pfnNvAPI_GPU_GetCoolerSettings;
     NvAPI_GPU_SetCoolerLevelsType m_pfnNvAPI_GPU_SetCoolerLevels;
     NvAPI_GPU_GetMemoryInfoType m_pfnNvAPI_GPU_GetMemoryInfo;
     NvAPI_GetDisplayDriverVersionType m_pfnNvAPI_GetDisplayDriverVersion;
     NvAPI_GetInterfaceVersionStringType m_pfnNvAPI_GetInterfaceVersionString;
     NvAPI_GPU_GetPCIIdentifiersType m_pfnNvAPI_GPU_GetPCIIdentifiers;


     int                 m_nDisplayCardCount;
     DISPLAY_CARD_INFO*  m_pDisplayCards;
     HMODULE             m_hNvApiDll;
 };


 //**************************************************************************************************/
 // KGpuMon.cpp 源代码
 #include "StdAfx.h"
 #include "KGpuMon.h"

 KGpuMon::KGpuMon(void)
 {
     m_hNvApiDll = NULL;
     m_nDisplayCardCount = 0;
     m_pDisplayCards = NULL;
 }

 KGpuMon::~KGpuMon(void)
 {
     Unit();
 }

 BOOL KGpuMon::Init()
 {
     BOOL bResult = FALSE;
     BOOL bRetCode = FALSE;

     int nIndex = 0;
     int nResult = 0;

     m_hNvApiDll = LoadLibrary(_T("nvapi.dll"));
     if (m_hNvApiDll)
     {
         m_pfnNvapi_QueryInterface = (nvapi_QueryInterfaceType)GetProcAddress(m_hNvApiDll, "nvapi_QueryInterface");
         if (m_pfnNvapi_QueryInterface)
         {
             m_pfnNvAPI_Initialize = (NvAPI_InitializeType)m_pfnNvapi_QueryInterface(ID_NvAPI_Initialize);
             m_pfnNvAPI_GPU_GetFullName = (NvAPI_GPU_GetFullNameType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetFullName);
             m_pfnNvAPI_GPU_GetThermalSettings = (NvAPI_GPU_GetThermalSettingsType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetThermalSettings);
             m_pfnNvAPI_EnumNvidiaDisplayHandle = (NvAPI_EnumNvidiaDisplayHandleType)m_pfnNvapi_QueryInterface(ID_NvAPI_EnumNvidiaDisplayHandle);
             m_pfnNvAPI_GetPhysicalGPUsFromDisplay = (NvAPI_GetPhysicalGPUsFromDisplayType)m_pfnNvapi_QueryInterface(ID_NvAPI_GetPhysicalGPUsFromDisplay);
             m_pfnNvAPI_EnumPhysicalGPUs = (NvAPI_EnumPhysicalGPUsType)m_pfnNvapi_QueryInterface(ID_NvAPI_EnumPhysicalGPUs);
             m_pfnNvAPI_GPU_GetTachReading = (NvAPI_GPU_GetTachReadingType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetTachReading);
             m_pfnNvAPI_GPU_GetAllClocks = (NvAPI_GPU_GetAllClocksType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetAllClocks);
             m_pfnNvAPI_GPU_GetPStates = (NvAPI_GPU_GetPStatesType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetPStates);
             m_pfnNvAPI_GPU_GetUsages = (NvAPI_GPU_GetUsagesType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetUsages);
             m_pfnNvAPI_GPU_GetCoolerSettings = (NvAPI_GPU_GetCoolerSettingsType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetCoolerSettings);
             m_pfnNvAPI_GPU_SetCoolerLevels = (NvAPI_GPU_SetCoolerLevelsType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_SetCoolerLevels);
             m_pfnNvAPI_GPU_GetMemoryInfo = (NvAPI_GPU_GetMemoryInfoType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetMemoryInfo);
             m_pfnNvAPI_GetDisplayDriverVersion = (NvAPI_GetDisplayDriverVersionType)m_pfnNvapi_QueryInterface(ID_NvAPI_GetDisplayDriverVersion);
             m_pfnNvAPI_GetInterfaceVersionString = (NvAPI_GetInterfaceVersionStringType)m_pfnNvapi_QueryInterface(ID_NvAPI_GetInterfaceVersionString);
             m_pfnNvAPI_GPU_GetPCIIdentifiers = (NvAPI_GPU_GetPCIIdentifiersType)m_pfnNvapi_QueryInterface(ID_NvAPI_GPU_GetPCIIdentifiers);

             if (m_pfnNvAPI_Initialize)
             {
                 nResult = m_pfnNvAPI_Initialize();
                 if (enumNvStatus_OK == nResult)
                 {
                     m_pDisplayCards = new DISPLAY_CARD_INFO[MAX_DISPLAY_CARDS];
                     ZeroMemory(m_pDisplayCards, MAX_DISPLAY_CARDS * sizeof(DISPLAY_CARD_INFO));

                     // 获取显卡个数
                     nResult = EnumDisplayCards();
                     MY_PROCESS_ERROR(nResult > 0);

                     // 获取每块显卡的GPU个数
                     for (nIndex = 0; nIndex < m_nDisplayCardCount; ++nIndex)
                     {
                         bRetCode = GetGpuHandles(m_pDisplayCards[nIndex].nvDisplayHandle, &m_pDisplayCards[nIndex]);
                         MY_PROCESS_ERROR(bRetCode);
                     }

                     bResult = TRUE;
                 }
             }
         }
     }
 Exit0:
     return bResult;
 }

 BOOL KGpuMon::Unit()
 {
     m_nDisplayCardCount = 0;

     if (m_pDisplayCards)
     {
         delete []m_pDisplayCards;
         m_pDisplayCards = NULL;
     }

     if (m_hNvApiDll)
     {
         FreeLibrary(m_hNvApiDll);
         m_hNvApiDll = NULL;
     }

     return TRUE;
 }

 BOOL KGpuMon::GetDisplayInfo(const int nCardIndex, DISPLAY_INFO *pDisplayInfo)
 {
     BOOL bResult = FALSE;

     int nIndex = 0;

     if (nCardIndex < m_nDisplayCardCount)
     {
         bResult = GetDisplayCardGpuUsages(m_pDisplayCards[nCardIndex].nvDisplayHandle, &m_pDisplayCards[nCardIndex]);
         MY_PROCESS_ERROR(bResult);

         pDisplayInfo->nGpuCount = m_pDisplayCards[nCardIndex].nGpuCount;
         for (nIndex = 0; nIndex < pDisplayInfo->nGpuCount; ++nIndex)
         {
             pDisplayInfo->nGpuUsages[nIndex] = m_pDisplayCards[nCardIndex].sGpuInfo[nIndex].nUsage;
         }

         bResult = GetDisplayCardMemoryInfo(m_pDisplayCards[nCardIndex].nvDisplayHandle, &m_pDisplayCards[nCardIndex]);
         MY_PROCESS_ERROR(bResult);

         pDisplayInfo->dwTotalMemory = m_pDisplayCards[nCardIndex].dwTotalMemory;
         pDisplayInfo->dwFreeMemory = m_pDisplayCards[nCardIndex].dwFreeMemory;
     }
 Exit0:
     return bResult;
 }

 int KGpuMon::GetDisplayCardCount()
 {
     return m_nDisplayCardCount;
 }

 int KGpuMon::EnumDisplayCards()
 {
     NvStatus nvResult;
     NvDisplayHandle nvDisplayCardHandle;

     int nIndex = 0;

     m_nDisplayCardCount = 0;
     if (m_pfnNvAPI_EnumNvidiaDisplayHandle)
     {
         for (nIndex = 0; nIndex < MAX_DISPLAY_CARDS; ++nIndex)
         {
             nvResult = m_pfnNvAPI_EnumNvidiaDisplayHandle(nIndex, &nvDisplayCardHandle);
             if (enumNvStatus_OK == nvResult)
             {
                 m_pDisplayCards[m_nDisplayCardCount].nvDisplayHandle = nvDisplayCardHandle;
                 ++m_nDisplayCardCount;
             }
         }
     }

     return m_nDisplayCardCount;
 }

 BOOL KGpuMon::GetGpuHandles(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo)
 {
     BOOL bResult = FALSE;

     NvStatus nvStatus;
     NvPhysicalGpuHandle *pnvHandles = NULL;

     int nIndex = 0;
     unsigned int uiGpuCount = 0;

     if (m_pfnNvAPI_GetPhysicalGPUsFromDisplay)
     {
         pnvHandles = new NvPhysicalGpuHandle[MAX_PHYSICAL_GPUS];
         nvStatus = m_pfnNvAPI_GetPhysicalGPUsFromDisplay(nvDisplayHandle, pnvHandles, &uiGpuCount);
         if (enumNvStatus_OK == nvStatus)
         {
             pCardInfo->nGpuCount = min(uiGpuCount, MAX_GPU_NUM);
             for (nIndex = 0; nIndex < pCardInfo->nGpuCount; ++nIndex)
             {
                 pCardInfo->sGpuInfo[nIndex].nvGpuHandle = pnvHandles[nIndex];
             }

             bResult = TRUE;
         }

         delete []pnvHandles;
         pnvHandles = NULL;
     }

     return bResult;
 }

 BOOL KGpuMon::GetDisplayCardGpuUsages(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo)
 {
     BOOL bResult = FALSE;

     int nIndex = 0;

     NvStatus nvStatus = enumNvStatus_ERROR;
     NvUsages *pnvUsages = NULL;

     if (m_pfnNvAPI_GPU_GetUsages)
     {
         pnvUsages = new NvUsages;
         pnvUsages->Version = GPU_USAGES_VER;
         for (nIndex = 0; nIndex < pCardInfo->nGpuCount; ++nIndex)
         {
             nvStatus = m_pfnNvAPI_GPU_GetUsages(pCardInfo->sGpuInfo[nIndex].nvGpuHandle, pnvUsages);
             if (enumNvStatus_OK == nvStatus)
             {
                 pCardInfo->sGpuInfo[nIndex].nUsage = pnvUsages->Usages[2];
             }
         }

         delete pnvUsages;
         pnvUsages = NULL;

         bResult = (enumNvStatus_OK == nvStatus) ? TRUE : FALSE;
     }

     return bResult;
 }

 BOOL KGpuMon::GetDisplayCardMemoryInfo(const NvDisplayHandle nvDisplayHandle, DISPLAY_CARD_INFO *pCardInfo)
 {
     BOOL bResult = FALSE;

     int nIndex = 0;

     NvStatus nvStatus = enumNvStatus_ERROR;
     NvUsages *pnvUsages = NULL;
     NvMemoryInfo sMemoryInfo;

     if (m_pfnNvAPI_GPU_GetMemoryInfo)
     {
         sMemoryInfo.Version = GPU_MEMORY_INFO_VER;
         nvStatus = m_pfnNvAPI_GPU_GetMemoryInfo(nvDisplayHandle, &sMemoryInfo);
         if (enumNvStatus_OK == nvStatus)
         {
             pCardInfo->dwTotalMemory = (DWORD)(sMemoryInfo.Values[0]);
             pCardInfo->dwFreeMemory = (DWORD)(sMemoryInfo.Values[4]);

             bResult = TRUE;
         }
     }

     return bResult;
 }

注意：32位程序使用LoadLibiary加载的是“nvapi.dll”，64位程序要使用“nvapi64.dll”；

            记得先调用Init()；

     nviapi参考页：http://docs.nvidia.com/gameworks/content/gameworkslibrary/coresdk/nvapi/index.html