当我使用 VirtualAlloc() 和 MEM_RESERVE 保留内存时，难道我不能在 64K 边界上增加我的分配吗？

Question

首先，我很清楚 VirtualAlloc() 是如何工作的：当我保留内存块时，我得到的地址对齐到 64K 边界，（这个值可以很容易地通过 GetSystemInfo() ), 然后当我提交页面时，我将它们放在页面大小边界上，通常是 4K。

我无法得到的是，为什么如果我用 MEM_RESERVE 标志调用 VirtualAlloc()（所以我要保留页面）并指定一定的大小，比如说 4096，那么我将无法将该区域进一步扩展到 64K？

我的意思是：当我提交页面时，我可以使用高达 4K 的内存，因为 Windows 将这些提交与页面大小对齐（当然，我正在提交页面！），但是当我正在保留内存区域，难道 Windows 不应该将我传递给 VirtualAlloc() 的区域的大小对齐到 64K 吗？ "wasted" 15 页都去哪儿了？

所以如果我保留 4096 字节，我是否应该能够提交更多页面直到 65536 字节？似乎并非如此，因为如果我尝试这样做，VirtualAlloc() 会失败并显示 ERROR_INVALID_ADDRESS 最后一个错误代码。

但是为什么呢？如果 Windows 真的保留了 64K 边界的页面，而我保留了小于该大小的页面，我会永远丢失我不保留的页面吗？因为似乎没有办法再次提交它们，或者调整区域大小以适应我因较低的保留而错过的 64K 边界。

那么，进程的虚拟space会不会有漏洞？为了避免这种情况，我是否必须在 64K 边界上保留内存 always，所以给 VirtualAlloc() 一个 64K 对齐的值 always when我要保留页面？

当我使用 MEM_RESERVE|MEM_COMMIT 时呢？由于 MEM_RESERVE 标志，我不应该在那里传递 64K 对齐的大小吗？

我附上了一个我试过的小代码示例。正如你在这里看到的，第一个函数成功了，因为我保留了更多的页面，然后我的提交将有足够的 "reserved region" 实际提交，但在这种情况下，区域将 <64K，那么那些 "lost" 页面去哪儿了？

在第二种情况下，我只有 MEM_RESERVE|MEM_COMMIT，因此提交其他页面会失败并显示 ERROR_INVALID_ADDRESS 最后一个错误代码。很公平，但在这里，为什么我不能提交更多页面，至少在 64K 边界上？为了不浪费地址并创建这些 "holes"，我真的应该在 64K 边界上保留虚拟内存吗？如果我不遵循这个原则怎么办？我总是看到很多代码只是调用 VirtualAlloc() 和 MEM_COMMIT|MEM_RESERVE 标志，不关心这个 64K 对齐事物。他们是否以错误的方式分配内存？想法？

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>

#define PAGE_SZ 4096


