---
title: Optimisations Générales du Système
description: Choses que vous pouvez faire pour optimiser après l'installation
tableOfContents:
  minHeadingLevel: 1
  maxHeadingLevel: 4
---

import { Tabs, TabItem, Steps } from '@astrojs/starlight/components';
import ImageComponent from '~/components/image-component.astro';

## Optimisations de performance AMD

### Pilote AMD P-State
---------------------------

`amd-pstate` est le pilote de mise à l'échelle des performances des processeurs AMD qui introduit un nouveau mécanisme de contrôle de la fréquence du processeur dans le noyau Linux pour les séries de CPU et d'APU AMD modernes. Le nouveau mécanisme est basé sur le Contrôle Collaboratif des Performances du Processeur (CPPC), qui offre une gestion de fréquence plus fine que les P-States matériels ACPI hérités.

Les plateformes CPU/APU AMD actuelles utilisent le pilote ACPI P-states pour gérer la fréquence et les horloges du processeur avec une commutation limitée à 3 P-states. Le CPPC remplace les contrôles ACPI P-states et permet une interface flexible et à faible latence pour que le noyau Linux puisse communiquer directement les indications de performance au matériel.

Voici 3 modes de fonctionnement du pilote `amd_pstate` et les entrées de ligne de commande du noyau pour les utiliser au démarrage :

- AMD P-State (Mode non autonome) : `amd_pstate=passive`
- AMD P-State Guidé (Mode autonome guidé) : `amd_pstate=guided`
- AMD P-State EPP (Mode autonome) : `amd_pstate=active`

:::note
Le pilote AMD P-State EPP est utilisé par défaut lorsqu'aucune configuration explicite n'est effectuée.
:::

Vous pouvez également basculer entre les modes de fonctionnement à l'exécution pour tester les options :

- **Mode autonome** : la plateforme ne prend en compte que les valeurs définies pour la performance minimale, la performance maximale et la préférence de performance énergétique.
   ```sh
   echo active | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

- **Mode autonome guidé** : la plateforme définit le niveau de performance de fonctionnement en fonction de la charge de travail actuelle et dans les limites fixées par le système d'exploitation via les registres de performance minimale et maximale.
   ```sh
   echo guided | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

