C++性能监视(CPU性能, GPU使用率, 磁盘读写速度, 网络速度)

已于 2024-10-17 08:04:11 修改
阅读量1.6k 收藏 13
点赞数 14
CC 4.0 BY-SA版权
分类专栏： Windows C++ Win32 文章标签： Win32 C++ 性能监控 CPU使用率 CPU频率 网络速率 GPU使用率
于 2024-09-19 21:28:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flame_Cyclone/article/details/142370112

CPerformHelper.h

#pragma once

#include <windows.h>
#include <tchar.h>
#include <string>
#include <pdh.h>
#include <string>
#include <mutex>
#include <thread>
#include <map>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

// CPU 使用率
#define PERFM_PATH_CPU_UTILITY              "\\Processor Information(_Total)\\% Processor Utility"

// CPU 性能
#define PERFM_PATH_CPU_PERFORMANCE          "\\Processor Information(_Total)\\% Processor Performance"

// CPU 主频
#define PERFM_PATH_CPU_FREQUENCY            "\\Processor Information(_Total)\\Processor Frequency"

// 磁盘读写
#define PERFM_PATH_DISK_READ_RATE           "\\PhysicalDisk(_Total)\\Disk Read Bytes/sec"
#define PERFM_PATH_DISK_WRITE_RATE          "\\PhysicalDisk(_Total)\\Disk Write Bytes/sec"

// 网络收发
#define PERFM_PATH_NETWORK_RECV_RATE        "\\Network Interface(*)\\Bytes Received/sec"
#define PERFM_PATH_NETWORK_SENT_RATE        "\\Network Interface(*)\\Bytes Sent/sec"

// GPU
#define PERFM_PATH_GPU_UTILITY              "\\GPU Engine(*)\\Utilization Percentage"

#ifdef UNICODE
using PerfMonInfo = std::map<std::wstring, HCOUNTER> ;
#else
using PerfMonInfo = std::map<std::string, HCOUNTER>;
#endif

class CPerformHelper
{
public:
    CPerformHelper();
    virtual ~CPerformHelper();

    // 初始化
    bool Initialize();
    
    // 反初始化
    void Uninitialize();

    // 添加性能计数器
    bool AddCounter(const _tstring& strCounterPath);

    // 移除性能计数器
    bool RemoveCounter(const _tstring& strCounterPath);

    // 设置性能采集时间间隔
    void SetCollectInterval(DWORD millisecond = 1000);

    // 获取性能计数器数值
    bool GetFormattedCounterValue(const _tstring&  strCounterPath, DWORD dwFormat, PPDH_FMT_COUNTERVALUE pValue);

    // 获取性能计数器数值数组
    bool GetFormattedCounterArray(const _tstring&  strCounterPath, DWORD dwFormat, PPDH_FMT_COUNTERVALUE pValue);

    // 开始采集数据
    bool StartCollect();

private:

    void _Sleep(int millisecond);

private:
    HQUERY m_hQuery;
    bool m_fQuit;
    DWORD m_msCollectInterval;
    std::mutex m_Mutex;
    PerfMonInfo m_hPerfMonInfos;
    std::thread m_task;
};

CPerformHelper.cpp

#include "CPerformHelper.h"
#include <pdh.h>
#include <pdhmsg.h>

#pragma comment(lib, "pdh.lib")

CPerformHelper::CPerformHelper()
    :
    m_fQuit(false),
    m_hQuery(NULL),
    m_msCollectInterval(1000)
{

}

CPerformHelper::~CPerformHelper()
{
    Uninitialize();
}

void CPerformHelper::_Sleep(int millisecond)
{
    do
    {
        const int span = 1;
        if (millisecond < span)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(millisecond));
            return;
        }

        clock_t tmBegin = clock();
        while (true)
        {
            if (::clock() - tmBegin > millisecond)
            {
                break;
            }

            if (m_fQuit)
            {
                break;
            }

            std::this_thread::sleep_for(std::chrono::milliseconds(span));
        }
    } while (false);
}

