experiment : 在私有堆和默认进程堆中, 测试能分配的堆空间总和, 每次能分配的最大堆空间

实验环境: Win7X64Sp1 + vs2008,  物理内存16GB.

实验结论:

*  进程堆的最大Size并没有使用完剩余的物理内存
    *  每次能分配的最大堆空间接近2M, 不管是私有堆,还是进程堆, 和堆初始Size无关, 
    *  将堆空间用尽后, 累计堆空间总Size接近2000MB, 不管是私有堆,还是进程堆, 和堆初始Size无关,

1. /// @file       getHeapSize.cpp
2. /// @brief      尝试得到本进程堆的最大size
3. #include "stdafx.h"
4. #include <Windows.h>
5. #include <tchar.h>
6. #define MEMORY_REQUESTED_MB (1024 * 1024)       ///< 请求的堆尺寸单位(MB)
7. size_t  GetSystemPageSize();
8. bool    GetHeapSize(HANDLE hHeap, size_t & nSizeHeapOnce, size_t & nSizeHeap);
9. bool    GetHeapAllocTotal(HANDLE hHeap, size_t nSizeHeapOnce, size_t & nSizeHeapTotal); ///< 计算在堆上能分配的空间总和
10. int _tmain(int argc, _TCHAR* argv[])
11. {
12. bool    bRc             =   false;
13. int     iIndex          =   0;
14. size_t  nSizeHeap       =   0;
15. size_t  nSizeHeapOnce   =   0;
16. size_t  nSizeHeapTotal  =   0;
17. HANDLE  hHeap           =   GetProcessHeap();
18. _tprintf(L"when hHeap = GetProcessHeap();\n");
19. for(iIndex = 0; iIndex < 5; iIndex++)
20. {
21. bRc = GetHeapSize(hHeap, nSizeHeapOnce, nSizeHeap);
22. _tprintf(   L"GetHeapSize() = %s, nSizeHeap = 0x%X, %.3f(MB)\n",
23. bRc ? L"TRUE" : L"FALSE",
24. nSizeHeap, 1.0f * nSizeHeap / MEMORY_REQUESTED_MB);
25. }
26. /// 对私有堆的测试
27. nSizeHeap = MEMORY_REQUESTED_MB * 10;
28. hHeap = HeapCreate(0, GetSystemPageSize() * 4, nSizeHeap);  ///< 建立10MB的私有堆, 每次提交4Page
29. if(NULL == hHeap)
30. _tprintf(L"HeapCreate error code = 0x%x\n", GetLastError());
31. else
32. {
33. _tprintf(L"HeapCreate Ok, nSizeHeap = %dMB\n", nSizeHeap / MEMORY_REQUESTED_MB);
34. for(iIndex = 0; iIndex < 5; iIndex++)
35. {
36. bRc = GetHeapSize(hHeap, nSizeHeapOnce, nSizeHeap);
37. _tprintf(   L"GetHeapSize() = %s, nSizeHeap = 0x%X, %.3f(MB)\n",
38. bRc ? L"TRUE" : L"FALSE",
39. nSizeHeap, 1.0f * nSizeHeap / MEMORY_REQUESTED_MB);
40. }
41. HeapDestroy(hHeap);
42. }
43. /// 测试从私有堆上能分配的最大空间, 依次分配一块, 计算能分配的空间总和
44. nSizeHeap = MEMORY_REQUESTED_MB * 10;
45. if(0 == nSizeHeapOnce)
46. nSizeHeapOnce = GetSystemPageSize();
47. _tprintf(L"nSizeHeapOnce = 0x%x\n", nSizeHeapOnce);
48. hHeap = HeapCreate(0, nSizeHeapOnce, nSizeHeap);    ///< 建立10MB的私有堆, 每次提交4Page
49. if(NULL == hHeap)
50. _tprintf(L"HeapCreate error code = 0x%x\n", GetLastError());
51. else
52. {
53. _tprintf(L"HeapCreate Ok, nSizeHeap = %dMB\n", nSizeHeap / MEMORY_REQUESTED_MB);
54. bRc = GetHeapAllocTotal(hHeap, nSizeHeapOnce, nSizeHeapTotal);
55. _tprintf(   L"GetHeapAllocTotal() = %s, nSizeHeapOnce = 0x%X, %.3f(MB), nSizeHeapTotal = 0x%X, %.3f(MB)\n",
56. bRc ? L"TRUE" : L"FALSE",
57. nSizeHeapOnce, 1.0f * nSizeHeapOnce / MEMORY_REQUESTED_MB,
58. nSizeHeapTotal, 1.0f * nSizeHeapTotal / MEMORY_REQUESTED_MB);
59. HeapDestroy(hHeap);
60. }
61. /** operating results
62. 将程序编译成Release + win32, 在IDE外直接运行
63. when hHeap = GetProcessHeap();
64. GetHeapSize() = TRUE, nSizeHeap = 0x70CBF000, 1804.746(MB)
65. GetHeapSize() = TRUE, nSizeHeap = 0x70CBF000, 1804.746(MB)
66. GetHeapSize() = TRUE, nSizeHeap = 0x70CBF000, 1804.746(MB)
67. GetHeapSize() = TRUE, nSizeHeap = 0x70CBF000, 1804.746(MB)
68. GetHeapSize() = TRUE, nSizeHeap = 0x70CBF000, 1804.746(MB)
69. HeapCreate Ok, nSizeHeap = 10MB
70. GetHeapSize() = TRUE, nSizeHeap = 0x1FF000, 1.996(MB)
71. GetHeapSize() = TRUE, nSizeHeap = 0x1FF000, 1.996(MB)
72. GetHeapSize() = TRUE, nSizeHeap = 0x1FF000, 1.996(MB)
73. GetHeapSize() = TRUE, nSizeHeap = 0x1FF000, 1.996(MB)
74. GetHeapSize() = TRUE, nSizeHeap = 0x1FF000, 1.996(MB)
75. nSizeHeapOnce = 0x1ff000
76. HeapCreate Ok, nSizeHeap = 10MB
77. GetHeapAllocTotal() = TRUE, nSizeHeapOnce = 0x1FF000, 1.996(MB), nSizeHeapTotal
78. = 0x7C41C000, 1988.109(MB)
79. 剩余物理内存是8655M, 看来进程堆的最大Size并没有使用完剩余的物理内存
80. 经过多次实验, 进程堆的Size大约是1800上下几MB
81. 建立10MB的私有堆, 测试出的私有堆大小为2MB左右??
82. 建立了20MB的私有堆, 测试出的私有堆大小也为2MB左右.
83. 建立了100MB的私有堆, 测试出的私有堆大小也为2MB左右.
84. 结论: 进程私有堆是程序编译时指定的, 指定多大都没用
85. 在vs2008中设置对大小为10MB, 10485760
86. 设置步骤: vs2008工程属性 >> Configuration Properties >> Linker >> System >> Heap Reserver Size
87. 实验结果:
88. * 每次能分配的堆空间一直2M左右, 不管是私有堆,还是进程堆, 和堆初始Size无关,
89. * 能分配的堆空间总和接近2000MB, 不管是私有堆,还是进程堆, 和堆初始Size无关,
90. */
91. getchar();
92. return 0;
93. }
94. bool    GetHeapAllocTotal(HANDLE hHeap, size_t nSizeHeapOnce, size_t & nSizeHeapTotal)
95. {
96. bool        bRc             =   false;
97. BYTE *      pBufHeap        =   NULL;
98. nSizeHeapTotal = 0;
99. do
100. {
101. pBufHeap = static_cast<BYTE *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSizeHeapOnce));
102. if(NULL != pBufHeap)
103. {
104. bRc = true;
105. nSizeHeapTotal += nSizeHeapOnce;
106. }
107. } while (NULL != pBufHeap);
108. return bRc;
109. }
110. bool    GetHeapSize(HANDLE hHeap, size_t & nSizeHeapOnce, size_t & nSizeHeap)
111. {
112. bool        bRc             =   false;
113. size_t      nSystemPageSize =   GetSystemPageSize();
114. int         iMultiple       =   0;          ///< 内存申请容量是SYSTEM_INFO.PageSize的倍数
115. BYTE *      pBufHeap        =   NULL;
116. iMultiple = static_cast<size_t>(MEMORY_REQUESTED_MB) / nSystemPageSize;
117. nSizeHeap = iMultiple * nSystemPageSize;    ///< 从1MB开始尝试
118. do
119. {
120. pBufHeap = static_cast<BYTE *>(HeapAlloc(hHeap, HEAP_ZERO_MEMORY, nSizeHeap));
121. if(NULL != pBufHeap)
122. {
123. if(FALSE == HeapFree(GetProcessHeap(), 0, pBufHeap))
124. return false;
125. }
126. iMultiple *= 2; ///< 快速靠近堆上限制
127. nSizeHeap = iMultiple * nSystemPageSize;
128. } while (NULL != pBufHeap); ///< 一直尝试到失败为止
129. /// 从失败的最大Size往小申请, 第一次成功的Size就是进程堆的Size
130. nSizeHeap = --iMultiple * nSystemPageSize;
131. do
132. {
133. pBufHeap = static_cast<BYTE *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSizeHeap));
134. if(NULL != pBufHeap)
135. {
136. if(FALSE == HeapFree(GetProcessHeap(), 0, pBufHeap))
137. {
138. return false;
139. }
140. bRc = true;
141. nSizeHeapOnce = nSizeHeap;
142. break;
143. }
144. nSizeHeap = --iMultiple * nSystemPageSize;
145. } while (NULL == pBufHeap); ///< 一直尝试到成功为止
146. return bRc;
147. }
148. size_t  GetSystemPageSize()
149. {
150. /// SYSTEM_INFO.dwPageSize : 页面大小和页保护和承诺的粒度, 是VirtualAlloc的入参
151. SYSTEM_INFO sSysInfo;
152. GetSystemInfo(&sSysInfo);
153. return sSysInfo.dwPageSize;
154. }

http://blog.csdn.net/lostspeed/article/details/8423215