内存监视

最新推荐文章于 2025-04-26 14:18:32 发布
原创 最新推荐文章于 2025-04-26 14:18:32 发布 · 5.6k 阅读 · 48 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#BIT #OS #EXP
本文档详述了一个Windows内存监视器的实现，包括实验目的、内容和环境，重点介绍了数据结构如内存状态、系统信息和性能信息结构体，以及Windows API的使用，如检索内存使用、获取系统信息和性能等功能，旨在理解Windows内存管理和虚拟内存机制。

内存监视

1. 实验目的

熟悉Windows存储器管理中提供的各类机制和实现的请求调页技术。

通过实验，了解Windows内存结构和虚拟内存管理，学习如何在应用程序中管理内存。了解当前系统中内存的使用情况，包括系统地址空间的布局，物理内存的使用情况；能够实时显示某个进程的虚拟地址空间布局和工作集信息等

2. 实验内容

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

相关的系统调用：

  • GetSystemInfo
  • VirtualQueryEx
  • VirtualAlloc
  • GetPerformanceInfo
  • GlobalMemoryStatusEx

3. 实验环境

本实验基于本机macOS系统下的Windows虚拟机完成，具体实验环境如下：

3.1 宿主机环境

宿主机环境配置如下：

  • 操作系统：macOS
  • 内存容量：8GB
  • 处理器：2.9GHz Intel Core i5
  • 硬盘容量：500GB

3.2 虚拟机环境

Windows虚拟机环境配置如下：

  • 虚拟机软件：VMware Fusion 11
  • 虚拟机操作系统：Windows 7 旗舰版
  • 虚拟机内存：4GB
  • 虚拟机硬盘容量：60GB

4. 程序设计和实现

4.1 实验原理

内存指的是计算机配置的RAM，系统可以管理所有的物理内存。操作系统（本实验特指Windows）通过分配RAM、页面文件或者二者中的空间，可以准确获取应用程序需要的内存

在Windows下运行的每个应用程序都认为能够独占4GB的虚拟地址空间，其中，低2GB为进程私有地址空间，用于存放程序和动态链接库，高2GB为所有进程共享区，也就是操作系统占用区。

事实上，少有进程可以占有2GB存储空间。Windows把每个进程的虚拟内存地址映射为物理内存地址。

4.2 数据结构介绍

内存状态结构体

Windows中使用MEMORYSTATUSEX结构体表示内存状态

该结构题包含了物理内存和虚拟内存的现有信息

语法结构如下：

typedef struct _MEMORYSTATUSEX {
  DWORD     dwLength;
  DWORD     dwMemoryLoad;
  DWORDLONG ullTotalPhys;
  DWORDLONG ullAvailPhys;
  DWORDLONG ullTotalPageFile;
  DWORDLONG ullAvailPageFile;
  DWORDLONG ullTotalVirtual;
  DWORDLONG ullAvailVirtual;
  DWORDLONG ullAvailExtendedVirtual;
} MEMORYSTATUSEX, *LPMEMORYSTATUSEX;

说明：

  • dwLength：结构体大小，需要在调用GlobalMemoryStatusEx之前设定
  • dwMemoryLoad：物理内存使用的百分比（从0到100）
  • ullTotalPhys：实际物理内存的大小（单位：字节）
  • ullAvailPhys：现在可用的物理内存大小（单位：字节）这部分物理内存是可以不需要写入磁盘立即被回收的内存。它是备用，空闲和零列表大小的综合
  • ullTotalPageFile：系统或当前进程已经提交的内存限制中的较小者（单位：字节）。要获取系统范围的已提交内存限制需要调用GetPerformanceInfo
  • ullAvailPageFile：当前进程可以提交的最大内存量（单位：字节）
  • ullTotalVirtual：调用进程的虚拟地址空间的用户模式部分的大小（单位：字节）。此值取决于进程类型，处理机类型和操作系统配置，在x86处理器上多为2GB
  • ullAvailVirtual：当前调用进程的虚拟地址空间的用户模式中未保留和未提交的内存量（单位：字节）
  • ullAvailExtendevVirtual：保留值，始终为0
  • 头文件：sysinfoapi.h（包括在Windows.h中）
计算机系统信息结构体

Windows使用SYSTEM_INFO结构体保存当前计算机系统的信息，包括处理器的体系结构和类型，系统中处理器的数量，页面大小和其他信息

语法如下：