bool CPerformHelper::Initialize()
{
    PDH_STATUS status = ERROR_SUCCESS;
    if (NULL == m_hQuery)
    {
        status = PdhOpenQuery(NULL, 0, &m_hQuery);
    }

    if (ERROR_SUCCESS != status)
    {
        return false;
    }

    return true;
}

void CPerformHelper::Uninitialize()
{
    m_fQuit = true;
    if (m_task.joinable())
    {
        m_task.join();
    }
    m_fQuit = false;

    if (m_hQuery)
    {
        ::PdhCloseQuery(m_hQuery);
        m_hQuery = NULL;
    }

    for (auto& item : m_hPerfMonInfos)
    {
        if (NULL != item.second)
        {
            ::PdhRemoveCounter(item.second);
        }
    }

    m_hPerfMonInfos.clear();
}

bool CPerformHelper::AddCounter(const _tstring& strCounterPath)
{
    HCOUNTER hCounter = NULL;
    PDH_STATUS status = ERROR_SUCCESS;

    status = ::PdhAddCounter(m_hQuery, strCounterPath.c_str(), 0, &hCounter);

    if (ERROR_SUCCESS != status)
    {
        return false;
    }

    m_Mutex.lock();
    m_hPerfMonInfos.insert(std::make_pair(strCounterPath, hCounter));
    m_Mutex.unlock();

    return true;
}

bool CPerformHelper::RemoveCounter(const _tstring& szCounterPath)
{
    bool fResult = false;

    m_Mutex.lock();
    auto itFind = m_hPerfMonInfos.find(szCounterPath);

    if (itFind != m_hPerfMonInfos.end())
    {
        ::PdhRemoveCounter(itFind->second);
        m_hPerfMonInfos.erase(itFind);
        fResult = true;
    }

    m_Mutex.unlock();

    return fResult;
}

void CPerformHelper::SetCollectInterval(DWORD millisecond)
{
    if (millisecond < 100)
    {
        m_msCollectInterval = 100;
    }

    m_msCollectInterval = millisecond;
}

bool CPerformHelper::StartCollect()
{
    PDH_STATUS status = ERROR_SUCCESS;
    status = ::PdhCollectQueryData(m_hQuery);

    if (ERROR_SUCCESS != status)
    {
        return false;
    }

    m_task = std::move(std::thread([&]() {

        PDH_STATUS status = ERROR_SUCCESS;
        while ((ERROR_SUCCESS == status) && !m_fQuit)
        {
            status = ::PdhCollectQueryData(m_hQuery);
            if (ERROR_SUCCESS != status)
            {
                break;
            }

            _Sleep(m_msCollectInterval);
        }

        }));

    return ERROR_SUCCESS == status;
}

bool CPerformHelper::GetFormattedCounterValue(const _tstring& strCounterPath, DWORD dwFormat, PPDH_FMT_COUNTERVALUE pValue)
{
    PDH_STATUS status = ERROR_SUCCESS;

    auto itFind = m_hPerfMonInfos.find(strCounterPath);
    if (m_hPerfMonInfos.end() == itFind)
    {
        return false;
    }

    status = ::PdhGetFormattedCounterValue(
        itFind->second,
        dwFormat,
        (LPDWORD)NULL,
        pValue);

    return ERROR_SUCCESS == status;
}

