[转贴]How to get the largest available continues memory block

原文地址: http://blog.kalmbachnet.de/?postid=9

Some applications require a huge amount of continues memory. And sometimes, windows is not able to satisfy the request.

To find out the reason of why the virtual memory is badly splited and to get the size of the larges continous memory block, you can use the following code to get the info about the virtual address space:

 #include <stdio.h>
 #include <windows.h>
 #include <tchar.h>
 #include <psapi.h>
 #pragma comment(lib, "psapi.lib")

  void PrintMemInfo(MEMORY_BASIC_INFORMATION &mbi)
  {
    if (mbi.State != MEM_FREE)
      return;
    _tprintf(_T("BaseAddress      : 0x%8.8X, 0x%8.8X, 0x%8.8X/n"), 
      mbi.BaseAddress, mbi.AllocationBase, mbi.AllocationProtect);
    _tprintf(_T("RegionSize       : 0x%8.8X/n"), mbi.RegionSize);
    _tprintf(_T("State            : "));
    switch(mbi.State)
    {
    case MEM_COMMIT:
      _tprintf(_T("Commit/n"));
      break;
    case MEM_FREE:
      _tprintf(_T("Free/n"));
      break;
    case MEM_RESERVE:
      _tprintf(_T("Reserve/n"));
      break;
    default:
      _tprintf(_T("Unknown/n"));
      break;
    }
    _tprintf(_T("Type             : "));
    switch(mbi.Type)
    {
    case MEM_IMAGE:
      _tprintf(_T("Image/n"));
      break;
    case MEM_MAPPED:
      _tprintf(_T("Mapped/n"));
      break;
    case MEM_PRIVATE:
      _tprintf(_T("Private/n"));
      break;
    default:
      _tprintf(_T("Unknown (%d)/n"), mbi.Type);
      break;
    }
    _tprintf(_T("/n"));
  }

  void PrintModules( DWORD processID )
  {
    HMODULE hMods[ 1024 ];
    HANDLE hProcess;
    DWORD cbNeeded;
    unsigned int i;
    _tprintf( _T("/nProcess ID: %u/n"), processID );
    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |PROCESS_VM_READ, FALSE, processID);
    if (NULL  hProcess)
      return;
    if( EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))
    {
      for ( i = 0; i < (cbNeeded / sizeof(HMODULE)); i++ )
      {
        TCHAR szModName[MAX_PATH];
        if ( GetModuleFileNameEx( hProcess, hMods[i], szModName, sizeof(szModName)))
        {
          _tprintf(_T("/t%s (0x%08X)/n"), szModName, hMods[i] );
        }
      }
    }
    CloseHandle( hProcess );
  }

  SIZE_T GetLargestFreeMemRegion(LPVOID *lpBaseAddr, bool showMemInfo)
  {
    SYSTEM_INFO systemInfo;
    GetSystemInfo(&systemInfo);
    VOID *p = 0;
    MEMORY_BASIC_INFORMATION mbi;
    SIZE_T largestSize = 0;
    while(p < systemInfo.lpMaximumApplicationAddress)
    {
      SIZE_T dwRet = VirtualQuery(p, &mbi, sizeof(mbi));
      if (dwRet > 0)
      {
        if (showMemInfo)
          PrintMemInfo(mbi);
        if (mbi.State  MEM_FREE)
        {
          if (largestSize < mbi.RegionSize)
          {
            largestSize = mbi.RegionSize;
            if (lpBaseAddr != NULL)
              *lpBaseAddr = mbi.BaseAddress;
          }
        }
        p = (void*) (((char*)p) + mbi.RegionSize);
      }
      else
      {
        if (showMemInfo)
          _tprintf(_T(”### VirtualQuery failed (%p)/n”), p);
        p = (void*) (((char*)p) + systemInfo.dwPageSize);
      }
    }
    return largestSize;
  }

  int _tmain()
  {
    LPVOID baseAddr;
    SIZE_T ls = GetLargestFreeMemRegion(&baseAddr, true);
    PrintModules(GetCurrentProcessId());
    _tprintf(_T(”/nLargest Free Region: 0x%8.8X bytes at 0x%8.8X/n”), ls, baseAddr);
    return 0;
  }