手册   游戏   WEB   字典   单词   在线工具  

c++ 实现 Windows 内存监视

问题描述

设计一个内存监视器, 能实时地显示当前系统中内存的使用情况, 包括系统地址空间的布局, 物理内存的使用情况; 能实时显示某个进程的虚拟地址空间布局和工作集信息等.

思路

获取系统信息

  1. SYSTEM_INFO
  2. typedef struct _SYSTEM_INFO {
  3.   union {
  4.     DWORD dwOemId;
  5.     struct {
  6.       Word wProcessorArchitecture;
  7.       Word wReserved;
  8.     } DUMMYSTRUCTNAME;
  9.   } DUMMYUNIONNAME;
  10.   DWORD     dwPageSize;
  11.   LPVOID    lpMinimumApplicationAddress;
  12.   LPVOID    lpMaximumApplicationAddress;
  13.   DWORD_PTR dwActiveProcessorMask;
  14.   DWORD     dwNumberOfProcessors;
  15.   DWORD     dwProcessorType;
  16.   DWORD     dwAllocationGranularity;
  17.   Word      wProcessorLevel;
  18.   Word      wProcessorRevision;
  19. } SYSTEM_INFO, *LPSYSTEM_INFO;
  20. GetNativeSystemInfo

注意 INTELx86_64 体系最好用这个函数. 其他的等价于 GetSystemInfo

  1. void GetNativeSystemInfo(
  2.   LPSYSTEM_INFO lpSystemInfo
  3. );

LPSYSTEM_INFO 指向 SYSTEM_INFO 的指针

信息输出

  1. DWORD mem_size = (DWORD*)si.lpMaximumApplicationAddress - (DWORD*)si.lpMinimumApplicationAddress;
  2.  printDword(L"处理器个数", si.dwNumberOfProcessors);
  3.  printStrFormatByte(L"物理页大小", si.dwPageSize);
  4.  printAddress(L"进程最小寻址空间:        0x", si.lpMinimumApplicationAddress);
  5.  printAddress(L"进程最大寻址地址:         0x", si.lpMaximumApplicationAddress);
  6.  printStrFormatByte(L"进程可用空间大小:", mem_size);

注意这里的 print*** 是自定义函数.

展示

获取物理内存信息

主要使用到的数据结构和函数有 MEMORYSTATUSEX 与 GlobalMemoryStatusEx, PERFORMANCE_INFORMATION 与 GetPerformanceInfo

  1. MEMORYSTATUSEX
  2. typedef struct _MEMORYSTATUSEX {
  3.   DWORD     dwLength;
  4.   DWORD     dwMemoryLoad;
  5.   DWORDLONG ullTotalPhys;
  6.   DWORDLONG ullAvailPhys;
  7.   DWORDLONG ullTotalPageFile;
  8.   DWORDLONG ullAvailPageFile;
  9.   DWORDLONG ullTotalVirtual;
  10.   DWORDLONG ullAvailVirtual;
  11.   DWORDLONG ullAvailExtendedVirtual;
  12. } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;

注意在使用该数据结构之前, dwLength 必须进行指定, dwLength = sizeof(MEMORYSTATUSEX)

  1. GlobalMemoryStatusEx
  2. BOOL GlobalMemoryStatusEx(
  3.   LPMEMORYSTATUSEX lpBuffer
  4. );

lpBuffer 是指向 MEMORYSTAUSEX 的指针, 用于保存信息.

  1. PERFORMANCE_INFORMATION
  2. typedef struct _PERFORMANCE_INFORMATION {
  3.   DWORD  cb;
  4.   SIZE_T CommitTotal;
  5.   SIZE_T CommitLimit;
  6.   SIZE_T CommitPeak;
  7.   SIZE_T PhysicalTotal;
  8.   SIZE_T PhysicalAvailable;
  9.   SIZE_T SystemCache;
  10.   SIZE_T KernelTotal;
  11.   SIZE_T KernelPaged;
  12.   SIZE_T KernelNonpaged;
  13.   SIZE_T PageSize;
  14.   DWORD  HandleCount;
  15.   DWORD  ProcessCount;
  16.   DWORD  ThreadCount;
  17. } PERFORMANCE_INFORMATION, *PPERFORMANCE_INFORMATION, PERFORMACE_INFORMATION, *PPERFORMACE_INFORMATION;
  18. GetPerformanceInfo
  19. BOOL GetPerformanceInfo(
  20.   PPERFORMANCE_INFORMATION pPerformanceInformation,
  21.   DWORD                    cb
  22. );
  23. pPerformanceInformation