bool CPerformHelper::GetFormattedCounterArray(const _tstring& strCounterPath, DWORD dwFormat, PPDH_FMT_COUNTERVALUE pValue)
{
    PPDH_FMT_COUNTERVALUE_ITEM pAryValue = NULL;
    PDH_STATUS status = ERROR_SUCCESS;
    DWORD dwBufferSize = 0;
    DWORD dwItemCount = 0;

    auto itFind = m_hPerfMonInfos.find(strCounterPath);
    if (m_hPerfMonInfos.end() == itFind)
    {
        return false;
    }

    do
    {
        status = ::PdhGetFormattedCounterArray(
            itFind->second,
            dwFormat,
            &dwBufferSize,
            &dwItemCount,
            NULL
        );

        if (PDH_MORE_DATA != status)
        {
            break;
        }

        pAryValue = (PPDH_FMT_COUNTERVALUE_ITEM)::HeapAlloc(::GetProcessHeap(), 0, dwBufferSize);
        if (NULL == pAryValue)
        {
            break;
        }

        status = ::PdhGetFormattedCounterArray(
            itFind->second,
            dwFormat,
            &dwBufferSize,
            &dwItemCount,
            pAryValue
        );

        PDH_FMT_COUNTERVALUE value = { 0 };
        for (int i = 0; i < dwItemCount; i++)
        {
            if (PDH_FMT_DOUBLE == dwFormat)
            {
                value.doubleValue += pAryValue[i].FmtValue.doubleValue;
            }
            if (PDH_FMT_LARGE == dwFormat)
            {
                value.largeValue += pAryValue[i].FmtValue.largeValue;
            }
            if (PDH_FMT_LONG == dwFormat)
            {
                value.longValue += pAryValue[i].FmtValue.longValue;
            }
        }

        if (pValue)
        {
            *pValue = value;
        }

    } while (false);

    if (pAryValue)
    {
        ::HeapFree(::GetProcessHeap(), 0, pAryValue);
    }

    return ERROR_SUCCESS == status;
}

main.cpp

#include <iostream>
#include "Win32Utils/CDeviceHelper.h"
#include "Win32Utils/CWmiQueryHelper.h"
#include "CPerformHelper.h"

#include "Win32Utils/CDeviceHelper.h"

// 数据单位
enum eUnitType
{
    eUT_Auto,   // 自动
    eUT_b,      // (2 ^ 000) Bit
    eUT_Kb,     // (2 ^ 010) Bit
    eUT_Mb,     // (2 ^ 020) Bit
    eUT_Gb,     // (2 ^ 030) Bit
    eUT_Tb,     // (2 ^ 040) Bit
    eUT_Pb,     // (2 ^ 050) Bit
    eUT_Eb,     // (2 ^ 060) Bit
    eUT_Zb,     // (2 ^ 070) Bit
    eUT_Yb,     // (2 ^ 080) Bit
    eUT_Bb,     // (2 ^ 090) Bit
    eUT_Nb,     // (2 ^ 100) Bit
    eUT_Db,     // (2 ^ 110) Bit
    eUT_Cb,     // (2 ^ 120) Bit
    eUT_Xb,     // (2 ^ 130) Bit

    eUT_B,      // Byte          2 ^ 000 Byte
    eUT_KB,     // Kilobyte      2 ^ 010 Byte 
    eUT_MB,     // Megabyte      2 ^ 020 Byte 
    eUT_GB,     // Gigabyte      2 ^ 030 Byte 
    eUT_TB,     // Terabyte      2 ^ 040 Byte 
    eUT_PB,     // Petabyte      2 ^ 050 Byte 
    eUT_EB,     // Exabyte       2 ^ 060 Byte 
    eUT_ZB,     // Zettabyte     2 ^ 070 Byte 
    eUT_YB,     // Yottabyte     2 ^ 080 Byte 
    eUT_BB,     // Brontobyte    2 ^ 090 Byte 
    eUT_NB,     // NonaByte      2 ^ 100 Byte 
    eUT_DB,     // DoggaByte     2 ^ 110 Byte 
    eUT_CB,     // corydonbyte   2 ^ 120 Byte 
    eUT_XB,     // Xerobyte      2 ^ 130 Byte
    eUT_Max
};

typedef struct _DATA_UNIT_INFO
{
    double value;           // 数值
    eUnitType eUnit;        // 单位
    _tstring strUnitStr;    // 单位字符串
    _tstring strOutput;     // 内容(数值 + 单位字符串)
}DATA_UNIT_INFO;