typedef struct _SYSTEM_INFO {
  union {
    DWORD dwOemId;
    struct {
      WORD wProcessorArchitecture;
      WORD wReserved;
    } DUMMYSTRUCTNAME;
  } DUMMYUNIONNAME;
  DWORD     dwPageSize;
  LPVOID    lpMinimumApplicationAddress;
  LPVOID    lpMaximumApplicationAddress;
  DWORD_PTR dwActiveProcessorMask;
  DWORD     dwNumberOfProcessors;
  DWORD     dwProcessorType;
  DWORD     dwAllocationGranularity;
  WORD      wProcessorLevel;
  WORD      wProcessorRevision;
} SYSTEM_INFO, *LPSYSTEM_INFO;

说明：（该结构体成员较多，只介绍部分）

  • dwPageSize：页面大小和页面保护和提交的粒度，是VirtualAlloc函数使用的页面大小
  • lpMinimumApplictionAddress：指向应用程序和动态链接库（DLL）可访问的最低内存指针
  • lpMaximumApplicationAddress：指向应用程序和动态链接库（DLL）可访问的最高内存指针
  • dwActiveProcessorMask：配置到系统中的处理器集掩码
  • dwNumberOfProcessors：当前组中的逻辑处理器数，若要检索，则需要调用GetLogicalProcessorInformation函数
  • dwAllocationGranularity：可以分配虚拟内存的其实地址的粒度
  • 头文件：sysinfoapi.h（包含于Windows.h中）
性能信息结构体

Windows使用PERFORMANCE_INFORMATION结构体保存性能信息

语法如下：

typedef struct _PERFORMANCE_INFORMATION {
  DWORD  cb;
  SIZE_T CommitTotal;
  SIZE_T CommitLimit;
  SIZE_T CommitPeak;
  SIZE_T PhysicalTotal;
  SIZE_T PhysicalAvailable;
  SIZE_T SystemCache;
  SIZE_T KernelTotal;
  SIZE_T KernelPaged;
  SIZE_T KernelNonpaged;
  SIZE_T PageSize;
  DWORD  HandleCount;
  DWORD  ProcessCount;
  DWORD  ThreadCount;
} PERFORMANCE_INFORMATION, *PPERFORMANCE_INFORMATION, PERFORMACE_INFORMATION, *PPERFORMACE_INFORMATION;

说明：（该结构体成员较多，只介绍部分）

  • cb：结构体大小（单位：字节）
  • CommitTotal：系统当前提交的页数，提交页面（使用VirtualAlloc和MEM_COMMIT）会立即更新该值；但是在访问页面之前，物理内存不会被填充
  • CommitPeak：自上次系统重新引导以来同时处于已提交状态的最大页数
  • PhysicalTotal：实际物理内存，以页为单位
  • PhysicalAvailable：当前可用的物理内存量，以页为单位。这部分内存是可以立即重用无需写入磁盘的内存，是备用，空闲和零列表大小的总和
  • SystemCache：系统缓存内存量，以页为单位。该值为备用列表大小加上系统工作集
  • KernelTotal：分页和非分页内核池中当前内存的总和，以页为单位
  • KernelPaged：当前在分页内核池的内存，以页为单位
  • KernelNonpaged：当前在非分页内核池中的内存，以页为单位
  • PageSize：页面大小，以字节为单位
  • HandleCount：当前打开手柄的数量
  • ProcessCount：当前进程数
  • ThreadCount：当前线程数
  • 头文件：psapi.h
进程列表条目

Windows使用PROCESSENTRY32结构体描述在拍摄快照时驻留在系统地址空间中的进程列表中的条目

语法如下：

typedef struct tagPROCESSENTRY32 {
  DWORD     dwSize;
  DWORD     cntUsage;
  DWORD     th32ProcessID;
  ULONG_PTR th32DefaultHeapID;
  DWORD     th32ModuleID;
  DWORD     cntThreads;
  DWORD     th32ParentProcessID;
  LONG      pcPriClassBase;
  DWORD     dwFlags;
  CHAR      szExeFile[MAX_PATH];
} PROCESSENTRY32;

说明：

  • dwSize：结构体大小，以字节为单位。在调用Process32First函数之前要设置为sizeof(PROCESSENTRY32)，若没有设置，则函数调用会是失败
  • th32ProcessID：进程标识符PID
  • cntThreads：进程启动的线程数
  • th32ParentProcessID：创建此进程的进程标识符，即父进程的PID
  • pcPriClassBase：此进程创建的线程的基本优先级
  • szExeFile：进程的可执行文件
  • 其他成员：不再使用，始终设置为0
  • 头文件：tlhelp32.h
进程内存统计信息结构

Windows使用PROCESS_MEMORY_COUNTERS结构体保存进程的内存统计信息

