c++ - 当我使用 VirtualAlloc() 和 MEM_RESERVE 保留内存时，我不应该能够在 64K 边界上增加我的分配吗？

Question

首先，我非常清楚 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 边界上保留内存 always，因此当我always 时给 VirtualAlloc() 一个 64K 对齐的值 always正在保留页面？

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

我包含了一个我试过的小代码示例。正如你在这里看到的，第一个函数成功了，因为我保留了更多的页面，然后我的提交将有足够的“保留区域”来实际提交，但是在这种情况下，区域将是 < 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;
}

Answer 1

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

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

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