static DATA_UNIT_INFO FormatByteSize(
    double nBytesSize,                                      // 输入值
    eUnitType eSrcUnit = eUnitType::eUT_Auto,               // 原始单位
    eUnitType eDestUnit = eUnitType::eUT_Auto,              // 目标单位
    bool fHasUnits = true,                                  // 结果字符串数值添加单位
    bool fSpace = true,                                     // 结果字符串数值与单位之间添加空格
    int nInteger = 1,                                       // 整数部分长度
    int nPrecision = 1                                      // 小数部分长度
);

void ConsoleOutput(LPCTSTR pFormat, ...);
void ConsoleClear();

int main()
{
    setlocale(LC_ALL, "");

    std::vector<VIDEO_ADAPTER_DESC_INFO> vResult = CDeviceHelper::GetAllVideoAdapterDesc();

    CDeviceHelper obj;

    clock_t tmBegin = ::clock();
    DEVICE_INFO info = obj.GetDeviceInfo();
    clock_t tmEnd = ::clock();

    ConsoleOutput(_T("cost time: %d\r\n"), tmEnd - tmBegin);

    CPerformHelper perfmon;

    perfmon.Initialize();
    perfmon.SetCollectInterval(1000);
    perfmon.AddCounter(_T(PERFM_PATH_CPU_UTILITY));
    perfmon.AddCounter(_T(PERFM_PATH_DISK_READ_RATE));
    perfmon.AddCounter(_T(PERFM_PATH_DISK_WRITE_RATE));
    perfmon.AddCounter(_T(PERFM_PATH_CPU_PERFORMANCE));
    perfmon.AddCounter(_T(PERFM_PATH_CPU_FREQUENCY));
    perfmon.AddCounter(_T(PERFM_PATH_NETWORK_RECV_RATE));
    perfmon.AddCounter(_T(PERFM_PATH_NETWORK_SENT_RATE));
    perfmon.AddCounter(_T(PERFM_PATH_GPU_UTILITY));
    perfmon.AddCounter(_T(PERFM_PATH_GPU_MEMORY_DEDICATED_USAGE_UTILITY));
    perfmon.AddCounter(_T(PERFM_PATH_GPU_MEMORY_SHARE_USAGE_UTILITY));
    perfmon.AddCounter(_T(PERFM_PATH_GPU_MEMORY_TOTAL_COMMITTED_USAGE_UTILITY));
    perfmon.StartCollect();

    PDH_FMT_COUNTERVALUE value = { 0 };

    SIZE_T DedicatedVideoMemory = vResult[0].AdapterDesc.DedicatedVideoMemory;
    SIZE_T DedicatedSystemMemory = vResult[0].AdapterDesc.DedicatedSystemMemory;
    SIZE_T SharedSystemMemory = vResult[0].AdapterDesc.SharedSystemMemory;

    MEMORYSTATUSEX memStatus = { 0 };
    memStatus.dwLength = sizeof(MEMORYSTATUSEX);

    double lfFrequency = 0.0f;
    while (true)
    {
        ::GlobalMemoryStatusEx(&memStatus);

        ConsoleClear();
        ::SetConsoleCursorPosition(::GetStdHandle(STD_OUTPUT_HANDLE), { 0, 0 });

        //获取CPU占用率
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_CPU_UTILITY), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("CPU 利用率: %.2lf%% "), value.doubleValue);
            //ConsoleOutput(_T("\r\n"));
        }

        //获取CPU性能
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_CPU_FREQUENCY), PDH_FMT_DOUBLE, &value))
        {
            lfFrequency = value.doubleValue;
        }

        //获取CPU性能
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_CPU_PERFORMANCE), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("当前主频: %.2lf Ghz "), value.doubleValue / 100.0f * lfFrequency / 1000.0f);
            ConsoleOutput(_T("基准频率: %.2lf Ghz"), lfFrequency / 1000.0f);
            ConsoleOutput(_T("\r\n"));
        }

        //物理内存
        ConsoleOutput(_T("内存: %.1lf"), FormatByteSize(memStatus.ullTotalPhys - memStatus.ullAvailPhys, eUnitType::eUT_B, eUnitType::eUT_GB).value);
        ConsoleOutput(_T("/"));
        ConsoleOutput(_T("%s "), FormatByteSize(memStatus.ullTotalPhys, eUnitType::eUT_B, eUnitType::eUT_GB).strOutput.c_str());
        ConsoleOutput(_T("%.2lf%%"), (double)(memStatus.ullTotalPhys - memStatus.ullAvailPhys) * 100 /(double)memStatus.ullTotalPhys);
        ConsoleOutput(_T("\r\n"));


        //获取GPU占用率
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_GPU_UTILITY), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("GPU 利用率: %.1lf%%"), value.doubleValue);
            ConsoleOutput(_T("\r\n"));
        }

        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_GPU_MEMORY_DEDICATED_USAGE_UTILITY), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("专用 GPU 内存: %0.1lf"), FormatByteSize(value.doubleValue, eUnitType::eUT_B, eUnitType::eUT_GB).value);
            ConsoleOutput(_T("/%s"), FormatByteSize(DedicatedVideoMemory).strOutput.c_str());
            ConsoleOutput(_T("\r\n"));
        }

        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_GPU_MEMORY_SHARE_USAGE_UTILITY), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("共享 GPU 内存: %0.1lf"), FormatByteSize(value.doubleValue, eUnitType::eUT_B, eUnitType::eUT_GB).value);
            ConsoleOutput(_T("/%s"), FormatByteSize(SharedSystemMemory).strOutput.c_str());
            ConsoleOutput(_T("\r\n"));
        }

        //获取硬盘读速度
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_DISK_READ_RATE), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("磁盘 读取: %s/s "), FormatByteSize(value.doubleValue).strOutput.c_str());
        }

        //获取硬盘写速度
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_DISK_WRITE_RATE), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("磁盘 写入: %s/s"), FormatByteSize(value.doubleValue).strOutput.c_str());
            ConsoleOutput(_T("\r\n"));
        }

        //获取网络读速度
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_NETWORK_RECV_RATE), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("网络 接收: %sps "), FormatByteSize(value.doubleValue).strOutput.c_str());
        }

        //获取网络写速度
        if (perfmon.GetFormattedCounterArray(_T(PERFM_PATH_NETWORK_SENT_RATE), PDH_FMT_DOUBLE, &value))
        {
            ConsoleOutput(_T("网络 发送: %sps"), FormatByteSize(value.doubleValue).strOutput.c_str());
            ConsoleOutput(_T("\r\n"));
        }

        ConsoleOutput(_T("\r\n"));
        ::Sleep(1000);
    }

    return 0;
}