语法如下：

typedef struct _PROCESS_MEMORY_COUNTERS {
  DWORD  cb;
  DWORD  PageFaultCount;
  SIZE_T PeakWorkingSetSize;
  SIZE_T WorkingSetSize;
  SIZE_T QuotaPeakPagedPoolUsage;
  SIZE_T QuotaPagedPoolUsage;
  SIZE_T QuotaPeakNonPagedPoolUsage;
  SIZE_T QuotaNonPagedPoolUsage;
  SIZE_T PagefileUsage;
  SIZE_T PeakPagefileUsage;
} PROCESS_MEMORY_COUNTERS;

说明：

  • cb：结构体大小
  • PageFaultCount：页面错误的数量
  • WorkingSetSize：当前工作集大小（单位：字节）
  • PeakWorkingSetSize：峰值工作集大小（单位：字节）
  • QuotaPeakPagedPoolUsage：峰值分页池使用情况（单位：字节）
  • QuotaPagedPoolUsage：当前页面缓冲池使用情况（单位：字节）
  • QuotaPeakNonPagedPoolUsage：非页面缓冲池使用率的峰值（单位：字节）
  • QuotaNonPagedPoolUsage：当前非分页池使用情况（单位：字节）
  • PagefileUsage：此进程的Commit Charge值（单位：字节），Commit Charge是内存管理器为正在运行的进程提交的内存总量
  • PeakPagefileUsage：此进程的生命周期内提交的峰值（单位：字节）
  • 头文件：psapi.h
虚拟地址空间信息

Windows使用MEMORY_BASIC_INFORMATION保存有关进程虚拟地址空间的一系列页面的信息，提供给VirtualQuery和VirtualQueryEx使用

语法如下：

typedef struct _MEMORY_BASIC_INFORMATION {
  PVOID  BaseAddress;
  PVOID  AllocationBase;
  DWORD  AllocationProtect;
  SIZE_T RegionSize;
  DWORD  State;
  DWORD  Protect;
  DWORD  Type;
} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;

说明：

  • BaseAddress：指向页面区域的基址指针
  • AllocationBase：指向VirtualAlloc函数分配的一系列页面的基址指针
  • AllocationProtect：最初分配区域时的内存保护选项
  • RegionSize：从基址开始的区域大小，其中所有页面都具有相同属性（单位：字节）
  • State：页面的状态，可以是以下值：
    • MEM_COMMIT：表示已在内存中或磁盘页面文件中为其分配物理存储的已提交页面
    • MEM_FREE：表示调用进程无法访问且可以分配的空闲页面
    • MEM_RESERVE：表示保留进程的虚拟地址空间范围而不分配任何物理存储的保留页面
  • Protect：该区域中页面的访问保护
  • Type：页面的类型，可以是以下值：
    • MEM_IMAGE：指示区域内的内存页面映射到映射文件到视图中
    • MEM_MAPPED：指示区域内的内存页面映射到节的仕途
    • MEM_PRIVATE：指示区域内页面是私有的
  • 头文件：winnt.h（包含于Windows.h中）

4.3 API介绍

检索内存使用情况函数

Windows使用GlobalMemoryStatusEx函数检索有关系统物理和虚拟内存当前使用情况的信息

语法如下：

BOOL GlobalMemoryStatusEx(
  LPMEMORYSTATUSEX lpBuffer
);

说明：

  • lpBuffer：指向MEMORYSTATUSEX结构的指针，该结构接受有关当前内存可用性的信息
  • 返回值
    • 若函数成功，则返回值非零
    • 若函数失败，则返回值为0
  • 头文件：sysinfoapi.h（包括在Windows.h中）
  • DLL：KERNEL32.DLL
获取系统信息函数

Windows使用GetSystemInfo函数获取当前系统的信息

语法如下：

void GetSystemInfo(
  LPSYSTEM_INFO lpSystemInfo
);

说明：

  • lpSystemInfo：指向接受信息的SYSTEM_INFO结构体指针
  • 头文件：sysinfoapi.h（包括在Windows.h中）
  • DLL：KERNEL32.DLL
获取性能函数

Windows使用GetPerformanceInfo函数获取性能信息，填充PERFORMANCE_INFORMATION结构中的性能值

语法如下：

BOOL GetPerformanceInfo(
  PPERFORMANCE_INFORMATION pPerformanceInformation,
  DWORD                    cb
);

