Jak duży może być malloc w C?

Obserwacje

Zakładając typowy alokator, taki jak ten, którego używa glibc, istnieją pewne obserwacje:

1. niezależnie od tego, czy pamięć jest rzeczywiście używana, region musi być bezpośrednio zarezerwowany w pamięci wirtualnej.
2. największe wolne sąsiadujące ze sobą regiony zależą od wykorzystania pamięci istniejących regionów pamięci i dostępności tych regionów do malloc.
3. praktyki mapowania zależą od architektury i systemu operacyjnego. Ponadto te praktyki wpływają na podstawowe wywołania systemowe w celu uzyskania regionów pamięci (np. mmap pozyskiwanie stron).

Eksperyment

Oto prosty program do przydzielania największego możliwego bloku (kompilacji z gcc largest_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;
    }
}

Uruchomienie powyższego programu (./a.out) na mojej Maszynie Linux stanley 2.6.32-24-generic-pae #39-Ubuntu SMP Wed Jul 28 07:39:26 UTC 2010 i686 GNU/Linux uzyskuje taki wynik:

<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

To jest przydział dokładnie 2800MiB. Obserwując odpowiednie odwzorowanie z /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]

Podsumowanie

Wygląda na to, że sterta została rozszerzona w obszarze pomiędzy danymi programu i kodem, a mapowaniami bibliotek współdzielonych, które są dopasowane do granicy przestrzeni pamięci użytkownika / jądra (oczywiście 3G/1g w tym systemie).

Ten wynik sugeruje, że maksymalna przestrzeń alokowana za pomocą malloca jest w przybliżeniu równa:

W tym przypadku nie jest to możliwe.]}
1. minus przesunięcie do początku the heap (program code and data)
2. mniej miejsca zarezerwowanego dla głównego stosu wątków
3. mniej miejsca zajmowanego przez wszystkie zmapowane biblioteki współdzielone
W zależności od tego, która z tych wartości jest większa, można ją znaleźć w obszarze dostępnym dla sterty (który może być fragmentowany przez inne mapowania).]}

Uwagi

W odniesieniu do implementacji glibc i Linuksa, następujące fragmenty podręcznika są świetne zainteresowanie:

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.

Afterword

Ten test został wykonany na jądrze x86. Spodziewałbym się podobnych rezultatów po jądrze x86_64, aczkolwiek z zwróconymi znacznie większymi regionami pamięci. Inne systemy operacyjne mogą różnić się rozmieszczeniem mapowań i obsługą dużych malloc s, Więc wyniki mogą być znacznie różne.