void ConsoleOutput(LPCTSTR pFormat, ...)
{
    size_t nCchCount = MAX_PATH;
    _tstring strResult(nCchCount, 0);
    va_list args;

    va_start(args, pFormat);

    do
    {
        //格式化输出字符串
        int nSize = _vsntprintf_s(&strResult[0], nCchCount, _TRUNCATE, pFormat, args);
        if (-1 != nSize)
        {
            HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
            CONSOLE_SCREEN_BUFFER_INFOEX ScreenBuffer = { 0 };
            ScreenBuffer.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX);

            ::GetConsoleScreenBufferInfoEx(console, &ScreenBuffer);

            // 如果在行开头写入文本, 则先清空当前行内容
            if (0 == ScreenBuffer.dwCursorPosition.X)
            {
                DWORD dwNumberOfCharsWritten = 0;
                ::FillConsoleOutputCharacter(
                    console, 
                    _T(' '), 
                    ScreenBuffer.dwMaximumWindowSize.X, 
                    { 0, ScreenBuffer.dwCursorPosition.Y },
                    &dwNumberOfCharsWritten
                );
            }

            ::WriteConsole(console, strResult.c_str(), nSize, NULL, NULL);
            break;
        }

        //缓冲大小超限终止
        if (nCchCount >= INT32_MAX)
        {
            break;
        }

        //重新分配缓冲
        nCchCount *= 2;
        strResult.resize(nCchCount);

    } while (true);

    va_end(args);
}