- **Mode non autonome** : la plateforme obtient le niveau de performance souhaité directement depuis le système d'exploitation via le registre de performance souhaitée.
   ```sh
   echo passive | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

Pour plus d'informations :

*   [https://www.kernel.org/doc/html/v6.9/admin-guide/pm/amd-pstate.html](https://www.kernel.org/doc/html/v6.9/admin-guide/pm/amd-pstate.html)
*   [https://lore.kernel.org/lkml/20221110175847.3098728-1-Perry.Yuan@amd.com/](https://lore.kernel.org/lkml/20221110175847.3098728-1-Perry.Yuan@amd.com/)
*   [https://lore.kernel.org/lkml/20230119115017.10188-1-wyes.karny@amd.com/](https://lore.kernel.org/lkml/20230119115017.10188-1-wyes.karny@amd.com/)

### Configuration d'AMD P-State EPP


Pour utiliser le P-State EPP, deux gouverneurs de mise à l'échelle de la fréquence du processeur sont disponibles : `powersave` et `performance`. Il est recommandé d'utiliser le gouverneur powersave et de définir une préférence.

*   Définir le gouverneur powersave : `sudo cpupower frequency-set -g powersave`
*   Définir le gouverneur performance : `sudo cpupower frequency-set -g performance`

Pour définir une préférence, exécutez la commande suivante avec la préférence souhaitée :

```sh
echo power | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/energy_performance_preference
```

Préférences disponibles : `performance`, `power`, `balance_power`, `balance_performance`

Des benchmarks pour chaque préférence peuvent être trouvés ici :
[https://lore.kernel.org/lkml/20221219064042.661122-1-perry.yuan@amd.com/](https://lore.kernel.org/lkml/20221219064042.661122-1-perry.yuan@amd.com/)

### Optimiseur AMD 3D V-Cache

AMD a publié un patch pour optimiser la planification du cache sur les processeurs 3D à double CCD, comme les 7950X3D et 7900X3D.
Vous devez définir dans le BIOS, sous l'option CPPC, l'option "Driver". Cela permettra de surcharger le mode utilisé avec sysfs.

Il existe deux modes :
1. Frequency (Fréquence)
2. Cache

Si `cache` est défini, le pilote essaiera de placer les tâches en premier sur le CCD avec le cache le plus élevé, ce qui est principalement avantageux pour les jeux.
L'option `frequency` essaiera de placer les tâches sur le second CCD, qui a une fréquence plus élevée que le CCD avec 3D Cache.

Fréquence (par défaut) :
```sh
echo frequency | sudo tee /sys/bus/platform/drivers/amd_x3d_vcache/AMDI0101:00/amd_x3d_mode
```

Cache :
```sh
echo cache | sudo tee /sys/bus/platform/drivers/amd_x3d_vcache/AMDI0101:00/amd_x3d_mode
```

Après avoir changé les modes, les statistiques de cœurs préférés AMD devraient fournir un classement différent. Vous pouvez le lire avec :
```sh
grep -v /sys/devices/system/cpu/cpu*/cpufreq/amd_pstate_prefcore_ranking
```

### AMD P-State Core Performance Boost

AMD Core Performance Boost, alias AMD Turbo Core, est une technologie de mise à l'échelle dynamique de la fréquence par AMD qui permet au
processeur d'ajuster et de contrôler dynamiquement la fréquence de fonctionnement du processeur dans certaines versions de ses processeurs,
ce qui permet d'augmenter les performances en cas de besoin tout en maintenant des paramètres de puissance et thermiques plus bas en fonctionnement normal.

Depuis `linux-cachyos` 6.9.6, le noyau est patché avec le support du CPB pour les pilotes p-state d'AMD (inclut `passive`, `active` et `guided`).
Les utilisateurs peuvent changer l'état de boost de chaque CPU via le fichier de boost sysfs `/sys/devices/system/cpu/cpuX/cpufreq/boost`
(X correspond au numéro du cœur, ex: cpu0 est le premier cœur, cpu1 le second, etc).

```sh
❯ echo 0 | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/boost # Désactive le boost pour tous les cœurs
❯ lscpu -ae # Ceci montre que le CPB d'AMD est désactivé globalement
CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE    MAXMHZ   MINMHZ       MHZ
  0    0      0    0 0:0:0:0          yes 3301.0000 400.0000 1212.8250
  1    0      0    0 0:0:0:0          yes 3301.0000 400.0000 1394.2180
  2    0      0    1 1:1:1:0          yes 3301.0000 400.0000 1204.4600

❯ echo 1 | sudo tee /sys/devices/system/cpu/cpu0/cpufreq/boost # Active le boost sur cpu0
❯ lscpu -ae
CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE    MAXMHZ   MINMHZ       MHZ
  0    0      0    0 0:0:0:0          yes 4564.0000 400.0000 1393.2380
  1    0      0    0 0:0:0:0          yes 3301.0000 400.0000  400.0000
  2    0      0    1 1:1:1:0          yes 3301.0000 400.0000 2157.8469