指向用于保存返回信息的指针

cb 需要指明

PERFORMANCE_INFORMATION

结构体的大小

效果展示

获取所有进程的基本信息

主要过程是先获取所有进程的一个 snapshot, 由于进程信息和数量是动态变化的, 所以需要先获取一个静态的信息集; 其次, 类似于目录检索对 snapshot 进行顺序检索, 获取进程信息.

创建进程 snapshot

  1. CreateToolhelp32Snapshot
  2. HANDLE CreateToolhelp32Snapshot(
  3.   DWORD dwFlags,
  4.   DWORD th32ProcessID
  5. );

DWORD dwFlags 用于表明该函数获取多少有关属性到 snapshot 中. 具体说明可参考 MSDN, 这里选用的参数是 TH32CS_SNAPALL

DWORD th32ProcessID 需要获取的进程的 pid.0 表示是最近的进程.

遍历进程

数据结构: PROCESSENTRY32

  1. API: Process32First Process32Next
  2. PROCESSENTRY32
  3. typedef struct tagPROCESSENTRY32 {
  4.   DWORD     dwSize;
  5.   DWORD     cntUsage;
  6.   DWORD     th32ProcessID;
  7.   ULONG_PTR th32DefaultHeapID;
  8.   DWORD     th32ModuleID;
  9.   DWORD     cntThreads;
  10.   DWORD     th32ParentProcessID;
  11.   LONG      pcPriClassBase;
  12.   DWORD     dwFlags;
  13.   TCHAR     szExeFile[MAX_PATH];
  14. } PROCESSENTRY32, *PPROCESSENTRY32;

注意在使用前必须指定 dwSize = sizeof(PROCESSENTRY32)

  1. Process32First
  2. BOOL Process32First(
  3.   HANDLE           hSnapshot,
  4.   LPPROCESSENTRY32 lppe
  5. );

HANDEL hSnapshot 就是从上述

CreateToolhelp32Snapshot

获得的.

LPPROCESSENTRY32 lppe

就是 PROCESSENTRY32 的指针

  1. Process32Next
  2. BOOL Process32Next(
  3.   HANDLE           hSnapshot,
  4.   LPPROCESSENTRY32 lppe
  5. );

含义同上. 其中 hSnapshot 是同一个, 不同的是 lppe 此时有了值, 用于保存当前项的下一项的进程的状态信息.

效果展示

获取单个进程的详细信息

使用到的主要数据结构有: SYSTEM_INFO (已介绍),MEMORY_BASIC_INFORMATION,

使用到的主要 API 有: GetNativeSystemInfo(已介绍),VirtualQueryEx, OpenProcess

  1. MEMORY_BASIC_INFORMATION
  2. typedef struct _MEMORY_BASIC_INFORMATION {
  3.   PVOID  BaseAddress;
  4.   PVOID  AllocationBase;
  5.   DWORD  AllocationProtect;
  6.   SIZE_T RegionSize;
  7.   DWORD  State;
  8.   DWORD  Protect;
  9.   DWORD  Type;
  10. } MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;

PVOID BaseAddress 页面区域的基地址

DWORD AllocationProtect;

如果这个页面区域是初始获取的, 这里就是其页面区域的保护方式

SIZE_T RegionSize 当前块的大小

DWORD State 当前页面块的状态, MEM_COMMIT MEME_FREE MEM_RESERVE 三种状态

DWORD Protect 当前块中的页面访问方式