void ConsoleClear()
{
    HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFOEX ScreenBuffer = { 0 };
    ScreenBuffer.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX);

    ::GetConsoleScreenBufferInfoEx(console, &ScreenBuffer);

    for (SHORT i = ScreenBuffer.dwCursorPosition.Y; i < ScreenBuffer.dwMaximumWindowSize.Y; i++)
    {
        DWORD dwNumberOfCharsWritten = 0;
        ::FillConsoleOutputCharacter(
            console, 
            _T(' '), 
            ScreenBuffer.dwMaximumWindowSize.X, 
            { 0, ScreenBuffer.dwCursorPosition.Y },
            &dwNumberOfCharsWritten
        );
    }
}

DATA_UNIT_INFO FormatByteSize(
    double nBytesSize,
    eUnitType eSrcUnit/* = eUnitType::eUT_Auto*/,
    eUnitType eDestUnit/* = eUnitType::eUT_Auto*/,
    bool fHasUnits/* = true*/,
    bool fSpace/* = true*/,
    int nInteger/* = 1*/,
    int nPrecision/* = 3*/
)
{
    TCHAR szFormatBuf[MAX_PATH] = { 0 };
    TCHAR szResultBuf[MAX_PATH] = { 0 };
    DATA_UNIT_INFO dataUnitInfo;
    bool fSrcBit = false;
    bool fDestBit = false;

    LPCTSTR strUnitByteName[] = {
        _T("B"),
        _T("KB"),
        _T("MB"),
        _T("GB"),
        _T("TB"),
        _T("PB"),
        _T("EB"),
        _T("ZB"),
        _T("YB"),
        _T("BB"),
        _T("NB"),
        _T("DB"),
        _T("CB"),
        _T("XB"),
    };

    LPCTSTR strUnitBitName[] = {
        _T("b"),
        _T("Kb"),
        _T("Mb"),
        _T("Gb"),
        _T("Tb"),
        _T("Pb"),
        _T("Eb"),
        _T("Zb"),
        _T("Yb"),
        _T("Bb"),
        _T("Nb"),
        _T("Db"),
        _T("Cb"),
        _T("Xb"),
    };

    // 原始单位 比特 -> 字节
    if (eSrcUnit >= eUnitType::eUT_b && eSrcUnit < eUnitType::eUT_B)
    {
        fSrcBit = true;
        eSrcUnit = (eUnitType)(eSrcUnit + (eUnitType::eUT_B - eUnitType::eUT_b));
    }

    // 目标单位 比特 -> 字节
    if (eDestUnit >= eUnitType::eUT_b && eDestUnit < eUnitType::eUT_B)
    {
        fDestBit = true;
        eDestUnit = (eUnitType)(eDestUnit + (eUnitType::eUT_B - eUnitType::eUT_b));
    }

    // 原始单位转换
    for (int i = eUnitType::eUT_B; i < eSrcUnit; i++)
    {
        nBytesSize *= 1024.0f;
    }

    // 自动
    int nUnitTypeIndex = eUnitType::eUT_B;
    if (eUnitType::eUT_Auto == eDestUnit)
    {
        double nCurUnitSize = 1.0f;
        double nNextUnitSize = 1024.0f;
        int nUnitTypeMaxIndex = eUnitType::eUT_Max - 1;
        for (int i = 0; i < _countof(strUnitByteName) && nUnitTypeIndex < nUnitTypeMaxIndex; i++)
        {
            if ((nBytesSize >= nCurUnitSize && nBytesSize < nNextUnitSize) || 0 == nNextUnitSize || 0 == nBytesSize)
            {
                break;
            }

            nCurUnitSize *= 1024.0f;
            nNextUnitSize *= 1024.0f;
            nUnitTypeIndex++;
        }
        eDestUnit = (eUnitType)nUnitTypeIndex;
    }

    {
        ::_stprintf_s(szFormatBuf, _countof(szFormatBuf), _T("%%%d.%dlf"), nInteger + nPrecision + 1, nPrecision);
        double fUnitSize = 1.0f;
        for (int i = eUnitType::eUT_B; i < eDestUnit; i++)
        {
            fUnitSize *= 1024.0f;
        }

        if (fSrcBit)
        {
            fUnitSize *= 8.0f;
        }

        if (fDestBit)
        {
            nBytesSize *= 8.0f;
        }

        double lfResult = nBytesSize / fUnitSize;
        ::_stprintf_s(szResultBuf, _countof(szResultBuf), szFormatBuf, lfResult);
        dataUnitInfo.strOutput = szResultBuf;
        dataUnitInfo.value = lfResult;

        if (fHasUnits)
        {
            if (fSpace)
            {
                dataUnitInfo.strOutput += _T(" ");
            }

            if (fDestBit)
            {
                dataUnitInfo.strOutput += strUnitBitName[eDestUnit - eUnitType::eUT_B];
                dataUnitInfo.strUnitStr = strUnitBitName[eDestUnit - eUnitType::eUT_B];
                dataUnitInfo.eUnit = (eUnitType)(eDestUnit + (eUnitType::eUT_B - eUnitType::eUT_b));
            }
            else
            {
                dataUnitInfo.strOutput += strUnitByteName[eDestUnit - eUnitType::eUT_B];
                dataUnitInfo.strUnitStr = strUnitByteName[eDestUnit - eUnitType::eUT_B];
                dataUnitInfo.eUnit = eDestUnit;
            }
        }
    }

    return dataUnitInfo;
}

 仓库 