说明：

  • pPerformanceInformation：指向PERFORMANCE_INFORMATION结构的指针
  • cb：PERFORMANCE_INFORMATION结构的大小，（单位：字节）
  • 返回值：
    • 函数成功，则返回TRUE
    • 函数失败，则返回FALSE
  • 头文件：psapi.h
  • DLL：PSAPI_VERSION=1时，使用Psapi.dll，否则使用Kernel32.dll
获取系统快照

Windows使用CreateToolhelp32Snapshot函数获取指定进程的快照，以及这些进程使用的堆、模块和线程

语法如下：

HANDLE CreateToolhelp32Snapshot(
  DWORD dwFlags,
  DWORD th32ProcessID
);

说明：

  • dwFlags：包含在快照中的系统部分，本实验选用的是TH32CS_SNAPPROCESS，表示包括快照中的所有进程，可以使用Process32First枚举这些进程
  • th32ProcessID：要包含在快照中的进程的标识符，本实验该参数为0，指示当前进程
  • 返回值：
    • 若函数成功，则返回快照句柄
    • 若函数失败，则返回INVALID_HANDLE_VALUE
  • 头文件：tlhelp32.h
  • DLL：KERNEL32.DLL
获取系统快照中第一个进程

Windows使用Process32First函数获取有关系统快照中遇到的第一额进程的信息

语法如下：

BOOL Process32First(
  HANDLE           hSnapshot,
  LPPROCESSENTRY32 lppe
);

说明：

  • hSnapshot：从先前调用的CreateToolhelp32Snapshot函数返回的快照句柄
  • ppe：指向PROCESSENTRY32结构的指针
  • 返回值：若进程列表第一个条目已经复制到缓冲区，则返回TRUE，否则返回FALSE
  • 注意：调用函数之前，必须将PROCESSENTRY32的dwSize设置为结构大小，否则会失败
  • 头文件：tlhelp32.h
  • DLL：KERNEL32.DLL
获取快照中下一个进程

Windows使用Process32Next函数获取有关系统快照中记录的下一个进程的信息

语法如下：

BOOL Process32Next(
  HANDLE           hSnapshot,
  LPPROCESSENTRY32 lppe
);

说明：

  • hSnapshot：从先前调用的CreateToolhelp32Snapshot函数返回的快照句柄
  • lppe：指向PROCESSENTRY32结构的指针
  • 头文件：tlhelp32.h
  • DLL：KERNEL32.DLL
打开进程函数

Windows使用OpenProcess函数打开现有的本地进程对象

语法如下：

HANDLE OpenProcess(
  DWORD dwDesiredAccess,
  BOOL  bInheritHandle,
  DWORD dwProcessId
);

说明：

  • dwDesiredAccess：对进程对象的访问权限
  • binheritHandle：若此值为TRUE，则该进程创建的进程将继承该句柄。否则，子进程不会继承该句柄
  • dwProcessId：要打开的本地进程的标识符，在实验中取PROCESSENTRY32结构中的th32ProcessID
  • 返回值：
    • 若函数成功，则返回指定进程的打开句柄
    • 若函数失败，则返回NULL
  • 头文件：processthreadspai.h（包含于Windows.h中）
  • DLL：KERNEL32.DLL
获取进程内存使用情况

Windows使用GetProcessMemoryInfo函数获取指定进程的内存使用情况的信息

语法如下：

BOOL GetProcessMemoryInfo(
  HANDLE                   Process,
  PPROCESS_MEMORY_COUNTERS ppsmemCounters,
  DWORD                    cb
);

说明：

  • Process：进程的句柄
  • ppsemCounters：指向PROCESS_MEMORY_COUNTERS或PROCESS_MEMORY_COUNTERS_EX结构的指针
  • cb：ppsemCounters结构大小
  • 返回值：
    • 若函数成功，则返回值非零
    • 若函数失败，则返回值为零
  • 头文件：psapi.h
  • DLL：若PSAPI_VERSION=1，则使用Psapi.dll，否则使用Kernel32.dll
显示页面保护

该段程序不是Windows提供的API，而是自己定义的若干函数

inline bool TestSet(DWORD dwTarget,DWORD dwMask){
    return ((dwTarget &dwMask)==dwMask);
}

#define SHOWMASK(dwTarget,type) if(TestSet(dwTarget,PAGE_##type)) {cout << "|" << #type;}

void ShowProtection(DWORD dwTarget){
    SHOWMASK(dwTarget,READONLY);
    SHOWMASK(dwTarget,GUARD);
    SHOWMASK(dwTarget,NOCACHE);
    SHOWMASK(dwTarget,READWRITE);
    SHOWMASK(dwTarget,WRITECOPY);
    SHOWMASK(dwTarget,EXECUTE_READ);
    SHOWMASK(dwTarget,EXECUTE);
    SHOWMASK(dwTarget,EXECUTE_READWRITE);
    SHOWMASK(dwTarget,EXECUTE_WRITECOPY);
    SHOWMASK(dwTarget,NOACCESS);
}

