Por que a primeira alocação C++ (m) sempre tem 72 KB?

O mistério por trás de sua primeira alocação C++

Você escreve um programa C++ simples. Um único novo int. Quatro bytes. Você inicia o strace ou seu criador de perfil de memória favorito e aí está – seu processo solicitou cerca de 72 KB do sistema operacional. Não 4 bytes. Não 64 bytes. Um total de 72 KB. Se você já olhou para esse número e se perguntou se suas ferramentas estavam mentindo para você, você não está sozinho. Esse comportamento aparentemente bizarro é uma das perguntas mais frequentes entre os desenvolvedores de C++ que investigam os componentes internos da memória pela primeira vez, e a resposta nos leva a uma jornada fascinante pelas camadas que ficam entre o seu código e o hardware real.

O que acontece quando você liga para novo

Para entender o número de 72 KB, você precisa rastrear toda a cadeia de alocação. Quando seu código C++ executa new int, o compilador traduz isso em uma chamada para o operador new, que na maioria dos sistemas Linux delega para malloc da glibc. Mas malloc não pede diretamente ao kernel 4 bytes de memória. O kernel opera em páginas — normalmente 4 KB em x86_64 — e o custo de uma chamada de sistema é enorme em relação a um simples acesso à memória. Chamar brk() ou mmap() para cada alocação individual faria qualquer programa não trivial parar.

Em vez disso, o alocador de memória da glibc — uma implementação chamada ptmalloc2, ela própria descendente do clássico dlmalloc de Doug Lea — atua como intermediário. Ele solicita grandes blocos de memória do kernel antecipadamente e depois os divide em pedaços menores conforme seu programa precisa deles. Esta é a razão fundamental pela qual sua primeira alocação de 4 bytes aciona uma solicitação muito maior ao sistema operacional. O alocador não está sendo um desperdício. É ser estratégico.

Dissecando os 72 KB: para onde vão os bytes

A sobrecarga de alocação inicial vem de vários componentes distintos que o tempo de execução deve inicializar antes de poder entregar a você até mesmo um único byte de memória utilizável. A compreensão de cada componente explica por que o número chega onde está.

Primeiro, o malloc da glibc inicializa a arena principal — a estrutura contábil primária que rastreia todas as alocações no thread principal. Essa arena inclui metadados para heap, ponteiros de lista livre e estruturas bin para diferentes tamanhos de alocação. O alocador estende a pausa do programa via sbrk(), e a extensão inicial é governada por um parâmetro interno chamado M_TOP_PAD, cujo padrão é 128 KB de preenchimento. No entanto, a solicitação inicial real é ajustada para o alinhamento da página e a posição de quebra existente, o que geralmente resulta em uma primeira solicitação menor – geralmente chegando perto do valor de 72 KB em um processo recém-iniciado.

Segundo, desde a glibc 2.26, o alocador inicializa um cache local de thread (tcache) no primeiro uso. O tcache contém 64 compartimentos (um por classe de tamanho de alocação pequena), cada um capaz de armazenar até 7 blocos em cache. O próprio tcache_perthread_struct consome cerca de 1 KB, mas o ato de inicializá-lo aciona a configuração mais ampla da arena. Terceiro, o tempo de execução do C++ já executou alocações antes mesmo de seu main() ser executado - construtores estáticos, inicialização do buffer iostream para std::cout e amigos e configuração de localidade contribuem para essa pegada inicial de heap.

O sistema Arena e por que a pré-alocação é inteligente

A decisão de pré-alocar uma parte substancial de memória em vez de solicitá-la aos poucos não é um acidente de implementação. É uma troca deliberada de engenharia enraizada em décadas de experiência em programação de sistemas. Cada chamada para brk() ou mmap() envolve uma mudança de contexto do espaço do usuário para o espaço do kernel, modificação dos mapeamentos de memória virtual do processo e possíveis atualizações da tabela de páginas. Em hardware moderno, uma única chamada de sistema custa cerca de 100 a 200 nanossegundos – trivial isoladamente, mas catastrófica em escala.

Considere um programa que faz 10.000 pequenas alocações durante a inicialização. Sem pré-alocação, isso significaria 10.000 chamadas de sistema, custando aproximadamente 1 a 2 milissegundos de pura sobrecarga. Com um alocador baseado em arena, o primeiro gatilho de alocação

Related Posts

• Direções do Google baseadas em texto
• QGIS 4.0
• Fiz uma torta todos os dias durante um ano e isso mudou minha vida
• A equipe quixotesca tentando construir um mundo em um jogo de 20 anos

Por que a primeira alocação C++ (m) sempre tem 72 KB?

O mistério por trás de sua primeira alocação C++
Você escreve um programa C++ simples. Um único novo int. Quatro bytes. Você inicia o strace ou seu criador de perfil de memória favorito e aí está – seu processo solicitou cerca de 72 KB do sistema operacional. Não 4 bytes. Não 64 bytes. Um total de 72 KB. Se você já olhou para esse número e se perguntou se suas ferramentas estavam mentindo para você, você não está sozinho. Esse comportamento aparentemente bizarro é uma das perguntas mais frequentes entre os desenvolvedores de C++ que investigam os componentes internos da memória pela primeira vez.

Como funciona o alinhamento de memória no C++?

O alinhamento de memória em C++ refere-se aos padrões de alocação de memória pelo compilador para que os dados sejam armazenados de maneira que os endereços de memória sejam múltiplos de um tamanho mínimo específico. Para o C++, esse tamanho mínimo é de 8 bytes, ou seja, um inteiro. Isso ocorre para garantir que o acesso a memória seja eficiente. Por exemplo, um inteiro de 32 bits requer um endereço de memória de 32 bits, enquanto um inteiro de 64 bits requer um endereço de memória de 64 bits. O compilador, portanto, precisa alinhar a memória de tal forma que acessos a memória sejam sempre múltiplos de 8 bytes.

O que significa "alinhamento de 4 bytes"?