为什么当内存足够时 malloc() 会失败？

Question

我正在使用具有 128GB 内存的服务器进行一些计算。我需要malloc() 一个大小为 56120 * 56120 的二维浮点数组。示例代码如下：

int main(int argc, char const *argv[])
{
    float *ls;
    int num = 56120,i,j;
    ls = (float *)malloc((num * num)*sizeof(float));
    if(ls == NULL){
        cout << "malloc failed !!!" << endl;
        while(1);
    }
    cout << "malloc succeeded ~~~" << endl;
    return 0;
}

代码编译成功，但是当我运行它时，它显示"malloc failed !!!"。正如我计算的那样，保存整个数组只需要大约 11GB 的内存。在开始编写代码之前，我检查了服务器，发现有 110GB 可用内存。为什么会出现错误？

我还发现，如果我将num 减少到，比如 40000，那么 malloc 就会成功。

这是否意味着malloc()可以分配的最大内存有限制？

另外，如果我改变分配方式，直接声明一个这样大小的二维浮点数组，如下：

int main(int argc, char const *argv[])
{
    int num = 56120,i,j;
    float ls[3149454400];
    if(ls == NULL){
        cout << "malloc failed !!!" << endl;
        while(1);
    }
    cout << "malloc succeeded ~~~" << endl;
    for(i = num - 10 ; i < num; i ++){
        for( j = num - 10; j < num ; j++){
            ls[i*num + j] = 1;
        }
    }
    for(i = num - 11 ; i < num; i ++){
        for( j = num - 11; j < num ; j++){
            cout << ls[i*num + j] << endl;
        }
    }
    return 0;
}

然后我编译并运行它。我收到了"Segmentation fault"。

我该如何解决这个问题？

Answer 1

问题是，你的计算

(num * num) * sizeof(float)

以 32 位有符号整数计算，num=56120 的结果为

-4582051584

然后将其解释为具有非常大值的 size_t

18446744069127500032

你没有那么多内存；）这就是malloc()失败的原因。

在 malloc 的计算中将num 转换为size_t，那么它应该可以按预期工作。

Answer 2

正如其他人指出的那样，56120*56120 溢出了 OP 平台上的 int 数学。那是未定义的行为 (UB)。

malloc(size_t x) 接受size_t 参数，传递给它的值最好至少使用size_t 数学计算。通过颠倒乘法顺序，就可以做到这一点。 sizeof(float) * num 导致 num 在乘法之前至少扩大到 size_t。

int num = 56120,i,j;
// ls = (float *)malloc((num * num)*sizeof(float));
ls = (float *) malloc(sizeof(float) * num * num);

尽管这可以防止 UB，但这并不能防止溢出，因为数学上 sizeof(float)*56120*56120 仍可能超过 SIZE_MAX。

代码可以预先检测到潜在的溢出。

if (num < 0 || SIZE_MAX/sizeof(float)/num < num) Handle_Error();

无需转换malloc()的结果。
使用引用变量的大小比调整类型更容易编码和维护。
当num == 0 时，malloc(0) == NULL 不一定是内存不足。
一起来：

int num = 56120;
if (num < 0 || ((num > 0) && SIZE_MAX/(sizeof *ls)/num < num)) {
  Handle_Error();
}
ls = malloc(sizeof *ls * num * num);
if (ls == NULL && num != 0) {
  Handle_OOM();
}

Answer 3

int num = 56120,i,j;
ls = (float *)malloc((num * num)*sizeof(float));

num * num 是 56120*56120 这是 3149454400 溢出 signed int 导致未定义的行为。

40000 起作用的原因是 40000*40000 可以表示为 int。

将num的类型改为long long（甚至unsigned int）

Answer 4

这与其他人写的相反，但对我来说，将变量 num 从 int 更改为 size_t 允许分配。可能是 num*num 溢出了 malloc 的 int。使用 56120 * 56120 而不是 num*num 执行 malloc 应该会引发溢出错误。

Answer 5

float ls[3149454400];是一个自动存储类型的数组，通常分配在进程栈上。默认情况下，进程堆栈受限于一个小于 12GB 的值远，您尝试将其推送到那里。所以你观察到的分段错误是由堆栈溢出引起的，而不是由malloc引起的。