当我使用 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?当我使用 VirtualAlloc() 和 MEM_RESERVE 保留内存时，我不应该能够在 64K 边界上增加分配吗？
【发布时间】：2015-10-13 16:42:33
【问题描述】：

首先，我非常了解VirtualAlloc() 的工作原理：当我保留内存块时，我得到的地址与 64K 边界对齐，（GetSystemInfo() 可以轻松获得的值），然后当我提交页面，我将它们放在页面大小边界上，通常是 4K。

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

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

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

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

那么，进程的虚拟空间会有漏洞吗？为避免这种情况，我是否必须在 64K 边界上始终保留内存，因此在我保留页面时为 VirtualAlloc() 提供一个 64K 对齐的值 always？ p>

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

我提供了一个我尝试过的小代码示例。正如你在这里看到的，第一个函数成功了，因为我保留了更多的页面，然后我的提交将有足够的“保留区域”来实际提交，但是同样在这种情况下，区域将是

在第二种情况下，我只是MEM_RESERVE|MEM_COMMIT，因此提交其他页面会失败，并显示ERROR_INVALID_ADDRESS 最后一个错误代码。很公平，但也在这里，为什么我不能提交更多的页面，至少在 64K 边界上？为了不浪费地址并创建这些“漏洞”，我真的应该在 64K 边界上保留虚拟内存吗？如果我不遵循这个原则怎么办？我总是看到很多代码只是用MEM_COMMIT|MEM_RESERVE标志调用VirtualAlloc()，不关心这个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;
}

【问题讨论】：

似乎在您的所有测试用例中，您都在提交之前没有保留的内存。来自VirtualAlloc：“尝试通过指定不带 MEM_RESERVE 和非 NULL的 MEM_COMMIT 来提交特定地址范围> lpAddress 失败，除非整个范围已被保留。生成的错误代码是 ERROR_INVALID_ADDRESS。"
VirtualAlloc() 是一种非常底层的地址空间管理方法，粒度是限制碎片和防止处理器分页表爆炸的一种非常基本的方法。当你开始担心你正在谈论的事情时，你应该使用 HeapAlloc() 来代替。
@IInspectable 正如您从代码中看到的那样，我 NEVER 在没有保留之前提交内存。仅在第二个示例中，我尝试提交的内存大于保留的内存，但只是为了测试我是否可以提交一些内存，考虑到保留的内存是否有 64K 边界，但似乎 Windows 强制我只根据我指定的保留大小提交，从而忽略 64K 边界。这正是我想证明的，然后我问：64K 边界之外的非保留页面会发生什么？系统会以某种方式重用它们吗？
@HansPassant 感谢您的建议，但对于这个具体的事情我需要VirtualAlloc()。据我了解，即使使用MEM_RESERVE|MEM_COMMIT 标志组合，也应该始终保留内存以询问与64K 对齐的系统大小，对吗？
系统无法重用未使用的地址空间，因为施加了粒度。原因是outlined by Hans Passant。没有记忆丢失。不耗尽保留内存只会在可用地址空间中戳洞。目前尚不清楚，为什么您似乎无法遵守书面合同。如果不能浪费地址空间，则需要预留 64k 的倍数的地址空间。

标签： c++ winapi memory-management allocation virtual-memory

【解决方案1】：

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

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

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

【讨论】：

感谢您对此事的见解。我猜微软只是选择了这个 64K，因为系统如何使虚拟地址空间与其数据结构（如 VAD 树）保持一致。话虽如此，您说分配小于 64K 的区域时不会丢失物理内存，这是事实，但如果您这样做，您可能会在 virtual 地址空间，因为您正在创建一些页面的保留地址，这些地址既不能保留也不能以任何方式提交。假设这个我错了，所以将 vmem 储备调整为 64K？
@MarcoPagliaricci 是的，当您分配的内存少于 64K 时，您最终会得到一系列无法保留或提交的浪费页面。所以虚拟地址空间被浪费了。但是许多程序并没有接近耗尽它们的 2G 虚拟地址空间。如今，那些确实有切换到 64 位的简单解决方案的人。
抱歉吹毛求疵，但 32 位应用程序的地址空间为 4GB。只有 2GB（或 3GB）可用于 32 位系统上的应用程序使用。在 64 位系统上，32 位应用程序可以使用整个 4GB 地址空间（只要它声称是大地址感知）。
@MarcoPagliaricci：如果您正在寻找不受内存碎片（一种或另一种方式）影响的运行时环境，则必须使用 .NET。虽然并不完美，但它的压缩堆优于任何本机 CRT 堆实现。鲜为人知的事实：Visual Studio 附带的 CRT 中实现的堆永远不会缩小。
msdn 上的 blogpost 对此进行了解释，但并未真正解释他们为什么这样做。这是他在下面的 cmets 中发布的。