4.4 程序代码

本实验源代码包含在文件MemoryWatch.cpp中，如下：

#include<windows.h>
#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<psapi.h>
#include"Psapi.h"
#include"tlhelp32.h"
#include"shlwapi.h"

#define DIV_GB (1024*1024*1024)
#define DIV_KB (1024)
using namespace std;

void memoryInfo(){
    MEMORYSTATUSEX statex;
    statex.dwLength=sizeof(statex);
    GlobalMemoryStatusEx(&statex);
    printf("THE SYSTEM MEMORY INFORMATION FLOWING:\n\n");
    printf("The usage of memory is %ld%%\n",statex.dwMemoryLoad);
    printf("The total capacity of memory is %.2fGB\n",(float)statex.ullTotalPhys/DIV_GB);
    printf("The available memory is %.2fGB\n",(float)statex.ullAvailPhys/DIV_GB);
    printf("The total pages file is %.2fGB\n",(float)statex.ullTotalPageFile/DIV_GB);
    printf("The available pages file is %.2fGB\n",(float)statex.ullAvailPageFile/DIV_GB);
    printf("The total virtual space is %.2fGB\n",(float)statex.ullTotalVirtual/DIV_GB);
    printf("The available virtual space is %.2fGB\n",(float)statex.ullAvailVirtual/DIV_GB);
    printf("The available extended virtual space is %.2fGB\n",(float)statex.ullAvailExtendedVirtual/DIV_GB);
    printf("\n\n");
}

void systemInfo(){
    SYSTEM_INFO si;
    ZeroMemory(&si,sizeof(si));
    GetSystemInfo(&si);
    printf("THE SYSTEM INFORMATION FLOWING:\n\n");
    printf("The page size and the granularity of page protection and commitment is %dKB\n",(int)si.dwPageSize/DIV_KB);
    printf("The pointer to the lowest memory address accessible to applications and dynamic-link libraries (DLLs) is 0x%.8x\n",si.lpMinimumApplicationAddress);//%.8x控制长度
    printf("The pointer to the highest memory address accessible to applications and DLLs is 0x%x\n",si.lpMaximumApplicationAddress);
    printf("The number of logical processors in the current group is %d\n",si.dwNumberOfProcessors);
    printf("The granularity for the starting address at which virtual memory can be allocated is %dKB\n",si.dwAllocationGranularity/DIV_KB);
    printf("\n\n");
}

void performanceInfo(){
    PERFORMANCE_INFORMATION pi;
    pi.cb=sizeof(pi);
    GetPerformanceInfo(&pi, sizeof(pi));
    printf("THE PERFORMANCE INFORMATION IS FOLLOWING:\n\n");
    printf("The number of pages currently committed by the system is %d\n",pi.CommitTotal);
    printf("The current maximum number of pages that can be committed by the system without extending the paging file(s) is %d\n",pi.CommitLimit);
    printf("The maximum number of pages that were simultaneously in the committed state since the last system reboot is %d\n",pi.CommitPeak);
    printf("The amount of actual physical memory in pages is %d\n",pi.PhysicalTotal);
    printf("The amount of physical memory currently available is %d\n",pi.PhysicalAvailable);
    printf("The amount of system cache memory is %d\n",pi.SystemCache);
    printf("The sum of the memory currently in the paged and nonpaged kernel pools is %d\n",pi.KernelTotal);
    printf("The memory currently in the nonpaged kernel pool is %d\n",pi.KernelNonpaged);
    printf("The size of a page is %dKB",pi.PageSize/DIV_KB);
    printf("The current number of open handles is %d\n",pi.HandleCount);
    printf("The current number of processes is %d\n",pi.ProcessCount);
    printf("The current number of threads is %d\n",pi.ThreadCount);
    printf("\n\n");
}

