> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Página com detalhes sobre profiling de alocação no ClickHouse

# Profiling de alocação para versões anteriores à 25.9

O ClickHouse usa o [jemalloc](https://github.com/jemalloc/jemalloc) como alocador global. O jemalloc inclui algumas ferramentas para amostragem e profiling de alocação.
Para tornar o profiling de alocação mais prático, são fornecidos comandos `SYSTEM` junto com comandos de quatro letras (4LW) no Keeper.

<div id="sampling-allocations-and-flushing-heap-profiles">
  ## Amostragem de alocações e gravação de perfis de heap
</div>

Se você quiser fazer amostragem e profiling de alocações no `jemalloc`, precisará iniciar o ClickHouse/Keeper com o profiling ativado usando a variável de ambiente `MALLOC_CONF`:

```sh theme={null}
MALLOC_CONF=background_thread:true,prof:true,prof_active:true
```

`jemalloc` amostrará as alocações e armazenará as informações internamente.

Você pode instruir o `jemalloc` a gravar o perfil atual executando:

<Tabs>
  <Tab title="ClickHouse">
    ```sql theme={null}
    SYSTEM JEMALLOC FLUSH PROFILE
    ```
  </Tab>

  <Tab title="Keeper">
    ```sh theme={null}
    echo jmfp | nc localhost 9181
    ```
  </Tab>
</Tabs>

Por padrão, o arquivo de perfil de heap será gerado em `/tmp/jemalloc_clickhouse._pid_._seqnum_.heap`, em que `_pid_` é o PID do ClickHouse e `_seqnum_` é o número de sequência global do perfil de heap atual.
Para o Keeper, o arquivo padrão é `/tmp/jemalloc_keeper._pid_._seqnum_.heap` e segue as mesmas regras.

Um local diferente pode ser definido adicionando a opção `prof_prefix` à variável de ambiente `MALLOC_CONF`.
Por exemplo, se você quiser gerar perfis na pasta `/data`, em que o prefixo do nome do arquivo será `my_current_profile`, poderá executar o ClickHouse/Keeper com a seguinte variável de ambiente:

```sh theme={null}
MALLOC_CONF=background_thread:true,prof:true,prof_prefix:/data/my_current_profile
```

O arquivo gerado será acrescido do prefixo PID e do número de sequência.

<div id="analyzing-heap-profiles">
  ## Analisando perfis de heap
</div>

Depois que os perfis de heap forem gerados, eles precisam ser analisados.
Para isso, pode-se usar a ferramenta do `jemalloc` chamada [jeprof](https://github.com/jemalloc/jemalloc/blob/dev/bin/jeprof.in). Ela pode ser instalada de várias maneiras:

* Usando o gerenciador de pacotes do sistema
* Clonando o [repositório do jemalloc](https://github.com/jemalloc/jemalloc) e executando `autogen.sh` a partir da pasta raiz. Isso disponibilizará o script `jeprof` dentro da pasta `bin`

<Note>
  O `jeprof` usa `addr2line` para gerar stacktraces, o que pode ser bastante lento.
  Se esse for o caso, recomenda-se instalar uma [implementação alternativa](https://github.com/gimli-rs/addr2line) da ferramenta.

  ```bash theme={null}
  git clone https://github.com/gimli-rs/addr2line.git --depth=1 --branch=0.23.0
  cd addr2line
  cargo build --features bin --release
  cp ./target/release/addr2line path/to/current/addr2line
  ```
</Note>

Há vários formatos diferentes que podem ser gerados a partir do perfil de heap usando `jeprof`.
Recomenda-se executar `jeprof --help` para obter informações sobre o uso e as várias opções oferecidas pela ferramenta.

Em geral, o comando `jeprof` é usado da seguinte forma:

```sh theme={null}
jeprof path/to/binary path/to/heap/profile --output_format [ > output_file]
```

Se quiser comparar quais alocações ocorreram entre dois perfis, pode definir o argumento `base`:

```sh theme={null}
jeprof path/to/binary --base path/to/first/heap/profile path/to/second/heap/profile --output_format [ > output_file]
```

<div id="examples">
  ### Exemplos
</div>

* se você quiser gerar um arquivo de texto com cada procedimento escrito em uma linha:

```sh theme={null}
jeprof path/to/binary path/to/heap/profile --text > result.txt
```

* se você quiser gerar um arquivo PDF com um gráfico de chamadas:

```sh theme={null}
jeprof path/to/binary path/to/heap/profile --pdf > result.pdf
```

<div id="generating-flame-graph">
  ### Gerando um flame graph
</div>

`jeprof` permite gerar stacks colapsadas para criar flame graphs.

Você precisa usar o argumento `--collapsed`:

```sh theme={null}
jeprof path/to/binary path/to/heap/profile --collapsed > result.collapsed
```

Depois disso, você pode usar várias ferramentas para visualizar pilhas colapsadas.

A mais popular é [FlameGraph](https://github.com/brendangregg/FlameGraph), que contém um script chamado `flamegraph.pl`:

```sh theme={null}
cat result.collapsed | /path/to/FlameGraph/flamegraph.pl --color=mem --title="Allocation Flame Graph" --width 2400 > result.svg
```

Outra ferramenta interessante é o [speedscope](https://www.speedscope.app/), que permite analisar os stacks coletados de forma mais interativa.

<div id="controlling-allocation-profiler-during-runtime">
  ## Controlando o profiler de alocação em tempo de execução
</div>

Se o ClickHouse/Keeper for iniciado com o profiler habilitado, haverá suporte a comandos adicionais para desabilitar/habilitar o profiling de alocação em tempo de execução.
Usando esses comandos, fica mais fácil fazer profiling apenas em intervalos específicos.

Para desabilitar o profiler:

<Tabs>
  <Tab title="ClickHouse">
    ```sql theme={null}
    SYSTEM JEMALLOC DISABLE PROFILE
    ```
  </Tab>

  <Tab title="Keeper">
    ```sh theme={null}
    echo jmdp | nc localhost 9181
    ```
  </Tab>
</Tabs>

Para habilitar o profiler:

<Tabs>
  <Tab title="ClickHouse">
    ```sql theme={null}
    SYSTEM JEMALLOC ENABLE PROFILE
    ```
  </Tab>

  <Tab title="Keeper">
    ```sh theme={null}
    echo jmep | nc localhost 9181
    ```
  </Tab>
</Tabs>

Também é possível controlar o estado inicial do profiler definindo a opção `prof_active`, que vem habilitada por padrão.
Por exemplo, se você não quiser coletar amostras de alocação durante a inicialização, mas apenas depois, poderá habilitar o profiler. Você pode iniciar o ClickHouse/Keeper com a seguinte variável de ambiente:

```sh theme={null}
MALLOC_CONF=background_thread:true,prof:true,prof_active:false
```

O profiler pode ser ativado mais tarde.

<div id="additional-options-for-profiler">
  ## Opções adicionais para o profiler
</div>

O `jemalloc` oferece várias opções relacionadas ao profiler. Elas podem ser controladas modificando a variável de ambiente `MALLOC_CONF`.
Por exemplo, o intervalo entre as amostras de alocação pode ser controlado com `lg_prof_sample`.
Se quiser gerar o perfil de heap a cada N bytes, você pode habilitá-lo com `lg_prof_interval`.

Recomenda-se consultar a [página de referência](https://jemalloc.net/jemalloc.3.html) do `jemalloc` para obter a lista completa de opções.

<div id="other-resources">
  ## Outros recursos
</div>

ClickHouse/Keeper expõem métricas relacionadas ao `jemalloc` de várias formas.

<Warning>
  **Aviso**

  É importante ter em mente que nenhuma dessas métricas é sincronizada com as outras, e os valores podem variar.
</Warning>

<div id="system-table-asynchronous_metrics">
  ### Tabela do sistema `asynchronous_metrics`
</div>

```sql theme={null}
SELECT *
FROM system.asynchronous_metrics
WHERE metric LIKE '%jemalloc%'
FORMAT Vertical
```

[Referência](/pt-BR/reference/system-tables/asynchronous_metrics)

<div id="system-table-jemalloc_bins">
  ### Tabela do sistema `jemalloc_bins`
</div>

Contém informações sobre alocações de memória feitas pelo alocador jemalloc em diferentes classes de tamanho (bins), agregadas de todas as arenas.

[Referência](/pt-BR/reference/system-tables/jemalloc_bins)

<div id="prometheus">
  ### Prometheus
</div>

Todas as métricas relacionadas ao `jemalloc` de `asynchronous_metrics` também são expostas por meio do endpoint Prometheus, tanto no ClickHouse quanto no Keeper.

[Referência](/pt-BR/reference/settings/server-settings/settings#prometheus)

<div id="jmst-4lw-command-in-keeper">
  ### Comando 4LW `jmst` no Keeper
</div>

O Keeper é compatível com o comando 4LW `jmst`, que retorna [estatísticas básicas do alocador](https://github.com/jemalloc/jemalloc/wiki/Use-Case%3A-Basic-Allocator-Statistics):

```sh theme={null}
echo jmst | nc localhost 9181
```