À medida que gerenciamos várias aplicações e serviços em um sistema Linux, lidamos com vários processos em execução simultaneamente. Um dos princípios fundamentais aqui é que cada um desses processos possui seu próprio espaço de memória dedicado.

Isso significa que a memória alocada para um processo é isolada da memória alocada para outros processos. No Linux, esse isolamento é uma característica fundamental fornecida pelos mecanismos de gerenciamento de memória do kernel.

Do ponto de vista do DevOps, esse isolamento é vital para manter a segurança e a estabilidade. Imagine se um processo pudesse acessar acidentalmente ou de maneira maliciosa a memória de outro processo. Isso poderia levar à corrupção de dados, acesso não autorizado e instabilidade do sistema. Garantindo que os processos não possam interferir na memória uns dos outros, o Linux evita esses riscos e garante que cada aplicativo ou serviço opere em seu próprio ambiente controlado.

Segmento de Código

Também conhecido como segmento de texto, é uma região da memória de um processo que armazena o código executável de um programa. Aqui é onde reside o código de máquina compilado de sua aplicação.

Ele inclui instruções que a CPU executa para realizar as tarefas definidas por seu programa. Neste segmento, o código é tipicamente somente leitura para garantir que a lógica do programa permaneça inalterada durante a execução.

Segmento de Dados

O segmento de dados contém dados inicializados e não inicializados usados pelo programa. Ele é dividido em duas partes principais:

1. Dados Inicializados (Seção de Dados): Aqui é onde estão armazenadas as variáveis globais e estáticas. Essas variáveis são explicitamente inicializadas com valores pelo programador e persistem durante a execução do programa.
2. Dados Não Inicializados (Seção BSS): Este segmento contém variáveis que são declaradas, mas não inicializadas explicitamente pelo programador. O sistema as inicializa com valores padrão (geralmente zero) antes do início da execução do programa.

Heap

Esta é uma região de memória dinâmica usada para alocar memória durante a execução. É onde a aplicação pode solicitar memória para estruturas de dados, como arrays, listas encadeadas e objetos cujos tamanhos podem não ser conhecidos em tempo de compilação.

Gerenciar o heap de forma eficaz é crucial para evitar vazamentos de memória (quando a memória alocada não é liberada corretamente) e fragmentação do heap (quando a memória é alocada de maneira ineficiente devido a alocações e desalocações repetidas).

Aqui está uma visão simplificada do layout de um processo na memória:

Layout de Processo na Memória

A pilha cresce para baixo (de endereços de memória mais altos para endereços mais baixos), e o heap cresce para cima, o que ajuda a maximizar o uso da memória disponível.

Exemplo do Mundo Real

Vamos pegar um exemplo simples em Python:

import os

# Variável global (Armazenada no Segmento de Dados Inicializados)
message = "Olá, mundo"
def imprimir_mensagem():
    # Variável local (Armazenada na Pilha)
    local_var = "Olá a partir da função imprimir_mensagem"
    print(local_var)
# Variável alocada dinamicamente (Armazenada no Heap)
heap_var = os.popen('echo Olá a partir do heap').read()
print(message)
imprimir_mensagem()
print(heap_var)

Neste script Python:

• A variável message é uma variável global e é armazenada no Segmento de Dados Inicializados.
• A função imprimir_mensagem inclui uma variável local local_var que é armazenada na Pilha.
• A variável heap_var é criada em tempo de execução com o comando os.popen (executando um comando shell e capturando a saída). Essa alocação dinâmica seria armazenada no Heap.
• O código real do programa Python (definições de função, declarações de importação, instruções de impressão, etc.) é armazenado no Segmento de Código.

Comando pmap

Você pode usar o comando pmap no Linux para exibir o mapa de memória de um processo, incluindo segmento de código, pilha, heap e bibliotecas que o processo está usando.

$ sudo pmap 32009
32009:   python3.10 test.py
0000000000400000   3320K r-x-- python3.10
000000000093d000      4K r---- python3.10
000000000093e000    204K rw--- python3.10
0000000000971000     24K rw---   [ anon ]
000000000266f000   1752K rw---   [ anon ]
00007f2dd32ae000     60K r-x-- math.cpython-310-x86_64-linux-gnu.so
00007f2dd32bd000   2044K ----- math.cpython-310-x86_64-linux-gnu.so
00007f2dd34bc000      4K r---- math.cpython-310-x86_64-linux-gnu.so
...
00007ffe7f3ff000    132K rw---   [ pilha ]
00007ffe7f5dd000     16K r----   [ anon ]
00007ffe7f5e1000      8K r-x--   [ anon ]
ffffffffff600000      4K r-x--   [ anon ]
 total           143272K

Aqui está uma breve descrição da saída:

• O espaço de endereço é dividido em blocos, cada um com um endereço, tamanho, permissões e a imagem à qual está associado.
• Mapas [anon] são tipicamente espaço de heap e pilha.
• O mapa [stack] é a pilha principal da aplicação.
• A seção .text de um arquivo binário é o segmento de código e é mapeada como executável. É aqui que residem os procedimentos e funções compilados.

• As seções .data e .bss correspondem aos segmentos de dados inicializados e não inicializados do programa.
• Os arquivos .so são as bibliotecas dinamicamente vinculadas.
• O tamanho total.

Entender o gerenciamento de memória de processos em sistemas Linux é essencial para profissionais de DevOps, pois permite otimizar o uso de recursos e solucionar problemas relacionados à memória de maneira eficaz. Isso é fundamental para garantir a estabilidade e o desempenho das aplicações e serviços implantados em ambientes Linux.