C 中的 malloc 可以有多大？

Question

我在 C 中有一个 malloc，它是 26901^2*sizeof(double)

这让我思考这里的最大值是多少？

另外，定义宏来访问这个二维数组时会遇到任何问题吗？

 #define DN(i,j) ((int)i * ny + (int)j)

因为这似乎对我不起作用——或者至少我不确定它是否有效。我不知道如何在宏上进行 TotalView 潜水来告诉我 A[DN(indx,jndx)] 实际在看什么。

Answer 1

观察

假设一个典型的分配器，例如 glibc 使用的分配器，有一些观察：

1. 无论内存是否实际使用，该区域都必须在虚拟内存中连续保留。
2. 最大的空闲连续区域取决于现有内存区域的内存使用情况，以及这些区域对 < 的可用性代码>malloc。
3. 映射实践取决于体系结构和操作系统。此外，获取内存区域的底层系统调用也受到这些做法的影响（例如 malloc 调用 mmap 获取页面）。

实验

这是一个简单程序，用于分配最大的可能的块（使用gcclargest_malloc_size.c -Wall -O2编译：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static void *malloc_wrap(size_t size)
{
    void *p = malloc(size);
    if (p) {
        printf("Allocated %zu bytes from %p to %p\n", size, p, p + size);
    }
    else {
        printf("Failed to allocated %zu bytes\n", size);
    }
    return p;
}

int main()
{
    size_t step = 0x1000000;
    size_t size = step;
    size_t best = 0;
    while (step > 0)
    {
        void *p = malloc_wrap(size);
        if (p) {
            free(p);
            best = size;
        }
        else {
            step /= 0x10;
        }
        size += step;
    }
    void *p = malloc_wrap(best);
    if (p) {
        pause();
        return 0;
    }
    else {
        return 1;
    }
}

在我的Linux stanley 2.6.32-上运行上述程序（./a.out） 24-generic-pae #39-Ubuntu SMP Wed Jul 28 07:39:26 UTC 2010 i686 GNU/Linux 机器获得此结果：

<snip>
Allocated 2919235584 bytes from 0x9763008 to 0xb7763008
Allocated 2936012800 bytes from 0x8763008 to 0xb7763008
Failed to allocated 2952790016 bytes
Failed to allocated 2953838592 bytes
Failed to allocated 2953904128 bytes
Failed to allocated 2953908224 bytes
Allocated 2936012800 bytes from 0x85ff008 to 0xb75ff008

这是一个恰好 2800MiB 的分配 从 /proc/[number]/maps：

<snip>
0804a000-0804b000 rw-p 00001000 08:07 3413394    /home/matt/anacrolix/public/stackoverflow/a.out
085ff000-b7600000 rw-p 00000000 00:00 0          [heap]
b7600000-b7621000 rw-p 00000000 00:00 0 
b7621000-b7700000 ---p 00000000 00:00 0 
b7764000-b7765000 rw-p 00000000 00:00 0 
b7765000-b78b8000 r-xp 00000000 08:08 916041     /lib/tls/i686/cmov/libc-2.11.1.so
<snip>
bfc07000-bfc1c000 rw-p 00000000 00:00 0          [stack]

结论

看来堆已经被在程序数据和代码之间的区域以及共享库映射之间进行了扩展，这些映射紧贴用户/内核内存空间边界（在此系统上显然为 3G/1G）

此结果表明使用 malloc 的最大可分配空间大致等于：

1. 用户空间区域（示例中为 3GB）
2. 减去到堆开头的偏移量（程序代码和数据）
3. 减去为主线程堆栈保留的空间
4. 减去共享库中所有映射所占用的空间
5. 最后，底层系统调用在堆可用区域内可以找到的最大连续区域（可能是被其他映射分割）

注释

关于 glibc 和 Linux 实现，以下手册片段非常有趣：

malloc

   Normally, malloc() allocates memory from the heap, and adjusts the size
   of the heap as required, using sbrk(2).  When allocating blocks of mem‐
   ory larger than MMAP_THRESHOLD bytes, the glibc malloc() implementation
   allocates the memory as a  private  anonymous  mapping  using  mmap(2).
   MMAP_THRESHOLD  is  128  kB  by  default,  but is adjustable using mal‐
   lopt(3).

mmap

   MAP_ANONYMOUS
          The mapping is not backed by any file; its contents are initial‐
          ized to zero.

后记

该测试是在 x86 内核上完成的。我预计 x86_64 内核会得到类似的结果，尽管返回的内存区域要大得多。其他操作系统在映射的位置以及大型 malloc 的处理方面可能会有所不同，因此结果可能会有很大不同。

Answer 2

这取决于您的 malloc 实现！

根据维基百科，“自 v2.3 版本以来，GNU C 库 (glibc) 使用修改后的 ptmalloc2，它本身基于 dlmalloc v2.7.0。” dlmalloc 指的是 Doug Lea 的 malloc 实现。在此实现中需要注意的重要一点是，大型 malloc 是通过操作系统的内存映射文件功能完成的，因此这些块实际上可以非常大，而不会出现查找连续块的许多问题。

Answer 3

malloc 问题已得到解答（取决于操作系统，您没有指定），因此关于定义：

#define DN(i,j) ((int)i * ny + (int)j)

不太安全，因为有人可能会执行 DN(a+b,c) ，它会扩展为

((int)a+b * ny + (int)c)

这可能不是你想要的。因此，请在其中添加很多括号：

#define DN(i,j) ((int)(i) * ny + (int)(j))

要查看 DN(indx,jndx) 指向什么，只需 printf("%d\n",DN(indx,jndx));< /代码>

Answer 4

malloc 调用中的大小参数的类型为 size_t，该类型因实现而异。请参阅此问题了解更多的。

Answer 5

这让我思考这里的最大值是多少？

26'901^2 = 723'663'801。如果你的 double 是 8 个字节，那么它就小于 8GB。我认为分配这么多内存完全没有问题，而且我的应用程序通常会分配更多内存（在 64 位系统上）。 （我见过的最大内存消耗是 420GB（在具有 640GB RAM 的 Solaris 10 numa 系统上），最大连续块约为 24GB。）

最大值很难识别，因为它依赖于平台：与 32 位系统类似，它取决于用户-空间/内核空间分割。就目前情况而言，我认为首先会达到实际物理 RAM 的限制 - 在达到 libc 可以分配的限制之前。 （内核并不关心，它只是经常扩展虚拟内存，甚至不考虑是否有足够的 RAM 来固定它。）

Answer 6

您可以要求 malloc() 获取的最大内存块是最大的 size_t 值 - 这是来自 SIZE_MAX代码>。您可以成功请求的最大数量显然取决于操作系统和单台计算机的配置。

你的宏不安全。它使用 int 变量执行索引计算，该变量的范围只需达到 32767。任何高于此值的值都可能导致有符号溢出，从而导致未定义的行为。您可能最好以 size_t 的形式进行计算，因为该类型必须能够保存任何有效的数组索引：（

#define DN(i, j) ((size_t)(i) * ny + (size_t)(j))

尽管请注意，如果您为 i 提供负值或j，你会得到一个远远超出范围的索引）。