DWORD Type 块类型, 三种 MEM_IMAGE MEM_MAPPED MEM_PRIVATE

  1. OpenProcess
  2. HANDLE OpenProcess(
  3.   DWORD dwDesiredAccess,
  4.   BOOL  bInheritHandle,
  5.   DWORD dwProcessId
  6. );
  7. DWORD dwDesiredAccess

访问该进程的方式, 我这里选用的是 PROCESS_ALL_ACCESS

BOOL bInheritHandle 如果为真, 该进程的子进程也将继承该函数的返回句柄

DWORD dwProcessId 要打开的进程的 PID

  1. VirtualQueryEx
  2. SIZE_T VirtualQueryEx(
  3.   HANDLE                    hProcess,
  4.   LPCVOID                   lpAddress,
  5.   PMEMORY_BASIC_INFORMATION lpBuffer,
  6.   SIZE_T                    dwLength
  7. );

hProcess 要查询的进程的句柄

lpAddress 要查询的进程的虚存的块的基地址

lpBuffer 指向要保存相关信息的数据的指针就是上文提到的

  1. MEMORY_BASIC_INFORMATION
  2. dwLength = sizeof(MEMORY_BASIC_INFORMATION)

效果展示

实现的功能如下, 具体的展示已在上文说明.

源代码

  1. #include <iostream>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <tchar.h>
  5. #include <iomanip>
  6. #include <Windows.h>
  7. #include <Tlhelp32.h>
  8. #include <shlwapi.h>
  9. #include <Psapi.h>
  10. #pragma comment(lib,"Shlwapi.lib")
  11. #pragma comment(lib, "Psapi.Lib")
  12. #pragma comment(lib,"Kernel32.lib")
  13. using namespace std;
  14. enum ProgramState { QUERY_SYS_INFO, QUERY_MEM_INFO, QUERY_PRE_INFO, EXIT };
  15. // 查询系统配置信息
  16. void getSystemInfo();
  17. // 物理内存使用情况
  18. void getMemoryInfo();
  19. // 打印所有进程的基本信息
  20. void getProcessInfo();
  21. // 获得单个内存的使用情况
  22. void showSingleProcessMemDetail(int PID);
  23. void help();
  24. int main()
  25. {
  26.     setlocale(LC_ALL, "");
  27.     int state = ProgramState::EXIT;// 默认为退出状态
  28.     while (1)
  29.     {
  30.         help();
  31.         std::cout.fill(' ');
  32.         std::cout.setf(iOS::dec);// 确保 cout 输出为十进制
  33.         cin>> state;
  34.         std::cout <<"\n";
  35.         if (state == ProgramState::QUERY_SYS_INFO)
  36.         {
  37.             getSystemInfo();
  38.         }
  39.         else if (state == ProgramState::QUERY_MEM_INFO)
  40.         {
  41.             getMemoryInfo();
  42.         }
  43.         else if (state == ProgramState::QUERY_PRE_INFO)
  44.         {
  45.             getProcessInfo();  // 当前所有运行进程基本信息
  46.             std::cout << "输入进程 PID 以查看其虚拟内存信息" << endl;
  47.             int PID;
  48.             cin>> PID;
  49.             showSingleProcessMemDetail(PID);
  50.         }
  51.         else if (state == ProgramState::EXIT)
  52.         {
  53.             return 0;    // 结束程序的运行
  54.         }
  55.     }
  56.     return 0;
  57. }
  58. // 将字节数转为字符串打印输出
  59. inline void printStrFormatByte(const WCHAR* info, DWORDLONG bytes)
  60. {
  61.     TCHAR tmp[MAX_PATH];
  62.     ZeroMemory(tmp, sizeof(tmp));
  63.     StrFormatByteSize(bytes, tmp, MAX_PATH);
  64.     wcout << info << tmp << endl;
  65.     return;
  66. }
  67. // 打印地址
  68. inline void printAddress(const WCHAR* info, LPVOID addr)
  69. {
  70.     wcout << info << hex << setw(8) << addr << endl;
  71. }
  72. inline void printDword(const WCHAR* info, DWORDLONG dw)// 将 DWORD 转为 DWORDLONG
  73. {
  74.     wcout << info;
  75.     std::cout << dw << endl;
  76. }
  77. // 查询系统配置信息
  78. void getSystemInfo()
  79. {
  80.     SYSTEM_INFO si;
  81.     ZeroMemory(&si, sizeof(si));
  82.     GetNativeSystemInfo(&si);
  83.     DWORD mem_size = (DWORD*)si.lpMaximumApplicationAddress - (DWORD*)si.lpMinimumApplicationAddress;
  84.     printDword(L"处理器个数", si.dwNumberOfProcessors);
  85.     printStrFormatByte(L"物理页大小", si.dwPageSize);
  86.     printAddress(L"进程最小寻址空间:        0x", si.lpMinimumApplicationAddress);
  87.     printAddress(L"进程最大寻址地址:         0x", si.lpMaximumApplicationAddress);
  88.     printStrFormatByte(L"进程可用空间大小:", mem_size);
  89.     return;
  90. }
  91. // 物理内存使用情况
  92. void getMemoryInfo()
  93. {
  94.     MEMORYSTATUSEX mem_stat;
  95.     ZeroMemory(&mem_stat, sizeof(mem_stat));
  96.     mem_stat.dwLength = sizeof(mem_stat);// 必须执行这一步
  97.     GlobalMemoryStatusEx(&mem_stat); // 取得内存状态
  98.     std::cout << "内存利用率        \t" << mem_stat.dwMemoryLoad << endl;
  99.     printStrFormatByte(L"物理内存:        \t", mem_stat.ullTotalPhys);
  100.     printStrFormatByte(L"可用物理内存:      \t", mem_stat.ullAvailPhys);
  101.     printStrFormatByte(L"总共页文件大小:    \t", mem_stat.ullTotalPageFile);
  102.     printStrFormatByte(L"空闲页文件大小:    \t", mem_stat.ullAvailPageFile);
  103.     printStrFormatByte(L"虚拟内存大小:    \t", mem_stat.ullTotalVirtual);
  104.     printStrFormatByte(L"空闲虚拟内存大小:\t", mem_stat.ullAvailVirtual);
  105.     printStrFormatByte(L"空闲拓展内存大小:\t", mem_stat.ullAvailExtendedVirtual);
  106.     cout << endl << endl;
  107.     PERFORMANCE_INFORMATION pi;
  108.     GetPerformanceInfo(&pi, sizeof(pi));
  109.     DWORDLONG page_size = pi.PageSize;
  110.     printStrFormatByte(L"Commit Total           \t", pi.CommitTotal * page_size);
  111.     printStrFormatByte(L"Commit Limit           \t", pi.CommitLimit * page_size);
  112.     printStrFormatByte(L"Commit Peak            \t", pi.CommitPeak * page_size);
  113.     printStrFormatByte(L"Physical Memory        \t", pi.PhysicalTotal * page_size);
  114.     printStrFormatByte(L"Physical Memory Avaliable", pi.PhysicalAvailable * page_size);
  115.     printStrFormatByte(L"System Cache           \t", page_size*pi.SystemCache);
  116.     printStrFormatByte(L"Kerbel Total           \t", page_size * pi.KernelTotal);
  117.     printStrFormatByte(L"Kernel Paged           \t", page_size * pi.KernelPaged);
  118.     printStrFormatByte(L"Kernel Nonpaged        \t", page_size * pi.KernelNonpaged);
  119.     printStrFormatByte(L"Page Size              \t", page_size * pi.PageSize);
  120.     printDword(L"Handle Count           \t", page_size * pi.HandleCount);
  121.     printDword(L"Process Count          \t", page_size * pi.ProcessCount);
  122.     printDword(L"Thread Count           \t", page_size * pi.ThreadCount);
  123. }
  124. // 打印所有进程的基本信息
  125. void getProcessInfo()
  126. {
  127.     // 创建进程 snapshot
  128.     HANDLE h_process_snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
  129.     if (h_process_snapshot == INVALID_HANDLE_VALUE)
  130.     {
  131.         cout << "CreateToolhelp32Snapshot 调用失败!\n";
  132.         exit(-1);
  133.     }
  134.     PROCESSENTRY32 process_entry;
  135.     process_entry.dwSize = sizeof(process_entry);// 必须要指定大小
  136.     // 循环遍历输出所有进程的信息
  137.     if (Process32First(h_process_snapshot, &process_entry))
  138.     {
  139.         wcout << setiosflags(iOS::left) << setw(40) << L"Process Name";
  140.         cout << setiosflags(iOS::right) << setw(15) << "PID";
  141.         wcout << L"\t\t 线程数量" << endl << endl;
  142.         do
  143.         {
  144.             wcout << setiosflags(iOS::left) << setw(40) << process_entry.szExeFile;// 进程名
  145.             std::cout << "\t" << setw(7) << process_entry.th32ProcessID;//pid
  146.             std::cout << "\t" << setw(3) << process_entry.cntThreads << endl;// 线程数目
  147.         } while (Process32Next(h_process_snapshot, &process_entry));
  148.     }
  149.     CloseHandle(h_process_snapshot);
  150. }
  151. // 显示当前块页面访问方式
  152. void printPageProtection(DWORD dwTarget)
  153. {
  154.     const int width = 20;
  155.     switch (dwTarget)
  156.     {
  157.     case(PAGE_READONLY):
  158.     {
  159.         std::cout << setiosflags(iOS::left) << setw(width) << "READONLY";
  160.         break;
  161.     }
  162.     case(PAGE_GUARD):
  163.     {
  164.         std::cout << setiosflags(iOS::left) << setw(width) << "GUARD";
  165.         break;
  166.     }
  167.     case(PAGE_NOCACHE):
  168.     {
  169.         std::cout << setiosflags(iOS::left) << setw(width) << "NOCACHE";
  170.         break;
  171.     }
  172.     case(PAGE_NOACCESS):
  173.     {
  174.         std::cout << setiosflags(iOS::left) << setw(width) << "NOACCESS";
  175.         break;
  176.     }
  177.     case(PAGE_READWRITE):
  178.     {
  179.         std::cout << setiosflags(iOS::left) << setw(width) << "READWRITE";
  180.         break;
  181.     }
  182.     case(PAGE_WRITECOPY):
  183.     {
  184.         std::cout << setiosflags(iOS::left) << setw(width) << "WRITECOPY";
  185.         break;
  186.     }
  187.     case(PAGE_EXECUTE):
  188.     {
  189.         std::cout << setiosflags(iOS::left) << setw(width) << "EXECUTE";
  190.         break;
  191.     }
  192.     case(PAGE_EXECUTE_READ):
  193.     {
  194.         std::cout << setiosflags(iOS::left) << setw(width) << "EXECUTE_READ";
  195.         break;
  196.     }
  197.     case(PAGE_EXECUTE_READWRITE):
  198.     {
  199.         std::cout << setiosflags(iOS::left) << setw(width) << "EXECUTE_READWRITE";
  200.         break;
  201.     }
  202.     case(PAGE_EXECUTE_WRITECOPY):
  203.     {
  204.         std::cout << setiosflags(iOS::left) << setw(width) << "EXECUTE_WRITECOPY";
  205.         break;
  206.     }
  207.     default:
  208.         break;
  209.     }
  210. }
  211. // 输出单个进程的详细信息
  212. void showSingleProcessMemDetail(int PID)
  213. {
  214.     SYSTEM_INFO si;
  215.     ZeroMemory(&si, sizeof(si));
  216.     GetNativeSystemInfo(&si);           // 获得系统信息
  217.     // 循环访问整个进程地址空间
  218.     LPCVOID p_begin = (LPVOID)si.lpMinimumApplicationAddress; //p_begin 指向开始的地址
  219.     std::cout.setf(iOS::left);
  220.     // 输出表头
  221.     wcout << setiosflags(iOS::left) << setw(21) << L"块地址"
  222.         << setw(10) << L"块大小"
  223.         << setw(10) << L"块内页状态"
  224.         << setw(12) << L"块内页保护方式"
  225.         << setw(10) << L"块类型" << endl;
  226.     HANDLE h_process = OpenProcess(PROCESS_ALL_ACCESS, 0, PID); // 得到 PID 的值
  227.     if (h_process == INVALID_HANDLE_VALUE)
  228.     {
  229.         std::cout << "Failed to OpenProcess" << endl;
  230.         exit(-1);
  231.     }
  232.     MEMORY_BASIC_INFORMATION mem;    // 虚拟内存空间的基本信息结构
  233.     ZeroMemory(&mem, sizeof(mem));
  234.     while (p_begin < (LPVOID)si.lpMaximumApplicationAddress)
  235.     {
  236.         // 查询进程在 p_begin 开始的块信息
  237.         VirtualQueryEx(
  238.             h_process,                       // 进程句柄
  239.             p_begin,                         // 开始位置的地址
  240.             &mem,                           // 缓冲区
  241.             sizeof(mem));
  242.         // 块结束地址
  243.         LPCVOID p_end = (PBYTE)p_begin + mem.RegionSize;
  244.         // 输出块起始, 结束地址
  245.         std::cout << hex << setw(8) << setfill('0') << (DWORD*)p_begin
  246.             << "-"
  247.             << hex << setw(8) << setfill('0') << (DWORD*)p_end;
  248.         // 输出块大小
  249.         TCHAR tmp[MAX_PATH];
  250.         ZeroMemory(tmp, sizeof(tmp));
  251.         StrFormatByteSize(mem.RegionSize, tmp, MAX_PATH);
  252.         std::wcout << "\t" << setw(8) << tmp;
  253.         // 输出块的状态
  254.         std::cout.fill(' ');
  255.         if (mem.State == MEM_COMMIT)
  256.         {
  257.             std::cout << setw(10) << "已提交";
  258.         }
  259.         else if (mem.State == MEM_FREE)
  260.         {
  261.             std::cout << setw(10) << "空闲";
  262.         }
  263.         else if (mem.State == MEM_RESERVE)
  264.         {
  265.             std::cout << setw(10) << "保留";
  266.         }
  267.         // 显示块内页的保护方式
  268.         if (mem.Protect == 0 && mem.State != MEM_FREE)
  269.         {
  270.             mem.Protect = PAGE_READONLY;
  271.         }
  272.         printPageProtection(mem.Protect);
  273.         // 显示块的类型 邻近页面物理存储器类型指的是与给定地址所在页面相同的存储器类型
  274.         std::cout.fill(' ');
  275.         if (mem.Type == MEM_IMAGE)
  276.         {
  277.             std::cout << "\t\tImage";
  278.         }
  279.         else if (mem.Type == MEM_PRIVATE)
  280.         {
  281.             std::cout << "\t\tPrivate";
  282.         }
  283.         else if (mem.Type == MEM_MAPPED)
  284.         {
  285.             std::cout << "\t\tMapped";
  286.         }
  287.         cout << endl;
  288.         // 移动块指针获得下一个块
  289.         if (p_begin == p_end)// 部分进程如 0 号进程无法进行空间遍历
  290.             break;
  291.         p_begin = p_end;
  292.     }
  293. }
  294. void help()
  295. {
  296.     std::cout << "\n\nMenu:" << endl
  297.         << ProgramState::QUERY_SYS_INFO << "- 查看系统信息" << endl
  298.         << ProgramState::QUERY_MEM_INFO << "- 查看内存情况" << endl
  299.         << ProgramState::QUERY_PRE_INFO << "- 查看当前运行进程信息及其虚拟地址空间布局和工作集信息" << endl
  300.         << ProgramState::EXIT << "- 退出 \ n\n";
  301. }

来源: http://www.bubuko.com/infodetail-3355113.html


与本文相关文章

  1. 共享内存
  2. 虚拟内存探究 -- 第一篇: C strings & /proc
  3. spring 监控 (九)-JVM 内存监控
  4. 消耗内存
  5. Two Sum Closest(App 前后端内存版)
  6. C++: 五种内存分配区域
  7. scull 的内存使用
  8. __block 内存管理
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1