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

> Page détaillant le profilage des allocations dans ClickHouse

# Profilage des allocations pour les versions antérieures à 25.9

ClickHouse utilise [jemalloc](https://github.com/jemalloc/jemalloc) comme allocateur global. Jemalloc est livré avec des outils d’échantillonnage et de profilage des allocations.
Pour faciliter le profilage des allocations, des commandes `SYSTEM` sont disponibles, ainsi que des commandes à quatre lettres (4LW) dans Keeper.

<div id="sampling-allocations-and-flushing-heap-profiles">
  ## Échantillonnage des allocations et écriture des profils du tas
</div>

Si vous souhaitez échantillonner les allocations et en établir le profil dans `jemalloc`, vous devez démarrer ClickHouse/Keeper avec le profilage activé à l'aide de la variable d'environnement `MALLOC_CONF` :

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

`jemalloc` effectuera un échantillonnage des allocations et stockera les informations en interne.

Vous pouvez demander à `jemalloc` de vider le profile actuel en exécutant :

<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>

Par défaut, le fichier de profil de tas sera généré dans `/tmp/jemalloc_clickhouse._pid_._seqnum_.heap`, où `_pid_` est le PID de ClickHouse et `_seqnum_` le numéro de séquence global du profil de tas actuel.
Pour Keeper, le fichier par défaut est `/tmp/jemalloc_keeper._pid_._seqnum_.heap` et suit les mêmes règles.

Un autre emplacement peut être défini en ajoutant l'option `prof_prefix` à la variable d'environnement `MALLOC_CONF`.
Par exemple, si vous souhaitez générer des profiles dans le dossier `/data`, avec `my_current_profile` comme préfixe du nom de fichier, vous pouvez exécuter ClickHouse/Keeper avec la variable d'environnement suivante :

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

Le fichier généré sera ajouté à la suite du préfixe PID et du numéro de séquence.

<div id="analyzing-heap-profiles">
  ## Analyse des profils de tas
</div>

Une fois les profils de tas générés, ils doivent être analysés.
Pour cela, vous pouvez utiliser l’outil de `jemalloc` appelé [jeprof](https://github.com/jemalloc/jemalloc/blob/dev/bin/jeprof.in). Il peut être installé de plusieurs façons :

* À l’aide du gestionnaire de paquets du système
* En clonant le [dépôt jemalloc](https://github.com/jemalloc/jemalloc) et en exécutant `autogen.sh` depuis le dossier racine. Cela fournit le script `jeprof` dans le dossier `bin`

<Note>
  `jeprof` utilise `addr2line` pour générer des traces de pile, ce qui peut être très lent.
  Si c’est le cas, il est recommandé d’installer une [implémentation alternative](https://github.com/gimli-rs/addr2line) de cet outil.

  ```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>

`jeprof` permet de générer de nombreux formats différents à partir d’un profil de tas.
Il est recommandé d’exécuter `jeprof --help` pour obtenir des informations sur son utilisation et sur les différentes options proposées par l’outil.

De manière générale, la commande `jeprof` s’utilise comme suit :

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

Si vous voulez comparer les allocations survenues entre deux profils, vous pouvez définir l’argument `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">
  ### Exemples
</div>

* si vous voulez générer un fichier texte avec une procédure par ligne :

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

* si vous souhaitez générer un fichier PDF avec un graphe des appels :

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

<div id="generating-flame-graph">
  ### Génération d'un flame graph
</div>

`jeprof` permet de générer des piles d'appels compactées pour créer des flame graphs.

Vous devez utiliser l'argument `--collapsed` :

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

Après cela, vous pouvez utiliser de nombreux outils pour visualiser les piles d’appels compactées.

Le plus populaire est [FlameGraph](https://github.com/brendangregg/FlameGraph), qui contient un script appelé `flamegraph.pl` :

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

Un autre outil intéressant est [speedscope](https://www.speedscope.app/), qui vous permet d’analyser les stacks collectées de manière plus interactive.

<div id="controlling-allocation-profiler-during-runtime">
  ## Contrôler le profileur d’allocation à l’exécution
</div>

Si ClickHouse/Keeper est démarré avec le profileur activé, des commandes supplémentaires permettant d’activer ou de désactiver le profilage des allocations à l’exécution sont disponibles.
L’utilisation de ces commandes facilite le profilage sur des intervalles spécifiques uniquement.

Pour désactiver le profileur :

<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>

Pour activer le profileur :

<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>

Il est également possible de contrôler l’état initial du profileur en définissant l’option `prof_active`, activée par défaut.
Par exemple, si vous ne souhaitez pas échantillonner les allocations au démarrage, mais seulement ensuite, vous pouvez activer le profileur. Vous pouvez démarrer ClickHouse/Keeper avec la variable d’environnement suivante :

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

Le profileur peut être activé plus tard.

<div id="additional-options-for-profiler">
  ## Options supplémentaires pour le profileur
</div>

`jemalloc` propose de nombreuses options liées au profileur. Elles peuvent être configurées en modifiant la variable d'environnement `MALLOC_CONF`.
Par exemple, l'intervalle entre les échantillons d'allocation peut être réglé avec `lg_prof_sample`.
Si vous souhaitez générer un dump du profil de tas tous les N octets, vous pouvez l'activer avec `lg_prof_interval`.

Il est recommandé de consulter la [page de référence](https://jemalloc.net/jemalloc.3.html) de `jemalloc` pour obtenir la liste complète des options.

<div id="other-resources">
  ## Autres ressources
</div>

ClickHouse/Keeper exposent des métriques liées à `jemalloc` de différentes manières.

<Warning>
  **Avertissement**

  Il est important de noter qu'aucune de ces métriques n'est synchronisée avec les autres et que leurs valeurs peuvent varier.
</Warning>

<div id="system-table-asynchronous_metrics">
  ### Table système `asynchronous_metrics`
</div>

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

[Référence](/fr/reference/system-tables/asynchronous_metrics)

<div id="system-table-jemalloc_bins">
  ### Table système `jemalloc_bins`
</div>

Contient des informations sur les allocations mémoire effectuées par l’allocateur jemalloc dans différentes classes de taille (bins), agrégées depuis l’ensemble des arenas.

[Référence](/fr/reference/system-tables/jemalloc_bins)

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

Toutes les métriques liées à `jemalloc` provenant de `asynchronous_metrics` sont également exposées via le endpoint Prometheus dans ClickHouse et Keeper.

[Référence](/fr/reference/settings/server-settings/settings#prometheus)

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

Keeper prend en charge la commande 4LW `jmst`, qui renvoie les [statistiques de base de l’allocateur](https://github.com/jemalloc/jemalloc/wiki/Use-Case%3A-Basic-Allocator-Statistics) :

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