```

CachyOS fournit également une version de `power-profiles-daemon` qui rétroporte un commit activant
le support pour le CPB d'AMD. Le CPB d'AMD sera désactivé si le profil `powersave` est utilisé, et sera activé avec `balanced` ou `performance`.

Pour plus d'informations, voir :
- https://lore.kernel.org/linux-pm/1a78eeaa-fadd-4734-aaeb-2fe11e96e198@amd.com/T/#m4a0c8917ea8fb033504055bd61512c80c85410c8
- https://lore.kernel.org/linux-pm/20240624213400.67773-1-mario.limonciello@amd.com/

## Améliorations de performance

### [Ordonnanceur d'E/S ADIOS](https://github.com/firelzrd/adios)

Créé par [firelzrd](https://github.com/firelzrd)

:::note
CachyOS inclut la branche stable d'ADIOS dans le noyau.

Version actuelle dans **linux-cachyos** : `3.1.7`

Version actuelle dans **linux-cachyos-rc** : `3.1.7`
:::

Brève introduction du README :

- *ADIOS (Adaptive Deadline I/O Scheduler) est un ordonnanceur d'E/S de la couche bloc pour le noyau Linux, conçu pour les périphériques de bloc modernes à files d'attente multiples (blk-mq). Il vise à fournir une faible latence pour les opérations d'E/S en combinant les principes de l'ordonnancement par échéance avec un mécanisme de contrôle de latence adaptatif basé sur l'apprentissage.*
  - *Inspiré par et s'appuyant sur les concepts des ordonnanceurs d'E/S mq-deadline et Kyber. Sa caractéristique principale est la capacité de prédire la latence d'achèvement des E/S en se basant sur les performances passées et les caractéristiques des requêtes (type d'opération, taille) et d'utiliser cette prédiction pour ajuster dynamiquement les échéances des requêtes et le comportement de traitement par lots.*

TLDR : ADIOS fonctionne en apprenant le profil de latence de votre périphérique de stockage et en utilisant cette connaissance pour définir dynamiquement des échéances pour les requêtes d'E/S. Il priorise les requêtes en quatre niveaux, des opérations système critiques (Niveau 0) aux tâches de fond (Niveau 3), pour garantir une expérience utilisateur fluide. Bien qu'il se concentre sur la réactivité, son comportement peut être affiné via les paramètres sysfs pour équilibrer la latence et le débit.

Pour une démonstration en direct, vous pouvez regarder cette [vidéo](https://www.youtube.com/watch?v=L9WDcEeHgy4)

#### Comment activer ADIOS

<Tabs>
    <TabItem label='Temporairement (prend effet à l’exécution)'>
        Cette méthode définit l'ordonnanceur pour la session actuelle. Le changement sera perdu au redémarrage.
        ```sh
        sync && echo adios | sudo tee /sys/block/<votredisque>/queue/scheduler
            # Remplacez <votredisque> par l'identifiant réel du disque (ex. sda, sdb, nvme0n1)
        ```
    </TabItem>
    <TabItem label='Persistant après redémarrage'>
        <Steps>
            1. Ouvrez ou créez un nouveau fichier de règles udev dans votre éditeur de texte préféré (ex., nano, micro, vim)
                ```sh title='Exemple'
                sudo nano /etc/udev/rules.d/60-ioschedulers.rules
                ```
            2. Ajoutez les règles suivantes au fichier. Ces règles appliquent automatiquement un ordonnanceur d'E/S spécifique en fonction du type de disque (HDD, SSD ou NVMe).
                ```text
                # HDD
                ACTION=="add|change", KERNEL=="sd[a-z]*", ATTR{queue/rotational}=="1", \
                    ATTR{queue/scheduler}="bfq"

                # SSD
                ACTION=="add|change", KERNEL=="sd[a-z]*|mmcblk[0-9]*", ATTR{queue/rotational}=="0", \
                    ATTR{queue/scheduler}="adios"

                # NVMe SSD
                ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/rotational}=="0", \
                    ATTR{queue/scheduler}="adios"
                ```
              3.  Enregistrez le fichier et fermez l'éditeur.
              4.  Rechargez les règles `udev` pour appliquer les changements immédiatement sans redémarrage.
                  ```sh
                  sudo udevadm control --reload-rules
                  sudo udevadm trigger
                  ```
        </Steps>
    </TabItem>
</Tabs>

FAQ :

- S'il améliore la réactivité, pourquoi n'est-il pas activé par défaut ?
  - ADIOS est encore en développement actif et en test continu. Bien qu'il offre des avantages significatifs pour la réactivité du bureau, il n'est pas encore considéré comme suffisamment stable pour être la valeur par défaut pour toutes les charges de travail et tous les types de matériel. Dans certains cas limites, des bogues pourraient entraîner des problèmes comme des blocages du système. Pour cette raison, c'est une fonctionnalité optionnelle pour les utilisateurs qui souhaitent tester et bénéficier de ses dernières améliorations.

### NVIDIA Smooth Motion (Séries RTX 40xx & 50xx)

:::note[Compatibilité des jeux.]
Les jeux qui tournent sur DX11, DX12 et Vulkan.

DXVK et VKD3D fonctionnent tous deux correctement.

**Seules les applications 64 bits sont prises en charge. Smooth Motion ne fonctionnera pas avec les applications 32 bits (par ex. les anciens jeux DX11).**

:::

Citation directe de la documentation de NVIDIA :

*NVIDIA Smooth Motion est un nouveau modèle d'IA basé sur le pilote qui offre une expérience de jeu plus fluide en déduisant une image supplémentaire entre deux images rendues. Pour les jeux sans DLSS Frame Generation, NVIDIA Smooth Motion est une nouvelle option pour améliorer votre expérience sur les GPU GeForce RTX Série 40 et plus récents.*

- Comment activer NVIDIA Smooth Motion pour un jeu :
  - Ajoutez la variable d'environnement suivante :
    ```text
    NVPRESENT_ENABLE_SMOOTH_MOTION=1
    ```

FAQ :

- Pourquoi utiliser Smooth Motion plutôt que le DLSS Frame Generation ?
  - Lorsqu'un jeu ne prend pas en charge le DLSS Frame Generation, Smooth Motion sert d'alternative grâce à son modèle d'IA basé sur le pilote.
- Y a-t-il un inconvénient à utiliser Smooth Motion ?
  - Oui, l'activation de Smooth Motion peut introduire une légère latence d'entrée (input lag) en raison du processus de déduction d'images supplémentaires.
  - Peut causer des problèmes avec les superpositions (overlays) tierces. Pour éviter cela, incluez la variable d'environnement suivante :
    ```text
    NVPRESENT_QUEUE_FAMILY=1
    ```
    :::note[Un impact sur les performances peut être observé lors de l'utilisation de cette variable.]
    :::
- Pourquoi MangoHud n'affiche-t-il pas l'augmentation du nombre d'images par seconde ?
  - Actuellement, MangoHud ne prend pas en compte les images supplémentaires générées par Smooth Motion, ce qui conduit à un affichage trompeur du nombre d'images par seconde.
    - L'utilisation du compteur de FPS intégré à un moniteur fournira le nombre correct d'images par seconde.
- Quelle est la qualité d'image par rapport au DLSS Frame Generation ?
  - La qualité d'image n'est pas aussi bonne et peut introduire des artéfacts, en particulier lors des scènes de mouvement rapide.
- Est-ce compatible avec les outils externes de limitation d'images par seconde ? Exemple : MangoHud.
  - Non. La limitation intégrée au jeu devrait fonctionner correctement.
- Peut-on combiner Smooth Motion avec le DLSS Frame Generation ?
  - Non. Une seule méthode de génération d'images peut être active à la fois.

## Optimisations d'économie d'énergie

### Activer RCU Lazy

RCU Lazy aide à réduire la consommation d'énergie sur les systèmes au repos ou peu chargés. Cela peut être utile pour les ordinateurs portables et les appareils portables.
L'amélioration est de 5 à 10 % en termes d'économie d'énergie. Cependant, il est important de noter que cette fonctionnalité d'économie d'énergie peut se faire au détriment d'une performance légèrement réduite selon le scénario.
Le noyau linux-cachyos-deckify aura cette option activée par défaut, car l'économie d'énergie est essentielle et nécessaire pour ces appareils.

Pour activer RCU Lazy, ajoutez le paramètre suivant à votre liste de paramètres de [ligne de commande](/fr/configuration/boot_manager_configuration/) du noyau :
```text
rcutree.enable_rcu_lazy=1
```

## Dépannage NVIDIA

### Désactivation du backend Wayland de SDDM

:::note
À partir de cachyos-kde-settings 4.3, SDDM utilise KWin comme compositeur Wayland par défaut.
:::

Bien que ce soit un beau pas en avant, cela peut introduire quelques désagréments tels que la rupture du support pour l'overclocking via nvidia-settings ou causer une incompatibilité avec les GPU plus anciens qui ont du mal sous Wayland.

Afin d'annuler ce changement. Supprimez le paquet cachyos-kde-settings :
```sh
sudo pacman -R cachyos-kde-settings
```

### Firmware GSP de NVIDIA

Le firmware GSP de NVIDIA peut **"dans certains cas"** entraîner une diminution des performances. Bien que le pilote NVIDIA 555.58.02 ait largement résolu ce problème, il peut persister sur certains systèmes.
Si vous rencontrez des saccades dans KDE ou de mauvaises performances dans certains cas, vous pouvez désactiver le firmware GSP avec le fichier de configuration suivant :
`/etc/modprobe.d/nvidia-gsp.conf`

```text
options nvidia NVreg_EnableGpuFirmware=0
```

Après avoir créé le fichier, exécutez la commande suivante :
```sh
sudo mkinitcpio -P
```

:::note
Les [modules de noyau open source](https://github.com/NVIDIA/open-gpu-kernel-modules) de NVIDIA sont basés sur le firmware GSP. Pour cette raison, le GSP ne peut pas être désactivé et cette option modprobe sera ignorée lors de leur utilisation. Utilisez `linux-cachyos-nvidia` ou `nvidia-dkms`.
:::

Il est généralement recommandé de tester le firmware GSP après chaque nouvelle installation de pilote NVIDIA, car il introduit souvent des fonctionnalités bénéfiques. De plus, NVIDIA a principalement commencé à effectuer des tests d'assurance qualité en utilisant le firmware GSP.

## Améliorations audio et logicielles

### Améliorer le son des haut-parleurs d'ordinateur portable

Les haut-parleurs d'ordinateurs portables produisent souvent un son faible et décevant en raison de leur taille compacte et de leurs capacités matérielles limitées. [EasyEffects](https://wiki.archlinux.org/title/PipeWire#EasyEffects) peut améliorer considérablement la qualité sonore des haut-parleurs intégrés de votre ordinateur portable en appliquant divers effets audio et configurations personnalisées.

Pour commencer, vous devez installer EasyEffects et les dépendances requises :

```bash
# Installer EasyEffects
sudo pacman -S easyeffects
# Installer des plugins supplémentaires pour plus d'effets
sudo pacman -S lsp-plugins-lv2
sudo pacman -S zam-plugins
sudo pacman -S calf
sudo pacman -S mda.lv2
```

#### Configuration

Suivez ces étapes pour configurer EasyEffects :

1. Lancez EasyEffects depuis votre menu d'applications ou en tapant `easyeffects` dans le terminal.
2. Naviguez vers l'onglet **Output** (Sortie) pour gérer les effets appliqués à l'audio de vos haut-parleurs.
3. Basculez vers l'onglet **Effects** (Effets) pour ajouter, modifier ou ajuster les effets audio.

<ImageComponent imgsrc={import('~/assets/images/easyeffects.png')} />

##### Utilisation des préréglages de la communauté

Pour une configuration rapide et efficace, commencez avec les **préréglages créés par la communauté** adaptés à divers scénarios audio :

1. Téléchargez des préréglages depuis le dépôt [EasyEffects Community Presets](https://github.com/wwmm/easyeffects/wiki/Community-presets).
2. Dans EasyEffects, cliquez sur le bouton **Presets** (Préréglages) et choisissez **"Import preset from local storage"** (Importer un préréglage depuis le stockage local).
3. Localisez et sélectionnez le fichier de préréglage téléchargé.
4. Une fois importé, le préréglage apparaîtra dans votre liste — cliquez sur **"Load"** (Charger) pour l'appliquer à votre sortie audio.

<ImageComponent imgsrc={import('~/assets/images/easyeffects-presets.png')} />

##### Création d'un profil personnalisé

Pour une expérience audio plus personnalisée, créez un profil personnalisé adapté aux haut-parleurs de votre ordinateur portable :

1. Cliquez sur le bouton **"+"** dans le menu Presets pour créer un nouveau préréglage (par exemple, nommez-le **"Laptop Speakers"**).
2. Sélectionnez **"Load"** pour activer le nouveau préréglage.
3. Ajoutez et configurez des effets dans l'onglet **Output** > **Effects**, en expérimentant avec des options comme les égaliseurs, les amplificateurs de basses ou les élargisseurs stéréo.

##### Utilisation de l'effet Convolver (ordinateurs portables Dolby Atmos)

L'effet **Convolver** peut améliorer considérablement le son en appliquant des réponses impulsionnelles qui simulent des environnements audio de haute qualité. Cependant, il nécessite une configuration précise :

1. Ajoutez l'effet **Convolver** à votre chaîne d'effets dans l'onglet **Effects**.
2. Chargez un fichier de réponse impulsionnelle (au format `.wav`) spécifique à votre modèle d'ordinateur portable, si disponible. Vous pouvez rechercher ces fichiers en ligne sur des ressources comme :
   - https://wiki.archlinux.org/title/Lenovo_ThinkPad_T14_(AMD)_Gen_4#Speakers
   - https://github.com/m4tx/thinkpad-p14s-g4-linux/#sound
   - https://github.com/shuhaowu/linux-thinkpad-speaker-improvements/
3. **Prévenir l'écrêtage (clipping)** : L'effet Convolver peut augmenter considérablement le volume. Ajoutez un effet **Limiter** (Limiteur) après le Convolver dans votre chaîne d'effets pour contrôler les pics et éviter la distorsion.

<ImageComponent imgsrc={import('~/assets/images/easyeffects-convolver.png')} />

#### Conseils pour des résultats optimaux

- **Expérimentez** avec différents préréglages pour identifier celui qui correspond le mieux à votre modèle d'ordinateur portable et à vos préférences sonores personnelles.
- **Faites des ajustements incrémentiels** aux effets individuels pour éviter la distorsion ou un son non naturel.
- **Comparez en activant/désactivant** : Activez et désactivez fréquemment EasyEffects pour évaluer les améliorations par rapport à l'audio par défaut.
- Recherchez des **préréglages spécifiques à l'appareil ou des réponses impulsionnelles Convolver** pour des modèles d'ordinateurs portables populaires comme le **Framework Laptop 13** ou le **ThinkPad T14** pour obtenir des résultats sur mesure.
- **Automatiser le démarrage** : Configurez EasyEffects pour qu'il se lance automatiquement au démarrage via les préférences de l'application pour vous assurer que votre profil personnalisé est toujours appliqué.
- **Chargement automatique des préréglages pour plusieurs appareils** : Utilisez l'onglet **PipeWire** > **Presets Autoloading** pour associer des préréglages spécifiques à différents périphériques de sortie (par exemple, Haut-parleurs vs Casque) pour une commutation transparente. <ImageComponent imgsrc={import('~/assets/images/easyeffects-autoloading.png')} />

#### Alternative à EasyEffects

Comme alternative, vous pouvez essayer d'utiliser [JDSP4Linux](https://github.com/Audio4Linux/JDSP4Linux), qui est un processeur d'effets audio pour les clients PipeWire et PulseAudio.

### OBS Studio

Nous fournissons un paquet personnalisé obs-studio-browser dans notre dépôt qui est recommandé par rapport au paquet standard `obs-studio`. Il contient des correctifs pour résoudre certains des problèmes courants comme les erreurs cuda et les problèmes de caméra virtuelle.

```sh title='Ouvrez un terminal et exécutez la commande suivante'
sudo pacman -S obs-studio-browser
# Si vous aviez précédemment installé obs-studio, pacman vous demandera si
# vous voulez le remplacer, si c'est le cas, entrez "O".
```

## Configuration de la Swap

### Passer de ZRam à Zswap

Par défaut, CachyOS utilise ZRam pour la gestion de la swap. Cependant, si vous préférez utiliser Zswap, vous pouvez facilement changer en suivant ces étapes :

:::note
Ce guide suppose que vous avez la configuration par défaut de CachyOS avec ZRam activé et qu'aucune partition ou fichier d'échange (swap) n'a été créé lors de l'installation.
:::

<Steps>
    1. Désactivez ZRam en ajoutant un paramètre au noyau. [Modifiez la configuration de votre chargeur d'amorçage](/fr/configuration/boot_manager_configuration) et ajoutez la ligne suivante :
        ```text
        systemd.zram=0
        ```
    2. Créez un fichier de remplacement vide pour désactiver [la règle udev de CachyOS](https://github.com/CachyOS/CachyOS-Settings/blob/master/usr/lib/udev/rules.d/30-zram.rules) qui désactive Zswap :
        ```bash
        sudo touch /etc/udev/rules.d/30-zram.rules
        ```
    3. Activez Zswap en ajoutant le paramètre de noyau suivant :
        ```text
        zswap.enabled=1 zswap.shrinker_enabled=1 zswap.compressor=lz4 zswap.max_pool_percent=30
        ```
    4. Créez un fichier d'échange (swap) pour Zswap.
        <details>
            <summary>Si vous utilisez Btrfs :</summary>
                <Steps>
                    1. Créez un sous-volume Btrfs pour le fichier d'échange :
                        ```bash
                        sudo btrfs subvolume create /swap
                        ```
                    2. Créez un fichier d'échange avec la taille souhaitée (par ex., 8 Go) en modifiant le paramètre `--size` :
                        ```bash "--size"
                        sudo btrfs filesystem mkswapfile --size 4g --uuid clear /swap/swapfile
                        ```
                    3. Activez le fichier d'échange :
                        ```bash
                        sudo swapon /swap/swapfile
                        ```
                    4. Ajoutez le fichier d'échange à `/etc/fstab` pour le rendre persistant après les redémarrages :
                        ```bash
                        sudo echo "/swap/swapfile none swap defaults 0 0" >> /etc/fstab
                        ```
                </Steps>
        </details>
        <details>
            <summary>Si vous n'utilisez pas Btrfs :</summary>
            <Steps>
                1. Créez un fichier d'échange avec la taille souhaitée (par ex., 8 Go) en modifiant le paramètre `count=` :
                    ```bash "count=8"
                    sudo dd if=/dev/zero of=/swapfile bs=1G count=8
                    ```
                2. Définissez les permissions correctes pour le fichier d'échange :
                    ```bash
                    sudo chmod 0600 /swapfile
                    ```
                3. Formatez le fichier d'échange :
                    ```bash
                    sudo mkswap /swapfile
                    ```
                4. Ajoutez le fichier d'échange à `/etc/fstab` pour le rendre persistant après les redémarrages :
                    ```bash
                    sudo echo "/swapfile none swap defaults 0 0" >> /etc/fstab
                    ```
                5. Activez le fichier d'échange :
                    ```
                    sudo swapon /swapfile
                    ```
            </Steps>
        </details>
    5. Reconstruisez votre initramfs pour appliquer les changements. La commande varie en fonction de votre chargeur d'amorçage :
        <details>
            <summary>systemd-boot</summary>
            ```bash
            sudo sdboot-manage gen
            ```
        </details>
        <details>
            <summary>GRUB</summary>
            ```bash
            sudo grub-mkconfig -o /boot/grub/grub.cfg
            ```
        </details>
        <details>
            <summary>Limine</summary>
            ```bash
            sudo limine-mkinitcpio
            ```
        </details>
    6. Redémarrez votre système pour appliquer tous les changements.
</Steps>
