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

Question

首先，我非常清楚如何VirtualAlloc()工作：当我保留内存块时，我得到与 64K 边界对齐的地址（可以通过 轻松获得该值GetSystemInfo()），然后当我提交页面时，我得到它们的页面大小边界，通常为 4K。

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

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

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

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

那么，进程的虚拟空间会不会有漏洞呢？为了避免这种情况，我是否必须始终在 64K 边界上保留内存，因此在保留页面时始终VirtualAlloc()给出64K 对齐的值？

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

我提供了一些我尝试过的代码示例。正如您在这里所看到的，第一个函数成功了，因为我保留了更多页面，那么我的提交将有足够的“保留区域”来实际提交，但在这种情况下，该区域将<64K，那么那些“丢失的”页面去哪儿了？

在第二种情况下，我只是MEM_RESERVE|MEM_COMMIT，因此提交其他页面会失败并显示ERROR_INVALID_ADDRESS最后一个错误代码。很公平，但同样在这里，为什么我不能提交更多页面，至少在 64K 边界上？为了不浪费地址并创建这些“漏洞”，我真的应该在 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将保留比您要求的更多的页面。我不知道微软到底为什么选择这种方式，但它似乎符合最少惊讶的原则。特别是，通过将其主要保留为隐藏的实现细节，这意味着如果决定更改分配粒度大小，则中断的程序会更少（但是，目前我认为 Microsoft 不可能更改这一点。）它还可能减少跟踪保留页面所需的内存。

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