Como posso ativar a divisão 4G / 4G no Linux?

Question

É um recurso útil para sistemas que estão usando (... ainda tem que usar) binários de 32 bits, e o limite de 4G foi levado em consideração.

Essencialmente, significa que o código do espaço do usuário de 32 bits, os dados do espaço do usuário de 32 bits e o kernel (32 bits com PAE ou 64 bits) residem em diferentes espaços de endereçamento, o que essencialmente permite que os processos usem quase todo o espaço de endereço 4G máximo possível para seus dados.

Exceto alguns anúncios antigos , infelizmente não consegui encontrar mais:

I am pleased to announce the first public release of the "4GB/4GB VM split" patch, for the 2.5.74 Linux kernel:

http://redhat.com/~mingo/4g-patches/4g-2.5.74-F8

The 4G/4G split feature is primarily intended for large-RAM x86 systems, which want to (or have to) get more kernel/user VM, at the expense of per-syscall TLB-flush overhead.

On x86, the total amount of virtual memory - as we all know - is limited to 4GB. Of this total 4GB VM, userspace uses 3GB (0x00000000-0xbfffffff), the kernel uses 1GB (0xc0000000-0xffffffff). This is VM scheme is called the 3/1 split. This split works perfecly fine up until 1 GB of RAM - and it works adequately well even after that, due to 'highmem', which moves various larger caches (and objects) into the high memory area.

Nos meus testes, alguns dos meus processos começam a morrer aproximadamente em 2-3 GB.

Como eu poderia conseguir isso? Eu uso um kernel recente relativo (4.10). Eu posso usar um kernel de 64 bits em um espaço de usuário de 32 bits ou usar um kernel PAE de 32 bits.

É suficiente, se apenas alguns dos processos usam 4G / 4G, mas eles parecem realmente precisar dele.

    

Answer 1

Em um kernel de 64 bits, você já tem 4G completo acessível por um programa de espaço do usuário de 32 bits. Veja a si mesmo digitando o seguinte no terminal (ATENÇÃO: seu sistema pode parar de responder se não tiver 4GiB de RAM livre ao executar isto):

cd /tmp
cat > test.c <<"EOF"
#include <stdlib.h>
#include <stdio.h>
int main()
{
    size_t allocated=0;
    while(1)
    {
        const size_t chunkSize=4096;
        char* p=malloc(chunkSize);
        if(!p) return 0;
        *p=1;
        allocated+=chunkSize;
        printf("%zu\n",allocated);
    }
    return 0;
}
EOF
gcc test.c -o test -m32 && ./test | tail -n1

No meu kernel x86_64 3.12.18 eu recebo 4282097664 como resultado, que é cerca de 4GiB-12.3MiB, então é justo considerar a divisão 4G / xG alcançada.