- **Fedora** :  

- **Arch Linux** :  

Après l’installation, vérifiez que **perf** fonctionne en tapant la commande suivante :  

<h3>Compilation du programme C avec des symboles de débogage</h3>  
Pour que **perf** fournisse des informations détaillées sur les fonctions et les lignes de code, le programme C doit être compilé avec les symboles de débogage. Cela se fait en ajoutant l’option `-g` lors de la compilation. Exemple :  

<h3>Vérification des permissions</h3>  
L’utilisation de **perf** nécessite souvent des permissions administratives. Pour éviter les erreurs d’accès, vous pouvez exécuter les commandes avec `sudo` ou configurer votre utilisateur pour accéder à **perf** sans droits root :  

Pour rendre cette configuration persistante après redémarrage, ajoutez la ligne suivante au fichier `/etc/sysctl.conf` :  

<h3>Validation de l’environnement</h3>  
Avant de commencer l’analyse, lancez une commande simple pour vérifier que **perf** est correctement configuré :  

Cette commande fournit des statistiques de base sur l’exécution de la commande `ls`. Si aucune erreur n’apparaît, l’environnement est prêt.

Avec ces étapes, votre environnement Linux est préparé pour utiliser **perf** et analyser efficacement vos programmes C.
<h2>Exécution de perf sur un programme C</h2>  

Analyser un programme C avec **perf** nécessite de suivre une série d’étapes pour collecter des données sur ses performances. Cette section détaille les commandes essentielles pour utiliser **perf** et obtenir des résultats exploitables.

<h3>Étape 1 : Préparer le programme</h3>  
Assurez-vous que le programme C a été compilé avec les symboles de débogage (`-g`) et qu’il est prêt à être exécuté. Voici un exemple :  

<h3>Étape 2 : Utiliser perf stat</h3>  
La commande `perf stat` fournit une vue d’ensemble des performances globales de votre programme, incluant les cycles processeur, les instructions exécutées et les défauts de cache. Exemple :  

**Sortie typique :**  

  123456789 cycles
  234567890 instructions
   12345678 cache-misses

<h3>Étape 3 : Utiliser perf record</h3>  
Pour une analyse plus approfondie, utilisez la commande `perf record` qui enregistre les événements de performance pendant l’exécution du programme.  

Cela génère un fichier de sortie (par défaut `perf.data`) contenant les données d’analyse.

<h3>Étape 4 : Visualiser les données avec perf report</h3>  
Une fois les données collectées, utilisez la commande `perf report` pour visualiser les résultats dans une interface interactive :  

Vous verrez un rapport détaillé indiquant quelles fonctions consomment le plus de cycles processeur. Les résultats incluent des informations sur :  
- Les adresses des fonctions.  
- Le pourcentage du temps passé dans chaque fonction.  

<h3>Étape 5 : Analyser une fonction spécifique avec perf annotate</h3>  
Pour approfondir l’analyse, utilisez `perf annotate` afin d’examiner le code assembleur d’une fonction spécifique et comprendre son comportement. Exemple :  

Cette commande affiche les lignes de code assembleur, accompagnées des cycles processeur correspondants.

<h3>Étape 6 : Exécuter perf sur une section de code</h3>  
Si votre programme est complexe, vous pouvez cibler une section spécifique en utilisant des outils comme des marqueurs dans le code (par exemple, début et fin d’une boucle critique) et limiter l’analyse à cette portion.

<h3>Exemple complet</h3>  
Voici une exécution typique d’analyse :  
1. Compiler le programme :  

2. Enregistrer les performances :  

3. Visualiser les résultats :  

En suivant ces étapes, vous pouvez identifier et corriger les problèmes de performance dans votre programme C.
<h2>Analyse des résultats de perf</h2>  

Après avoir exécuté une commande comme `perf stat` ou `perf record`, l’étape cruciale est de lire et d’interpréter les résultats pour identifier les problèmes de performance et déterminer les optimisations possibles. Cette section explique comment analyser efficacement les données générées par **perf**.

<h3>Interprétation des résultats de perf stat</h3>  

La commande `perf stat` fournit une vue d’ensemble des métriques de performance clés. Voici un exemple de sortie :  

  123456789 cycles
  234567890 instructions
  12345678 cache-misses