void processInfo(){
    PROCESSENTRY32 pe;
    pe.dwSize=sizeof(pe);
    HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    BOOL bMore = ::Process32First(hProcessSnap, &pe);
    printf("THE ALL PROCESS INFORMATION IS FOLLOWING:\n\n");
    printf("PID\t | Execute File\t\t\t\t\t | Working Set Size(KB)\n");
    while(bMore){
        HANDLE hP = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
        PROCESS_MEMORY_COUNTERS pmc;
		ZeroMemory(&pmc, sizeof(pmc));
        if(GetProcessMemoryInfo(hP, &pmc, sizeof(pmc))){
            int len=strlen(pe.szExeFile);
            printf("%d\t | %s",pe.th32ProcessID,pe.szExeFile);t
            for(int i=0;i<=45-len;i++){
                printf(" ");//控制长度，打表好看
            }
            printf("| %.2f\n",(float)pmc.WorkingSetSize/DIV_KB);
        }
        bMore = ::Process32Next(hProcessSnap, &pe);
    }
    CloseHandle(hProcessSnap);
}

//以下三个功能函数来自书本第292页

inline bool TestSet(DWORD dwTarget,DWORD dwMask){
    return ((dwTarget &dwMask)==dwMask);
}

#define SHOWMASK(dwTarget,type) if(TestSet(dwTarget,PAGE_##type)) {cout << "|" << #type;}

void ShowProtection(DWORD dwTarget){
    SHOWMASK(dwTarget,READONLY);
    SHOWMASK(dwTarget,GUARD);
    SHOWMASK(dwTarget,NOCACHE);
    SHOWMASK(dwTarget,READWRITE);
    SHOWMASK(dwTarget,WRITECOPY);
    SHOWMASK(dwTarget,EXECUTE_READ);
    SHOWMASK(dwTarget,EXECUTE);
    SHOWMASK(dwTarget,EXECUTE_READWRITE);
    SHOWMASK(dwTarget,EXECUTE_WRITECOPY);
    SHOWMASK(dwTarget,NOACCESS);
}

void processVirtualMemoryInfo(){
    int pid;
    printf("Please enter the pid that you want to search\n"); 
    SYSTEM_INFO si;
    ZeroMemory(&si,sizeof(si));
    GetSystemInfo(&si);
    HANDLE hProcess;
    while(TRUE){
        printf("PID:\t");
        scanf("%d",&pid);
        hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
        if (hProcess==NULL) {
            printf("You Enter A INVALID Pid, Please Check and Enter again:\n");
        }
        else{
            break;
        }
    }
    MEMORY_BASIC_INFORMATION mbi;
    ZeroMemory(&mbi,sizeof(mbi));
    LPCVOID pBlock = (LPVOID)si.lpMinimumApplicationAddress;
    printf("Address\t\t\t | Size\t\t | State\t | Protect\t | Type\t\t | Module\n\n");
    while(pBlock < si.lpMaximumApplicationAddress){
        if (VirtualQueryEx(hProcess,pBlock,&mbi,sizeof(mbi))==sizeof(mbi)) {
            LPCVOID pEnd = (PBYTE)pBlock + mbi.RegionSize;
            TCHAR szSize[MAX_PATH];
            StrFormatByteSize(mbi.RegionSize, szSize, MAX_PATH);
            printf("%.8x-%.8x\t",(DWORD)pBlock,(DWORD)pEnd);
            printf("| %s\t",szSize);
            switch (mbi.State)
            {
                case MEM_COMMIT:
                    printf("| Commited\t");
                    break;
                case MEM_FREE:
                    printf("| Free\t\t");
                    break;
                case MEM_RESERVE:
                    printf("| Reserved\t");
                    break;
                default:
                    break;
            }
            if (mbi.Protect == 0 && mbi.State != MEM_FREE) {
                mbi.Protect = PAGE_READONLY;
            }
            ShowProtection(mbi.Protect);
            printf("\t");
            switch (mbi.Type)
            {
                case MEM_IMAGE:
                    printf("| Image\t");
                    break;
                case MEM_MAPPED:
                    printf("| Mapped\t");
                    break;
                case MEM_PRIVATE:
                    printf("| Private\t");
                    break;
                default:
                    break;
            }
            TCHAR szFilename[MAX_PATH];
            if (GetModuleFileName((HINSTANCE)pBlock,szFilename,MAX_PATH)>0) {
                PathStripPath(szFilename);
                printf("\t| %s",szFilename);
            }
            printf("\n");
            pBlock=pEnd;
        }
    }
}

void clear(){
    system("cls");
}

int main(int argc, char const *argv[])
{
    while(TRUE){
        printf("What do you want to know?\n");
        printf("Memory Information press: 'u'\nSystem Information press 'i'\nPerformance Information press 'o'\nProcess Infomation press 'p'\nProcess Virtual Memory Information press 'm'\nQuit press 'q'\n");
        char c=getchar();
        if(c=='q'){
            break;
        }
        else if(c=='u'){
            getchar();//去掉回车
            memoryInfo();
        }
        else if(c=='i'){
            getchar();
            systemInfo();
        }
        else if(c=='o'){
            getchar();
            performanceInfo();
        }
        else if(c=='p'){
            getchar();
            processInfo();
        }
        else if(c=='m'){
            getchar();
            processVirtualMemoryInfo();
            getchar();
        }
    }
    return 0;
}