https://gitee.com/flame_cyclone/c_device_utils

⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 2961
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
Unity 面试篇|（四）Unity性能优化篇 【全面总结 | 持续更新】
热门推荐
游戏开发小Y的博客
01-12 10万+
Unity中，CPU准备好需要绘制的元素，对底层图形程序接口进行调用的过程，每次引擎准备数据并通知GPU的过程称为一次Draw Call。DrawCall越高对显卡的消耗就越大。降低DrawCall的方法：动态合批静态合批降低shader的等级特性场景优化策略——遮挡技术。rectMask2D替代Mask。
C++获取CPU使用率
qq_53304163的博客
03-25 1416
C++获取CPU利用率，内容精简，一看就会
c++获取cpu使用率（包含系统和单进程）
09-02
c++获取cpu使用率（包含系统和单进程）含多个例子 c++获取cpu使用率（包含系统和单进程）含多个例子 c++获取cpu使用率（包含系统和单进程）含多个例子
C++实现系统资源监控工具：CPU与内存占用
最新发布
weixin_29476595的博客
05-23 941
内存管理是软件开发中的一个基本而重要的课题，尤其是在需要高性能和资源敏感型的应用程序中，如资源监控工具。理解操作系统内存管理机制，以及如何在C++中有效管理内存，是优化应用程序性能的关键。
c++之cpu使用率
千霜的博客
06-12 2325
如何获取cpu使用率呢?这用到了系统api,也就是几个系统函数来获取系统信息. 首先介绍下GetSystemTimes()这个函数: BOOL WINAPI GetSystemTimes( _Out_opt_ LPFILETIME lpIdleTime, _Out_opt_ LPFILETIME lpKernelTime, _Out_opt_ LPFILETIME lpUser
检测C / C ++应用程序性能监视
02-23 575
随着AppDynamics Winter '16发布，AppDynamics现在支持通过监控SDK监控C / C ++应用程序，该监控SDK支持与其他支持语言相同的实时，端到端，用户到数据库性能可见性，以实现快速根 - 因为分析和问题解决。 C / C ++已经有一段时间了，它被认为是高性能应用程序的语言，主要是因为它编译为机器代码并直接与操作系统接口而没有中间层。 虽然多年来应用程序的复杂性...
google开源的C++性能分析工具 - gperftools
04-22 3930
gperftools是Google提供的一套工具，其中的一个功能是CPU profiler，用于分析程序性能，找到程序的性能瓶颈。 安装 gperftools：http://code.google.com/p/gperftools/downloads/list libunwind：http://download.savannah.gnu.org/releases/libunwind/ 64
主机系统性能监控C++
05-20
该程序为主机系统性能监控技术的C++编法，希望可以对有的人提供帮助吧。
Windows利用Pdh读取机器的磁盘，网络，CPU等信息
03-28
在Windows操作系统中，开发人员可以使用Performance Data Helper（Pdh）库来监控系统的各种性能指标，如磁盘使用情况、网络流量、IO读写速率以及CPU使用率等。Pdh是一个强大的API，允许C++程序员，尤其是使用MFC...
C++在高性能计算中如何提升运算效率
aronSandy的博客
04-25 1477
通过优化内存管理、利用并行计算、选择合适的编译器选项以及使用高效的算法和数学库，可以显著提升C++程序的运算效率。然而，高性能计算是一个复杂且不断发展的领域，需要不断地学习和探索新的技术和方法，以适应不断变化的计算需求。：对于需要进行大规模数值计算的任务，如图像处理、深度学习等，可以利用NVIDIA的CUDA架构进行GPU加速。：对于涉及数学运算的任务，如线性代数、矩阵运算等，可以使用专业的数学库来提高性能。编译器是将源代码转换为可执行文件的工具，选择合适的编译器选项可以对代码进行优化，提高运算效率。
C++获取CPU使用率源码
10-18
获取cpu使用率源码。
使用C++获取指定线程的CPU使用率
12-12
简单例子说明如何使用C++实现获取指定线程的CPU使用率
NodeJs的性能监控指标
阿超的博客
12-05 1176
最近一直在用 NestJs 开发一个企业级的商业化项目，对于要上线的项目，那必然就少不了性能监控了。了解这些指标对我们开发调优的时候至关重要。CPU 使用率CPU 负载(load)内存磁盘I/O吞吐量 （Throughput）每秒查询率 QPS（Query Per Second）日志监控/真实 QPS响应时间进程监控提示：以下是本篇文章正文内容，下面案例可供参考Node.js 的性能监控对构建高效、稳定的企业级应用至关重要。
C++ 简单的CPU使用率监控程序
摔断翅膀的鸟人
05-25 1800
主要代码如下： // test4.cpp : 定义控制台应用程序的入口点。 // 简单的监控指定程序列表的CPU使用率 #include "stdafx.h" #include<thread> #include <windows.h> #include <stdint.h> #include <tlhelp32.h> #include <stdio.h> #include <iostream> #include <ve.
在C/C++代码中使用windows性能监视器
qq_43668159的博客
02-12 1216
在C/C++代码中使用windows性能监视器
C++ CPU程序占用率高问题排查
lovely_yoshino的博客
12-29 8955
我们在之前介绍了使用Valgrind、perf、AddressSanitzer等工具来完成内存泄漏的检测，当然内存泄漏以外还有cpu的占用率变高这类问题。作者在这里提供几个方法来对C++程序中CPU程序占用率高问题排查。
c++ 计算cpu占用率
weixin_30905133的博客
01-24 964
计算CPU占用率就是获取系统总的内核时间 用户时间及空闲时间 其中空闲时间就是内核空转 所以内核时间包含空闲时间 然后计算 运行时间 = 内核时间 加 用户时间 减去 空闲时间 间隔时间 = 内核时间 加 用户时间 cpu使用率% =运行时间 /间隔时间 ; 无论单个进程cpu占用率还是系统整个cpu占用路 都是如此原理 核心代码就是如下几段 BOOL res = Get...
C++ Windows 获取CPU利用率【转】
weixin_30750335的博客
08-10 1389
原文：http://blog.youkuaiyun.com/maoxing63570/article/details/6919599 #include <windows.h> #include <stdio.h> #include <conio.h> #include <tchar.h> #include <pdh.h> #...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值