- **Cycles** : Indique le nombre de cycles processeur utilisés par le programme. Un nombre élevé peut suggérer un problème d’efficacité ou une section de code particulièrement gourmande.  
- **Instructions** : Mesure le nombre d’instructions exécutées. Un ratio élevé entre cycles et instructions peut indiquer des instructions inefficaces ou des dépendances de données.  
- **Cache-misses** : Indique les défauts de cache. Un nombre élevé de défauts de cache suggère un problème lié à la localisation des données ou une mauvaise gestion de la mémoire.  

<h3>Analyse détaillée avec perf report</h3>  

La commande `perf report` génère un rapport interactif qui décompose les performances par fonction ou par ligne de code. Voici les principaux champs à examiner :  

- **Symboles (Functions)** : Affiche les noms des fonctions où le programme passe le plus de temps.  
- **% Time** : Indique le pourcentage de temps passé dans chaque fonction. Les fonctions avec une valeur élevée doivent être examinées en priorité.  
- **Callgraph** : Montre l’arborescence des appels pour comprendre le flux d’exécution et identifier les goulets d’étranglement.  

**Exemple d’analyse :**  
Si une fonction consomme 60 % du temps total, cela peut indiquer une opportunité d’optimisation. En examinant la logique ou les structures de données utilisées dans cette fonction, vous pourriez réduire sa complexité ou améliorer son efficacité.

<h3>Utilisation de perf annotate</h3>  

La commande `perf annotate` permet de zoomer sur une fonction spécifique et de visualiser le code assembleur associé aux événements de performance :  

**Points à examiner :**  
- Les instructions avec un nombre élevé de cycles.  
- Les instructions liées aux accès mémoire, comme `MOV`, qui peuvent indiquer des problèmes de cache.  

<h3>Détection des goulets d’étranglement</h3>  

Les goulets d’étranglement peuvent être identifiés en examinant les fonctions avec un pourcentage élevé de temps CPU ou un ratio élevé de cycles par instruction (CPI).  

- **CPI élevé** : Cela peut indiquer des problèmes tels que des latences mémoire.  
- **Cache-misses élevés** : Cela peut être causé par des structures de données mal dimensionnées ou une gestion inefficace de la mémoire.  

<h3>Exemple pratique</h3>  

Supposons que votre programme analyse de grands tableaux et que `perf report` indique que la fonction `calculate_sums` consomme 75 % du temps total avec un taux élevé de défauts de cache.  
1. Réorganisez les données pour qu’elles tiennent mieux dans le cache (ex. : tableau de structures).  
2. Réexécutez `perf stat` et `perf record` pour vérifier si les métriques s’améliorent.  

<h3>Résumé des actions</h3>  
- Identifier les fonctions critiques avec **perf report**.  
- Analyser le code assembleur avec **perf annotate**.  
- Réduire les défauts de cache en optimisant les structures de données.  
- Améliorer le ratio cycles/instructions en optimisant les algorithmes.  

Avec ces étapes, vous pouvez exploiter pleinement les résultats générés par **perf** pour rendre vos programmes C plus performants.
<h2>Résolution des problèmes fréquents</h2>  

Lors de l'utilisation de **perf**, divers problèmes peuvent survenir, notamment des erreurs liées aux permissions, des résultats incomplets ou des problèmes d’interprétation des données. Cette section vous guide pour diagnostiquer et résoudre les problèmes courants afin de maximiser l’efficacité de vos analyses.

<h3>Problème 1 : Erreur de permissions</h3>  
**Erreur fréquente :**  

**Cause :**  
L’utilisateur n’a pas les permissions nécessaires pour accéder aux compteurs matériels ou pour exécuter **perf**.

**Solution :**  
1. **Exécuter avec sudo :**  

2. **Réduire les restrictions avec kernel.perf_event_paranoid :**  
   Changez temporairement la valeur de `kernel.perf_event_paranoid` :  

   Pour rendre cette configuration permanente, ajoutez la ligne suivante dans `/etc/sysctl.conf` :  

<h3>Problème 2 : Résultats incomplets dans perf report</h3>  
**Erreur fréquente :** Certaines fonctions ou lignes de code ne s’affichent pas dans le rapport.  