程序运行方式如下：

g++ MemoryWatch.cpp -lPsapi -lShlwapi -o MemoryWatch.exe
MemoryWatch.exe

注意：由于实验中需要用到动态链接库，所以编译时需要添加动态链接库参数

4.5 运行结果

实验者在主要程序外嵌套了一层交互程序，运行程序可以交互进行实时内存监控，如下

4.5.1 查询内存信息

在这里插入图片描述

4.5.2 查询系统信息

在这里插入图片描述

4.5.3 查询性能信息

在这里插入图片描述

4.5.4 查询进程

在这里插入图片描述

4.5.5 查询进程虚拟地址空间

需要输入PID，若PID无效则会提示无效信息，可以通过4.5.5查询有效的PID

在这里插入图片描述

5. 实验收获与体会

  1. 通过本实验，掌握了许多在Windows下关于内存信息的系统调用函数，了解系统内部内存的工作方式和工作情况
  2. 对获取系统信息的API有了更加深入的了解
  3. 对操作系统内存分配方式有了进一步的印象。Windows把每个进程的虚拟内存地址映射到物理内存地址，操作系统通过页式管理的方式对内存进行管理
  4. 对于本实验的所有数据结构和系统调用函数，均在微软文档中进行阅读和深入理解，实验进一步训练自己阅读文档获取函数、数据结构声明的能力。