bool
reserve_and_commit()
{
  MEMORY_BASIC_INFORMATION mem_info;
    void * mem, * mem2;
bool result = true;

  mem =
    VirtualAlloc(0, PAGE_SZ * 1, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  if (!mem)
  {
    result = false;
    printf("VirtualAlloc1: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualAlloc1: MEM_RESERVE|MEM_COMMIT OK. Address: %p\n", mem);

  printf("\n-------------------------------------\n\n");

  if (!VirtualQuery(mem, &mem_info, sizeof mem_info))
  {
    result = false;
    printf("VirtualQuery: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualQuery: OK. BaseAddress:%p AllocationBase:%p AllocationProtect:%08X "
           "RegionSize:%d State:%08X Protect:%08X Type:%08X\n",
           mem_info.BaseAddress, mem_info.AllocationBase, mem_info.AllocationProtect,
           (unsigned int)mem_info.RegionSize, (unsigned int)mem_info.State,
           (unsigned int)mem_info.Protect, (unsigned int)mem_info.State);

  printf("\n-------------------------------------\n\n");

  mem2 =
    VirtualAlloc(mem, PAGE_SZ * 2, MEM_COMMIT, PAGE_READWRITE);
  if (!mem2)
  {
    result = false;
    printf("VirtualAlloc2: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualAlloc2: MEM_COMMIT OK. Address: %p\n", mem2);

  printf("\n-------------------------------------\n\n");

  if (!VirtualFree(mem, 0, MEM_RELEASE))
  {
    result = false;
    printf("VirtualFree: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualFree: OK.\n");

  return result;
}


bool
first_reserve_and_then_commit()
{
  MEMORY_BASIC_INFORMATION mem_info;
  void * mem_reserved, * mem_committed;
  bool result = true;

  mem_reserved =
    VirtualAlloc(0, PAGE_SZ * 8, MEM_RESERVE, PAGE_READWRITE);
  if (!mem_reserved)
  {
    result = false;
    printf("VirtualAlloc1: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualAlloc1: MEM_RESERVE OK. Address: %p\n", mem_reserved);

  printf("\n-------------------------------------\n\n");

  if (!VirtualQuery(mem_reserved, &mem_info, sizeof mem_info))
  {
    result = false;
    printf("VirtualQuery1: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
   printf("VirtualQuery1: OK. BaseAddress:%p AllocationBase:%p AllocationProtect:%08X "
           "RegionSize:%d State:%08X Protect:%08X Type:%08X\n",
           mem_info.BaseAddress, mem_info.AllocationBase, mem_info.AllocationProtect,
           (unsigned int)mem_info.RegionSize, (unsigned int)mem_info.State,
           (unsigned int)mem_info.Protect, (unsigned int)mem_info.State);

  printf("\n-------------------------------------\n\n");

  mem_committed =
    VirtualAlloc(mem_reserved, PAGE_SZ * 1, MEM_COMMIT, PAGE_READWRITE);
  if (!mem_committed)
  {
    result = false;
    printf("VirtualAlloc2: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualAlloc2: MEM_COMMIT OK. Address: %p\n", mem_committed);

  printf("\n-------------------------------------\n\n");

  if (!VirtualQuery(mem_committed, &mem_info, sizeof mem_info))
  {
    result = false;
    printf("VirtualQuery2: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualQuery2: OK. BaseAddress:%p AllocationBase:%p AllocationProtect:%08X "
           "RegionSize:%ul State:%08X Protect:%08X Type:%08X\n",
           mem_info.BaseAddress, mem_info.AllocationBase, mem_info.AllocationProtect,
           (unsigned int)mem_info.RegionSize, (unsigned int)mem_info.State,
           (unsigned int)mem_info.Protect, (unsigned int)mem_info.State);

  printf("\n-------------------------------------\n\n");

  mem_committed =
    VirtualAlloc(mem_committed, PAGE_SZ * 8, MEM_COMMIT, PAGE_READWRITE);
  if (!mem_committed)
  {
    result = false;
    printf("VirtualAlloc3: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualAlloc3: MEM_COMMIT OK. Address: %p\n", mem_committed);

  printf("\n-------------------------------------\n\n");

  if (!VirtualFree(mem_reserved, 0, MEM_RELEASE))
  {
    result = false;
    printf("VirtualFree: ERROR '%d'\n", (unsigned int)GetLastError());
  }
  else
    printf("VirtualFree: OK.\n");

  return result;
}



int main()
{
  first_reserve_and_then_commit();
  reserve_and_commit();
  return 0;
}

Answer 1

如您的程序所示，虚拟页面在分配时不会自动保留。当您使用 VirtualAlloc 保留单个页面时，将分配整个 64K 页面块，但仅保留一个页面。您只能提交已保留的页面，因此当您的程序尝试提交已分配但未保留的页面时，对 VirtualAlloc 的调用将失败。

至于为什么它以这种方式工作，简单的答案是这是它记录的工作方式。文档中没有任何地方声明 VirtualAlloc 将保留比您要求的更多的页面。我不知道微软为什么选择这种方式实现，但它似乎符合最小惊讶原则。特别是，通过将其主要隐藏在实现细节中，这意味着如果他们决定更改分配粒度大小，更少的程序会中断（但是，在这一点上，我认为微软不可能更改它。）它还可能减少跟踪保留页面所需的内存。

至于使用 VirtualAlloc 时的最佳做法是什么，我的建议是它通常应该只用于分配大于 64K 的内存，理想情况下更大。但是由于在分配小于 64K 的区域时不会丢失物理内存，只是虚拟地址 space，对于许多程序来说这并不重要。作为调试辅助工具，我曾经在一个程序中使用了自定义版本的malloc，因此它对所有分配使用VirtualAlloc，其中大部分都比4K小得多，更不用说64K了。

当我使用 VirtualAlloc() 和 MEM_RESERVE 保留内存时，难道我不能在 64K 边界上增加我的分配吗？

When I reserve memory with VirtualAlloc() and MEM_RESERVE, shouldn't I be able to grow my allocation on a 64K boundary?

c++

winapi

memory-management

allocation

virtual-memory