**Cause :**  
Le programme n’a pas été compilé avec les symboles de débogage.  

**Solution :**  
Recompilez le programme avec l’option `-g` :  

Vérifiez également que le fichier exécutable généré est accessible au chemin attendu.

<h3>Problème 3 : Résultats inattendus ou biaisés</h3>  
**Cause :**  
Les résultats peuvent être biaisés si le programme est influencé par d’autres processus en cours d’exécution sur le système.  

**Solution :**  
1. Minimisez l’interférence en exécutant **perf** sur un système dédié ou en mode monoutilisateur.  
2. Utilisez `taskset` pour lier le programme à un processeur spécifique :  

<h3>Problème 4 : Fichier perf.data corrompu</h3>  
**Erreur fréquente :**  

**Cause :**  
Le fichier `perf.data` généré par `perf record` a été modifié ou corrompu.  

**Solution :**  
1. Supprimez le fichier corrompu :  

2. Relancez `perf record` pour générer un nouveau fichier.

<h3>Problème 5 : Résultats difficiles à interpréter</h3>  
**Cause :**  
Le volume des données peut rendre l’interprétation complexe, notamment avec de grands projets.  

**Solution :**  
1. **Filtrer les données :** Utilisez des options comme `--sort` pour trier les résultats :  

2. **Limiter l’analyse à une fonction spécifique :**  
   Ajoutez des symboles pour cibler une section précise du programme :  

<h3>Problème 6 : Perf non compatible avec le noyau</h3>  
**Erreur fréquente :**  

**Cause :**  
La version de **perf** installée n’est pas compatible avec votre noyau Linux.  

**Solution :**  
1. Mettez à jour votre noyau Linux.  

2. Téléchargez la version de **perf** correspondant à votre noyau via votre gestionnaire de paquets.

<h3>Résumé des solutions</h3>  
- Vérifiez les permissions d’accès avec `sudo` ou ajustez les paramètres du noyau.  
- Recompilez votre programme avec les symboles de débogage.  
- Filtrez et triez les données pour faciliter leur analyse.  
- Maintenez votre système à jour pour éviter les incompatibilités.  

Avec ces solutions, vous pouvez surmonter la plupart des obstacles courants lors de l'utilisation de **perf** et mener vos analyses sans accroc.
<h2>Exemples pratiques et exercices</h2>  

Pour maîtriser l’utilisation de **perf**, rien de mieux que de travailler sur des exemples concrets et de pratiquer avec des exercices ciblés. Cette section propose des scénarios d’analyse de performances et des exercices pour renforcer vos compétences.

<h3>Exemple 1 : Analyse des performances d’une boucle</h3>  

Considérez le programme suivant qui contient une boucle inefficace :  

for (int i = 0; i < n; i++) {  
    array[i] = i;  
}  

free(array);  
return 0;  

1. **Compilation avec des symboles de débogage** :  

2. **Analyse avec perf stat** :  

   Résultats attendus : nombre élevé de cycles processeur et de défauts de cache.

3. **Analyse approfondie avec perf record** :  

   Puis visualisez les résultats :  

   Identifiez si la boucle consomme une quantité disproportionnée de ressources.

**Exercice :**  
Modifiez la boucle pour réduire les défauts de cache en réorganisant les données ou en optimisant l’accès mémoire. Recompilez et répétez l’analyse avec **perf** pour observer les améliorations.

---

<h3>Exemple 2 : Analyse d’une fonction complexe</h3>  

Considérez un programme avec plusieurs fonctions :  

1. **Compilation avec symboles** :  

2. **Exécution avec perf record** :  

3. **Rapport avec perf report** :  

   Analysez quel pourcentage de temps est passé dans `fonction_critique()` et `fonction_secondaire()`.

**Exercice :**  
- Ajoutez une nouvelle fonction optimisée pour remplacer `fonction_critique`.  
- Comparez les performances avant et après modification.

---

<h3>Exemple 3 : Analyse des appels système</h3>  

Pour un programme effectuant des entrées/sorties :  

1. **Compilation** :  

2. **Analyse des appels système avec perf trace** :