内存写入监视器 V2.0
04-20
内存写入监视器 V2.0 用于软件反编译 偷取别人补丁的一个好用根据
内存写入监视器（驱动版）纯E 附驱动源码
07-21
内存写入监视器（驱动版）纯E 附驱动源码内存写入监视器（驱动版）纯E 附驱动源码内存写入监视器（驱动版）纯E 附驱动源码
Windows内存管理与结构体MEMORY_BASIC_INFORMATION
Ginvar的专栏
08-19 4369
原文地址：Windows内存管理与结构体MEMORY_BASIC_INFORMATION作者：Jess23基于32位Windows，摘自http://blog.csdn.net/yeming81/archive/2008/01/16/2046193.aspx   1. 进程地址空间   软件的进程运行于32位系统上，其寻址位也是32位，能表示的空间是232=4G，范围从0x0000 0000~0x
Qt笔记(六十八)之获取内存信息
我是黄同学博客
05-31 3001
一.前言 楼主最近在获取电脑设备的一些信息，今天获取了关于内存的信息，于是分享记录下 二.获取过程 1.使用系统APIGlobalMemoryStatusEx和结构体MEMORYSTATUSEX 关于MEMORYSTATUSEX中各个变量的解释 typedef struct _MEMORYSTATUSEX { DWORD dwLength; // 结构体的大小 DWORD dwMemoryLoad; // 表示内存使用率，是一个0-100的数字
C/C++ 遍历进程内存块
热门推荐
LYSHARK
07-16 1万+
它使用了Windows API函数来遍历指定进程的所有内存块，并输出每个内存块的相关信息。该代码可以帮助了解目标进程的内存布局，以及各个内存块的属性。的函数，用于枚举指定进程的所有内存块。该代码使用Windows API函数实现了遍历指定进程的内存块的功能，并输出了每个内存块的地址、大小和保护属性等信息。使用循环遍历内存块的向量，并输出每个内存块的相关信息，包括基地址、分配基地址、内存块大小、内存块状态、内存保护属性等。在主函数中，创建了一个进程快照句柄，用于获取当前系统中的进程信息。
实验四内存监视15分1 - 内存监视器设计与实现
最新发布
gitblog_06747的博客
04-26 891
实验四内存监视15分1 - 内存监视器设计与实现 【下载地址】实验四内存监视15分1-内存监视器设计与实现 本项目是一款专为Windows系统设计的内存监视器，能够实时监控并展示计算机内存的使用情况。通过图形化界面，用户可以直观查看系统地址空间的布局和物理内存的动态使用情况。项目采用操作系统API获取内存数据，并以图表和...
监视和内存观察
2302_79863009的博客
03-16 920
开始调试后，在菜单栏中【调试】->【窗⼝】->【监视】，打开任意⼀个监视窗口，输入想要观察的对象就行。如果监视窗口看的不够仔细，也是可以观察变量在内存中的存储情况，还是在【调试】->【窗口】->【内存】在打开内存窗口后，要在地址栏输入：arr，&num，&c，这类地址，就能观察到该地址处的数据。除此之外，在调试的窗口中还有：自动窗口，局部变量，反汇编、寄存器等窗口，自行验证使用一下。在调试的过程中我们，如果要观察代码执行过程中，上下文环境中的变量的值，有哪些方法呢？
【性能监视器】监视查看CPU、内存等数据
就是那个党伟
08-30 5625
性能监视器，windows，内存，cpu
VS2022版本没有调试内存监视等
m0_52271408的博客
04-20 1万+
关于Visual Studio 2022版本很多新手说没有调试内存监视等功能的问题 1、确实正常选择调试-窗口的时候，内存，监视等功能都没了，少了很多，网上有教程说什么设置这里设置那里，其实都不用， 只是新版本更简洁化，当你没有调试的时候不需要这些功能自动隐藏了而己。 2、你只需要把代码 写好后，需要调试的时候按F10，这时再去菜单 调试-窗口，你会发现超多的功能全部出来了，想用哪个用哪个。 ...
内存写入监视器
04-23
监测内存写入检测，帮助开发者快速进行应用开发等操作！
实验四内存监视15分1
08-08
实验四、内存监视（15分）设计一个内存监视器，能实时地显示当前系统中内存的使用情况，包括系统地址空间的布局，物理内存的使用情况；参考Windows系统相关的系统
易语言源码深入：进程内存监视技术与实现
weixin_34598113的博客
09-21 1793
本文还有配套的精品资源，点击获取 简介：易语言作为一种简便的编程语言，便于理解和使用，尤其适合编程教育和小型应用开发。本文将深入探讨易语言源码中的进程内存监视技术，解释如何利用易语言进行内存的读取、写入和监控，以及如何使用系统服务命令获取进程权限。此外，文章还将阐述构建内存监视核心逻辑的方法，包括监控范围、频率和条件的设定，以及如何通过用户界面展示内存监视结果。在进行内存监...
JVM：内存监视手段及各区域内存溢出解决
jiq•钦's technical Blog
04-17 1万+
引言本文仅关注一些常见的虚拟机内存监视手段，以及JVM运行时数据区各个部分内存溢出的发生和对应的解决方案，总体来说属于概括性总结，涉及相对不是很深入，目的是让自己和其它初学者有一个框架性、概念性的了解，当遇到问题时有迹可循、不至于不知所措。一、虚拟机内存监视手段虚拟机常出现的问题包括：内存泄露、内存溢出、频繁GC导致性能下降等，导致这些问题的原因可以通过下面虚拟机内存监视手段来进行分析，具体实施时
J2ME小技巧——使用WTK的内存监视器
爪哇米工作室陈跃峰的移动开发博客
10-31 3899
        在实际的开发过程中，经常需要监视内存的使用，WTK提供了监视内存的功能。        选择“Preferences”->“监视”，选中“启用内存监视器”，则再下次启动WTK的时候，就可以启动内存监视器了。
【操作系统实验】内存监视器实验
ayaishere_的博客
01-16 1502
Memory Monitor
Eclipse开启内存监视窗口
天外来客的博客
02-23 6694
Eclipse开启内存监视窗口重要性自己体会！ Eclipse 3.2以上都可以直接通过
易语言技术-内存读写监视窥探技术
hzw320的博客
08-13 7173
如果要监控某个程序进程里的内存读写数据信息, 知道目标进程里都对哪些内存地址进行读写了哪些数据信息,我们该怎么办呢？ 那么我们就需要进行内存监控技术,这项技术,一般可以用于以下方面： 1.检测监控自己写的程序在运行时候,对各内存地址的数据读写的行为是否如自己所想效果 2.监控别人的软件程序进程里的内存读写事件,来获取别人的软件程序的一些数据或内存地址信息,用来偷取 不管是哪一点,结果是学会这项技术...
JVM总结-内存监视手段及各区域内存溢出解决
xuqu_volition的专栏
12-21 6746
引言 本文仅关注一些常见的虚拟机内存监视手段，以及JVM运行时数据区各个部分内存溢出的发生和对应的解决方案，总体来说属于概括性总结，涉及相对不是很深入，目的是让自己和其它初学者有一个框架性、概念性的了解，当遇到问题时有迹可循、不至于不知所措。 一、虚拟机内存监视手段 虚拟机常出现的问题包括：内存泄露、内存溢出、频繁GC导致性能下降等，导致这些问题的原因可以通过下面虚拟
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值