此文版權屬於作者所有，任何人、媒體或者網站轉載、借用都必須征得作者本人同意！
32 位的程序尋址空間是 4G，因此能用的內存應該有 4G，除掉一些系統等使用的亂七八糟的東西，3G 內存應該沒有問題吧，這些只是猜測，寫個程序測一下，結果如下：
測試結論：
1. 棧內存最大可用 768k 左右；
2. 堆內存最大可用 1.586G 左右。
結果令人沮喪，才 1.6 G!!!
測試環境：Windows7 2G、IBMSL300、VC9
附錄測試程序等
測試程序只考慮 windows，首先，說明一下相關知識：
內存可以來自兩個地方，在棧空間上分配的內存（棧內存）和在堆空間分配的內存（堆內存）。
棧內存，通過 alloca 來申請。
堆內存，通過 malloc、new、VirtualAlloc 來申請。
測試程序如下：
/* $Id$ */
/**
* \file memory_test.cpp
*
* \brief 大內存申請測試
*
* \version $Rev$
* \author
* \date 2010年04月06日:09:24
*
* \note 修改歷史：<br>
* <table>
* <tr><th>日期</th><th>修改人</th><th>內容</th></tr>
* <tr><td>2010-4-6</td><td></td><td>創建初稿</td>
* </tr>
* </table>
*/
#include <stdio.h>
#include <malloc.h>
#include <windows.h>
#include <excpt.h>
// alloca: Allocates memory on the stack
static bool alloca_test(size_t s)
{
__try{
alloca(s); printf(" √1 alloca(%u) 通過\n", s);
}__except( GetExceptionCode() == STATUS_STACK_OVERFLOW ){
printf(" ×1 alloca(%u) 失敗，內存溢出\n", s);
_resetstkoflw();
return false;
}
__try{
alloca(s); printf(" √2 alloca(%u) 通過\n", s);
}__except( GetExceptionCode() == STATUS_STACK_OVERFLOW ){
printf(" ×2 alloca(%u) 失敗，內存溢出\n", s);
_resetstkoflw();
return false;
}
return true;
}
// malloc: Allocates memory blocks.
static bool malloc_test(size_t s)
{
void* buf = malloc(s);
if (buf)
printf(" √malloc(%u) 通過\n", s);
else
printf(" ×malloc(%u) 失敗\n", s);
free(buf);
return buf != 0;
}
// malloc: Allocates memory blocks.
static bool malloc_test2(size_t s)
{
void* buf1 = malloc(s);
void* buf2 = malloc(s);
if (buf1)
printf(" √buf1 malloc(%u) 通過\n", s);
else
printf(" ×buf1 malloc(%u) 失敗\n", s);
if (buf2)
printf(" √buf2 malloc(%u) 通過\n", s);
else
printf(" ×buf2 malloc(%u) 失敗\n", s);
free(buf1);
free(buf2);
return buf1 != 0 && buf2 != 0;
}
static bool new_test(size_t s)
{
try
{
char* buf = new char[s];
delete[] buf;
printf(" √new char[%u] 成功\n", s);
return true;
}catch(...){
printf(" ×new char[%u] 失敗\n", s);
return false;
}
}
bool VirtualAlloc_test(size_t s)
{
LPVOID buf = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);
VirtualFree(buf, 0, MEM_RELEASE);
if (buf)
printf(" √VirtualAlloc(NULL, %u, ..) 成功\n", s);
else
printf(" ×VirtualAlloc(NULL, %u, ..) 失敗\n", s);
return buf != 0;
}
bool VirtualAlloc_test2(size_t s)
{
LPVOID buf1 = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);
LPVOID buf2 = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);
VirtualFree(buf1, 0, MEM_RELEASE);
VirtualFree(buf2, 0, MEM_RELEASE);
if (buf1)
printf(" √1 VirtualAlloc(NULL, %u, ..) 成功\n", s);
else
printf(" ×1 VirtualAlloc(NULL, %u, ..) 失敗\n", s);
if (buf2)
printf(" √2 VirtualAlloc(NULL, %u, ..) 成功\n", s);
else
printf(" ×2 VirtualAlloc(NULL, %u, ..) 失敗\n", s);
return buf1 != 0 && buf2 != 0;
}
const size_t SIZE_K = (((size_t)1) << 10);
const size_t SIZE_M = (SIZE_K << 10);
const size_t SIZE_G = (SIZE_M << 10);
// 把大小轉換為xxxK、xxxM、xxxG 之類的描述，非線程安全！
static char const*const i2a(size_t s)
{
static char buf[24];
if (s < SIZE_M) {
sprintf(buf, "%uK", s/SIZE_K);
} else if (s < SIZE_G) {
sprintf(buf, "%.3fM", (double)s/SIZE_M);
} else {
sprintf(buf, "%.3fG", (double)s/SIZE_G);
}
return buf;
}
int main(int, char**)
{
size_t sizes[] =
{
SIZE_K // 1K
, 128*SIZE_K // 128K
, 256*SIZE_K // 256K
, 512*SIZE_K // 512K
, 768*SIZE_K // 768K
, SIZE_M // 1M
, 512*SIZE_M // 512M
, 640*SIZE_M // 640M
, 768*SIZE_M // 768M
, SIZE_G // 1G
, SIZE_G + 100*SIZE_M // 1.1G
, SIZE_G + 200*SIZE_M // 1.2G
, SIZE_G + 300*SIZE_M // 1.3G
, SIZE_G + 400*SIZE_M // 1.4G
, SIZE_G + 500*SIZE_M // 1.5G
, SIZE_G + 600*SIZE_M // 1.6G
, SIZE_G + 700*SIZE_M // 1.7G
, SIZE_G + 800*SIZE_M // 1.8G
, SIZE_G + 900*SIZE_M // 1.9G
};
printf("大內存申請測試\n");
bool res = true;
for (size_t i = 0, c = sizeof(sizes)/sizeof(sizes[0]); i != c && res; ++i)
{
size_t s = sizes[i];
printf(" 測試申請%s 內存\n", i2a(s));
res = false;
res = alloca_test(s) || res;
res = malloc_test(s) || res;
res = new_test(s) || res;
res = VirtualAlloc_test(s) || res;
if (s >= 1024*1024*512)
{
res = malloc_test2(s) || res;
res = VirtualAlloc_test2(s) || res;
}
}
return 0;
}
運行結果如下：
大內存申請測試
測試申請 1K 內存
√ 1 alloca(1024) 通過
√ 2 alloca(1024) 通過
√ malloc(1024) 通過
√ new char[1024] 成功
√ VirtualAlloc(NULL, 1024, ..) 成功
測試申請 128K 內存
√ 1 alloca(131072) 通過
√ 2 alloca(131072) 通過
√ malloc(131072) 通過
√ new char[131072] 成功
√ VirtualAlloc(NULL, 131072, ..) 成功
測試申請 256K 內存
√ 1 alloca(262144) 通過
√ 2 alloca(262144) 通過
√ malloc(262144) 通過
√ new char[262144] 成功
√ VirtualAlloc(NULL, 262144, ..) 成功
測試申請 512K 內存
√ 1 alloca(524288) 通過
× 2 alloca(524288) 失敗，內存溢出
√ malloc(524288) 通過
√ new char[524288] 成功
√ VirtualAlloc(NULL, 524288, ..) 成功
測試申請 768K 內存
√ 1 alloca(786432) 通過
× 2 alloca(786432) 失敗，內存溢出
√ malloc(786432) 通過
√ new char[786432] 成功
√ VirtualAlloc(NULL, 786432, ..) 成功
測試申請 1.000M 內存
× 1 alloca(1048576) 失敗，內存溢出
√ malloc(1048576) 通過
√ new char[1048576] 成功
√ VirtualAlloc(NULL, 1048576, ..) 成功
測試申請 512.000M 內存
× 1 alloca(536870912) 失敗，內存溢出
√ malloc(536870912) 通過
√ new char[536870912] 成功
√ VirtualAlloc(NULL, 536870912, ..) 成功
√ buf1 malloc(536870912) 通過
√ buf2 malloc(536870912) 通過
√ 1 VirtualAlloc(NULL, 536870912, ..) 成功
√ 2 VirtualAlloc(NULL, 536870912, ..) 成功
測試申請 640.000M 內存
× 1 alloca(671088640) 失敗，內存溢出
√ malloc(671088640) 通過
√ new char[671088640] 成功
√ VirtualAlloc(NULL, 671088640, ..) 成功
√ buf1 malloc(671088640) 通過
√ buf2 malloc(671088640) 通過
√ 1 VirtualAlloc(NULL, 671088640, ..) 成功
√ 2 VirtualAlloc(NULL, 671088640, ..) 成功
測試申請 768.000M 內存
× 1 alloca(805306368) 失敗，內存溢出
√ malloc(805306368) 通過
√ new char[805306368] 成功
√ VirtualAlloc(NULL, 805306368, ..) 成功
√ buf1 malloc(805306368) 通過
√ buf2 malloc(805306368) 通過
√ 1 VirtualAlloc(NULL, 805306368, ..) 成功
√ 2 VirtualAlloc(NULL, 805306368, ..) 成功
測試申請 1.000G 內存
× 1 alloca(1073741824) 失敗，內存溢出
√ malloc(1073741824) 通過
√ new char[1073741824] 成功
√ VirtualAlloc(NULL, 1073741824, ..) 成功
√ buf1 malloc(1073741824) 通過
× buf2 malloc(1073741824) 失敗
√ 1 VirtualAlloc(NULL, 1073741824, ..) 成功
× 2 VirtualAlloc(NULL, 1073741824, ..) 失敗
測試申請 1.098G 內存
× 1 alloca(1178599424) 失敗，內存溢出
√ malloc(1178599424) 通過
√ new char[1178599424] 成功
√ VirtualAlloc(NULL, 1178599424, ..) 成功
√ buf1 malloc(1178599424) 通過
× buf2 malloc(1178599424) 失敗
√ 1 VirtualAlloc(NULL, 1178599424, ..) 成功
× 2 VirtualAlloc(NULL, 1178599424, ..) 失敗
測試申請 1.195G 內存
× 1 alloca(1283457024) 失敗，內存溢出
√ malloc(1283457024) 通過
√ new char[1283457024] 成功
√ VirtualAlloc(NULL, 1283457024, ..) 成功
√ buf1 malloc(1283457024) 通過
× buf2 malloc(1283457024) 失敗
√ 1 VirtualAlloc(NULL, 1283457024, ..) 成功
× 2 VirtualAlloc(NULL, 1283457024, ..) 失敗
測試申請 1.293G 內存
× 1 alloca(1388314624) 失敗，內存溢出
√ malloc(1388314624) 通過
√ new char[1388314624] 成功
√ VirtualAlloc(NULL, 1388314624, ..) 成功
√ buf1 malloc(1388314624) 通過
× buf2 malloc(1388314624) 失敗
√ 1 VirtualAlloc(NULL, 1388314624, ..) 成功
× 2 VirtualAlloc(NULL, 1388314624, ..) 失敗
測試申請 1.391G 內存
× 1 alloca(1493172224) 失敗，內存溢出
√ malloc(1493172224) 通過
√ new char[1493172224] 成功
√ VirtualAlloc(NULL, 1493172224, ..) 成功
√ buf1 malloc(1493172224) 通過
× buf2 malloc(1493172224) 失敗
√ 1 VirtualAlloc(NULL, 1493172224, ..) 成功
× 2 VirtualAlloc(NULL, 1493172224, ..) 失敗
測試申請 1.488G 內存
× 1 alloca(1598029824) 失敗，內存溢出
√ malloc(1598029824) 通過
√ new char[1598029824] 成功
√ VirtualAlloc(NULL, 1598029824, ..) 成功
√ buf1 malloc(1598029824) 通過
× buf2 malloc(1598029824) 失敗
√ 1 VirtualAlloc(NULL, 1598029824, ..) 成功
× 2 VirtualAlloc(NULL, 1598029824, ..) 失敗
測試申請 1.586G 內存
× 1 alloca(1702887424) 失敗，內存溢出
√ malloc(1702887424) 通過
√ new char[1702887424] 成功
√ VirtualAlloc(NULL, 1702887424, ..) 成功
√ buf1 malloc(1702887424) 通過
× buf2 malloc(1702887424) 失敗
√ 1 VirtualAlloc(NULL, 1702887424, ..) 成功
× 2 VirtualAlloc(NULL, 1702887424, ..) 失敗
測試申請 1.684G 內存
× 1 alloca(1807745024) 失敗，內存溢出
× malloc(1807745024) 失敗
× new char[1807745024] 失敗
× VirtualAlloc(NULL, 1807745024, ..) 失敗
× buf1 malloc(1807745024) 失敗
× buf2 malloc(1807745024) 失敗
× 1 VirtualAlloc(NULL, 1807745024, ..) 失敗
× 2 VirtualAlloc(NULL, 1807745024,
