Por que esse comedor de memória realmente não come memória?

Quero criar um programa que simule uma situação de falta de memória (OOM) em um servidor Unix. Eu criei este super comedor de memória super simples:

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

unsigned long long memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
void *memory = NULL;

int eat_kilobyte()
{
    memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        // realloc failed here - we probably can't allocate more memory for whatever reason
        return 1;
    }
    else
    {
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    printf("I will try to eat %i kb of ram\n", memory_to_eat);
    int megabyte = 0;
    while (memory_to_eat > 0)
    {
        memory_to_eat--;
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory! Stucked at %i kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            printf("Eaten 1 MB of ram\n");
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

Ele consome tanta memória quanto definida, na memory_to_eatqual agora são exatamente 50 GB de RAM. Ele aloca memória em 1 MB e imprime exatamente o ponto em que deixa de alocar mais, para que eu saiba qual valor máximo conseguiu consumir.

O problema é que funciona. Mesmo em um sistema com 1 GB de memória física.

Quando verifico na parte superior, vejo que o processo consome 50 GB de memória virtual e apenas menos de 1 MB de memória residente. Existe uma maneira de criar um comedor de memória que realmente o consome?

Especificações do sistema: Kernel do Linux 3.16 ( Debian ) provavelmente com a confirmação excessiva ativada (não sei como fazer check-out) sem troca e virtualizada.

Quando sua malloc()implementação solicita memória ao kernel do sistema (por meio de uma chamada sbrk()ou mmap()sistema), o kernel apenas anota que você solicitou a memória e onde ela deve ser colocada no seu espaço de endereço. Na verdade, ele ainda não mapeia essas páginas .

Quando o processo acessa a memória posteriormente na nova região, o hardware reconhece uma falha de segmentação e alerta o kernel para a condição. O kernel então consulta a página em suas próprias estruturas de dados e descobre que você deve ter uma página zero lá, para que ele mapeie em uma página zero (possivelmente expulsando uma página do cache de páginas) e retorne da interrupção. Seu processo não percebe que nada disso aconteceu, a operação dos kernels é perfeitamente transparente (exceto pelo pequeno atraso enquanto o kernel faz seu trabalho).

Essa otimização permite que a chamada do sistema retorne muito rapidamente e, o mais importante, evita que todos os recursos sejam comprometidos com o seu processo quando o mapeamento é feito. Isso permite que os processos reservem buffers bastante grandes que eles nunca precisam em circunstâncias normais, sem medo de consumir muita memória.

Portanto, se você deseja programar um comedor de memória, é absolutamente necessário fazer algo com a memória que você aloca. Para isso, você só precisa adicionar uma única linha ao seu código:

int eat_kilobyte()
{
    if (memory == NULL)
        memory = malloc(1024);
    else
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        //Force the kernel to map the containing memory page.
        ((char*)memory)[1024*eaten_memory] = 42;

        eaten_memory++;
        return 0;
    }
}

Observe que é perfeitamente suficiente gravar em um único byte em cada página (que contém 4096 bytes no X86). Isso ocorre porque toda a alocação de memória do kernel para um processo é feita na granularidade da página de memória, o que, por sua vez, ocorre devido ao hardware que não permite a paginação em granularidades menores.

Todas as páginas virtuais iniciam a cópia na gravação mapeada para a mesma página física zerada. Para usar páginas físicas, você pode sujá-las escrevendo algo em cada página virtual.

Se estiver executando como root, você pode usar mlock(2)ou fazer mlockall(2)com que o kernel ligue as páginas quando elas estiverem alocadas, sem precisar sujá-las. (usuários não-root normais têm ulimit -lapenas 64 KB.)

Como muitos outros sugeriram, parece que o kernel Linux realmente não aloca a memória, a menos que você escreva nele

Uma versão aprimorada do código, que faz o que o OP estava querendo:

Isso também corrige as incompatibilidades da cadeia de caracteres do formato printf com os tipos de memory_to_eat e eaten_memory, usando %zipara imprimir size_tnúmeros inteiros. O tamanho da memória a ser consumida, em kiB, pode opcionalmente ser especificado como um argumento de linha de comando.

O design confuso usando variáveis ​​globais e crescendo 1k em vez de 4k páginas é inalterado.

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

size_t memory_to_eat = 1024 * 50000;
size_t eaten_memory = 0;
char *memory = NULL;

void write_kilobyte(char *pointer, size_t offset)
{
    int size = 0;
    while (size < 1024)
    {   // writing one byte per page is enough, this is overkill
        pointer[offset + (size_t) size++] = 1;
    }
}

int eat_kilobyte()
{
    if (memory == NULL)
    {
        memory = malloc(1024);
    } else
    {
        memory = realloc(memory, (eaten_memory * 1024) + 1024);
    }
    if (memory == NULL)
    {
        return 1;
    }
    else
    {
        write_kilobyte(memory, eaten_memory * 1024);
        eaten_memory++;
        return 0;
    }
}

int main(int argc, char **argv)
{
    if (argc >= 2)
        memory_to_eat = atoll(argv[1]);

    printf("I will try to eat %zi kb of ram\n", memory_to_eat);
    int megabyte = 0;
    int megabytes = 0;
    while (memory_to_eat-- > 0)
    {
        if (eat_kilobyte())
        {
            printf("Failed to allocate more memory at %zi kb :(\n", eaten_memory);
            return 200;
        }
        if (megabyte++ >= 1024)
        {
            megabytes++;
            printf("Eaten %i  MB of ram\n", megabytes);
            megabyte = 0;
        }
    }
    printf("Successfully eaten requested memory!\n");
    free(memory);
    return 0;
}

Uma otimização sensata está sendo feita aqui. O tempo de execução não adquire a memória até você usá-la.

Um simples memcpyserá suficiente para contornar essa otimização. (Você pode achar que callocainda otimiza a alocação de memória até o ponto de uso.)

Não tenho certeza sobre este, mas a única explicação que posso fazer é que o linux é um sistema operacional de copiar em escrever. Quando se chama forkos dois processos, aponte para a mesma memória fisicamente. A memória é copiada apenas quando um processo realmente grava na memória.

Penso que aqui, a memória física real só é alocada quando se tenta escrever algo nela. Chamar sbrkou mmappode muito bem atualizar apenas a manutenção de livros em memória do kernel. A RAM real só pode ser alocada quando realmente tentamos acessar a memória.