rendu

.gitignore

@@ -0,0 +1,11 @@
+/analyseur
+/exemple
+/gmon.out
+/mesures/analyseur_avant
+/mesures/analyseur_avant_pg
+/mesures/analyseur_apres_pg
+/mesures/analyseur_etape_[1-5]
+/mesures/analyseur_sanitizers
+/mesures/gmon_*.out
+/mesures_reproduction/
+/__pycache__/

COMPTE_RENDU.md

@@ -0,0 +1,118 @@
+# Compte rendu — TD 1 : utilisation de gprof
+### Nathan COUCHOT et Lucas POT
+
+## 1. Mesurer le programme sans instrumentation
+
+La mesure sans profiler se réalise avec les commandes suivantes, depuis le dossier du programme :
+
+```bash
+gcc -O0 analyseur.c -o analyseur
+time ./analyseur
+```
+
+La nouvelle exécution sans `-pg`, sur le même volume de texte que le profil, donne :
+
+| Mesure | Temps |
+| --- | ---: |
+| Temps réel (`real`) | 1,200 s |
+| Temps CPU utilisateur (`user`) | 1,164 s |
+| Temps CPU système (`sys`) | 0,022 s |
+
+L'empreinte du rapport est **`03c7b78f93838d02`**. Cette empreinte sert de référence pour vérifier que le résultat reste identique lors d'une comparaison effectuée avec les mêmes données.
+
+Les dix mots les plus fréquents sont :
+
+| Rang | Mot | Occurrences |
+| --- | --- | ---: |
+| 1 | rane | 2 811 |
+| 2 | fasi | 2 399 |
+| 3 | mopo | 2 161 |
+| 4 | tata | 2 086 |
+| 5 | vesi | 1 979 |
+| 6 | laganomo | 1 784 |
+| 7 | boto | 1 697 |
+| 8 | nopebo | 1 653 |
+| 9 | cofi | 1 612 |
+| 10 | siri | 1 593 |
+
+## 2. Compiler avec `-pg` et produire le profil
+
+Pour activer l'instrumentation de `gprof`, on compile avec `-O0 -pg`, puis on exécute le programme et on génère le profil :
+
+```bash
+gcc -O0 -pg analyseur.c -o analyseur
+time ./analyseur
+gprof ./analyseur gmon.out > profil_avant.txt
+```
+
+On passe d'une mesure de **1,200 s sans `-pg`** à un temps réel relevé de **2,750 s avec `-pg`**, soit une durée environ **2,29 fois plus longue** et un écart de **1,550 s** (environ **129 %** d'augmentation). Le profil affiche cependant seulement **0,91 s de temps effectif estimé dans les fonctions analysées**.
+
+L'option `-pg` ajoute du travail à chaque entrée dans une fonction pour compter les appels. Avec des dizaines de millions d'appels à de petites fonctions, ce surcoût devient très important : le profiling perturbe donc fortement la durée d'exécution.
+
+## 3. Analyser le profil plat et le graphe d'appels
+
+### Profil plat : où passe le temps ?
+
+Le profil plat indique le temps propre de chaque fonction, sans le temps de ses fonctions appelées. Les principaux résultats de `profil_avant.txt` sont :
+
+| Fonction | Part du temps propre | Temps propre affiché | Nombre d'appels |
+| --- | ---: | ---: | ---: |
+| `egales` | 28,02 % | 0,26 s | 121 889 737 |
+| `est_mot_vide` | 13,74 % | 0,12 s | 2 500 000 |
+| `analyser_bigrammes` | 12,09 % | 0,11 s | 1 |
+| `decouper_lignes` | 7,69 % | 0,07 s | 1 |
+| `generer_texte` | 6,59 % | 0,06 s | 1 |
+| `est_lettre` | 5,49 % | 0,05 s | 52 929 320 |
+
+La fonction `egales` est le principal point chaud : elle compare des chaînes et représente environ 28 % du temps propre mesuré. Son coût vient surtout de son nombre d'appels, supérieur à 121 millions.
+
+`analyser_bigrammes`, `decouper_lignes` et `generer_texte` ne sont appelées qu'une fois, mais parcourent de grandes quantités de données. Elles peuvent donc consommer un temps significatif malgré leur faible nombre d'appels.
+
+### Graphe d'appels : pourquoi ces fonctions coûtent-elles du temps ?
+
+`main` appelle `compter_mots_ligne`, qui vérifie chaque mot avec `est_mot_vide` avant de le compter. Cette étape représente environ **51 % du temps du profil**, fonctions appelées comprises.
+
+Pour vérifier si un mot est vide, `est_mot_vide` le compare aux éléments d'une liste de 60 mots avec `egales`. Comme cette vérification est répétée pour les 2 500 000 mots du texte, elle entraîne plus de **120 millions de comparaisons** et représente environ **41 % du temps du profil**.
+
+Le principal coût vient donc de la vérification des mots vides.
+
+## 4. Proposer des améliorations
+
+Les pistes suivantes sont classées par gain attendu :
+
+1. **Optimiser `est_mot_vide`.** Regrouper les mots vides par longueur et première lettre éviterait de parcourir toute la liste et réduirait fortement les appels à `egales`.
+
+2. **Optimiser `longueur_moyenne`.** Mémoriser la longueur des mots et réutiliser la moyenne dans `ecart_type_longueur` éviterait des parcours inutiles. Le gain attendu est plus faible.
+
+## 5. Optimisations réalisées
+
+Dans `est_mot_vide`, les 60 mots vides sont regroupés une seule fois par longueur et première lettre. Pour chaque mot du texte, seules les chaînes du groupe correspondant sont comparées avec `egales`. La longueur est déjà connue lors du découpage du mot.
+
+La longueur de chaque mot compté est aussi mémorisée dans la table pour calculer les statistiques. La moyenne déjà calculée est transmise à `ecart_type_longueur` pour éviter de la recalculer.
+
+## 6. Vérifier les résultats et mesurer le gain
+
+Après compilation avec `gcc -O0 -pg analyseur.c -o analyseur`, deux exécutions donnent :
+
+| Mesure | Après : essai 1 | Après : essai 2 |
+| --- | ---: | ---: |
+| Temps réel | 1,200 s | 1,231 s |
+| Temps CPU utilisateur | 1,147 s | 1,183 s |
+| Temps CPU système | 0,016 s | 0,019 s |
+
+Le temps réel moyen avec `-pg` est de **1,216 s**, contre **2,750 s avant optimisation**, soit environ **55,8 % de temps en moins** et une exécution **2,26 fois plus rapide**. Cette comparaison concerne les versions instrumentées : elle inclut la réduction du surcoût de `-pg` grâce aux appels supprimés.
+
+La comparaison de `profil_avant.txt` et `profil_après.txt` confirme la réduction du travail :
+
+| Mesure du profil | Avant | Après |
+| --- | ---: | ---: |
+| Temps total estimé par `gprof` | 0,91 s | 0,45 s |
+| Appels à `egales` | 121 889 737 | 3 413 876 |
+| Temps propre de `egales` | 0,26 s | 0,02 s |
+| Temps propre de `est_mot_vide` | 0,12 s | 0,02 s |
+| Appels à `longueur` | 39 162 | 20 994 |
+| Appels à `longueur_moyenne` | 2 | 1 |
+
+Les appels à `egales` diminuent d'environ **97 %**. Les 60 appels à `longueur` ajoutés par l'initialisation des groupes expliquent le passage de 20 934 appels après la seule optimisation des statistiques à 20 994 dans la version finale.
+
+L'empreinte reste **`03c7b78f93838d02`** dans les deux exécutions. Le Top 10 et les statistiques affichées restent identiques.

analyseur.c

@@ -14,7 +14,7 @@
  * L'empreinte affichée à la fin doit rester IDENTIQUE après optimisation :
  * elle prouve que le résultat du programme n'a pas changé.
  *
- * Compilation :  gcc -O0 -g -pg analyseur.c -o analyseur
+ * Compilation :  gcc -O0 -pg analyseur.c -o analyseur
  * Exécution :    ./analyseur
  * Profil :       gprof ./analyseur gmon.out > profil.txt
  */
@@ -22,7 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#define NB_MOTS_TEXTE   250000
+#define NB_MOTS_TEXTE   2500000
 #define NB_MOTS_VOCAB   7000
 #define TAILLE_MOT      32
 #define MAX_MOTS_UNIQUES 20000
@@ -32,6 +32,7 @@
 /* Générateur pseudo-aléatoire (identique sur toutes les machines)          */
 /* ------------------------------------------------------------------------ */
 
+
 static unsigned long etat_alea = GRAINE;
 
 unsigned long alea(void)
@@ -209,7 +210,7 @@ char **decouper_lignes(const char *texte, int *nb_lignes)
 
 void normaliser_ligne(char *ligne)
 {
-    for (int i = 0; i < longueur(ligne); i++) {
+    for (int i = 0; ligne[i] != '\0'; i++) {
         if (est_lettre(ligne[i]))
             ligne[i] = en_minuscule(ligne[i]);
         else
@@ -224,34 +225,82 @@ void normaliser_ligne(char *ligne)
 typedef struct {
     char mot[TAILLE_MOT];
     int occurrences;
+    int longueur_mot;
 } Entree;
 
-int est_mot_vide(const char *mot)
+/* Groupes par longueur et première lettre ; indices + 1, zéro = fin. */
+int est_mot_vide(const char *mot, int taille)
 {
-    for (int i = 0; i < NB_MOTS_VIDES; i++) {
-        if (egales(mot, MOTS_VIDES[i]))
+    static int groupes[TAILLE_MOT][26];
+    static int suivants[NB_MOTS_VIDES];
+    static int initialise = 0;
+
+    if (!initialise) {
+        for (int i = 0; i < NB_MOTS_VIDES; i++) {
+            int n = longueur(MOTS_VIDES[i]);
+            int lettre = MOTS_VIDES[i][0] - 'a';
+            if (n > 0 && n < TAILLE_MOT && lettre >= 0 && lettre < 26) {
+                suivants[i] = groupes[n][lettre];
+                groupes[n][lettre] = i + 1;
+            }
+        }
+        initialise = 1;
+    }
+
+    if (taille <= 0 || taille >= TAILLE_MOT || mot[0] < 'a' || mot[0] > 'z')
+        return 0;
+    for (int indice = groupes[taille][mot[0] - 'a']; indice != 0;
+         indice = suivants[indice - 1]) {
+        if (egales(mot, MOTS_VIDES[indice - 1]))
             return 1;
     }
     return 0;
 }
 
-int chercher_mot(Entree *table, int nb_entrees, const char *mot)
+/* Indices + 1 : zéro représente une case libre. Charge < 31 %. */
+#define CAPACITE_INDEX 65536
+static int index_mots[CAPACITE_INDEX];
+
+unsigned long hacher_mot(const char *mot)
 {
-    for (int i = 0; i < nb_entrees; i++) {
-        if (egales(table[i].mot, mot))
-            return i;
+    unsigned long h = 5381;
+    for (int i = 0; mot[i] != '\0'; i++)
+        h = h * 33 + (unsigned char)mot[i];
+    return h;
+}
+
+int chercher_mot(Entree *table, const char *mot, unsigned long *case_libre)
+{
+    unsigned long position = hacher_mot(mot) % CAPACITE_INDEX;
+    while (index_mots[position] != 0) {
+        int indice = index_mots[position] - 1;
+        if (egales(table[indice].mot, mot))
+            return indice;
+        position = (position + 1) % CAPACITE_INDEX;
     }
+    *case_libre = position;
     return -1;
 }
 
-void compter_mot(Entree *table, int *nb_entrees, const char *mot)
+void compter_mot(Entree *table, int *nb_entrees, const char *mot, int longueur_mot)
 {
-    int indice = chercher_mot(table, *nb_entrees, mot);
+    /* Réinitialisation possible pour un nouveau comptage. */
+    if (*nb_entrees == 0)
+        for (int i = 0; i < CAPACITE_INDEX; i++)
+            index_mots[i] = 0;
+    unsigned long position;
+    int indice = chercher_mot(table, mot, &position);
     if (indice >= 0) {
         table[indice].occurrences++;
     } else {
+        if (*nb_entrees == MAX_MOTS_UNIQUES) {
+            fputs("Trop de mots distincts\n", stderr);
+            exit(EXIT_FAILURE);
+        }
         copier(table[*nb_entrees].mot, mot);
         table[*nb_entrees].occurrences = 1;
+        table[*nb_entrees].longueur_mot = longueur_mot;
+        index_mots[position] = *nb_entrees + 1;
         (*nb_entrees)++;
     }
 }
@@ -274,8 +323,8 @@ void compter_mots_ligne(Entree *table, int *nb_entrees, const char *ligne,
         mot[k] = '\0';
         if (k > 0) {
             (*nb_mots_total)++;
-            if (!est_mot_vide(mot))
-                compter_mot(table, nb_entrees, mot);
+            if (!est_mot_vide(mot, k))
+                compter_mot(table, nb_entrees, mot, k);
         }
     }
 }
@@ -291,17 +340,37 @@ int doit_echanger(const Entree *a, const Entree *b)
     return comparer(a->mot, b->mot) > 0;
 }
 
+/* Tri fusion : même ordre total, O(n log n), mémoire O(n). */
+void fusionner_entrees(Entree *table, Entree *tampon, int debut, int fin)
+{
+    if (fin - debut < 2)
+        return;
+    int milieu = debut + (fin - debut) / 2;
+    fusionner_entrees(table, tampon, debut, milieu);
+    fusionner_entrees(table, tampon, milieu, fin);
+    int gauche = debut, droite = milieu;
+    for (int k = debut; k < fin; k++) {
+        if (gauche < milieu && (droite == fin ||
+                !doit_echanger(&table[gauche], &table[droite])))
+            tampon[k] = table[gauche++];
+        else
+            tampon[k] = table[droite++];
+    }
+    for (int k = debut; k < fin; k++)
+        table[k] = tampon[k];
+}
+
 void trier_entrees(Entree *table, int n)
 {
-    for (int i = 0; i < n - 1; i++) {
-        for (int j = 0; j < n - 1 - i; j++) {
-            if (doit_echanger(&table[j], &table[j + 1])) {
-                Entree tmp = table[j];
-                table[j] = table[j + 1];
-                table[j + 1] = tmp;
-            }
-        }
+    if (n < 2)
+        return;
+    Entree *tampon = malloc((size_t)n * sizeof(*tampon));
+    if (tampon == NULL) {
+        perror("malloc tri");
+        exit(EXIT_FAILURE);
     }
+    fusionner_entrees(table, tampon, 0, n);
+    free(tampon);
 }
 
 /* ------------------------------------------------------------------------ */
@@ -312,15 +381,15 @@ double longueur_moyenne(const Entree *table, int n)
 {
     long total = 0;
     for (int i = 0; i < n; i++)
-        total += longueur(table[i].mot);
+        total += table[i].longueur_mot;
     return (double)total / n;
 }
 
-double ecart_type_longueur(const Entree *table, int n)
+double ecart_type_longueur(const Entree *table, int n, double moyenne)
 {
     double somme = 0.0;
     for (int i = 0; i < n; i++) {
-        double ecart = longueur(table[i].mot) - longueur_moyenne(table, n);
+        double ecart = table[i].longueur_mot - moyenne;
         somme += ecart * ecart;
     }
     return somme / n;   /* variance ; la racine est prise dans main */
@@ -368,15 +437,22 @@ void analyser_bigrammes(char **lignes, int nb_lignes,
 
 char *construire_rapport(const Entree *table, int n)
 {
-    char *rapport = malloc((size_t)n * 64 + 256);
-    char ligne[128];
-    rapport[0] = '\0';
-
-    ajouter(rapport, "rang;mot;occurrences\n");
+    size_t capacite = (size_t)n * 64 + 256;
+    char *rapport = malloc(capacite);
+    if (rapport == NULL) {
+        perror("malloc rapport");
+        exit(EXIT_FAILURE);
+    }
+    size_t position = (size_t)snprintf(rapport, capacite, "rang;mot;occurrences\n");
     for (int i = 0; i < n; i++) {
-        snprintf(ligne, sizeof(ligne), "%d;%s;%d\n",
-                 i + 1, table[i].mot, table[i].occurrences);
-        ajouter(rapport, ligne);
+        int taille = snprintf(rapport + position, capacite - position,
+                             "%d;%s;%d\n", i + 1, table[i].mot, table[i].occurrences);
+        if (taille < 0 || (size_t)taille >= capacite - position) {
+            fputs("Rapport trop long\n", stderr);
+            free(rapport);
+            exit(EXIT_FAILURE);
+        }
+        position += (size_t)taille;
     }
     return rapport;
 }
@@ -420,7 +496,7 @@ int main(void)
     trier_entrees(table, nb_entrees);
 
     double moyenne = longueur_moyenne(table, nb_entrees);
-    double ecart_type = racine(ecart_type_longueur(table, nb_entrees));
+    double ecart_type = racine(ecart_type_longueur(table, nb_entrees, moyenne));
 
     char trigramme[4];
     int occ_trigramme;

profil_après.txt

@@ -0,0 +1,173 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  ms/call  ms/call  name    
+ 17.78      0.08     0.08        1    80.00   108.37  analyser_bigrammes
+ 13.33      0.14     0.06   217318     0.00     0.00  compter_mots_ligne
+ 13.33      0.20     0.06        1    60.00    60.00  decouper_lignes
+  8.89      0.24     0.04 52929320     0.00     0.00  est_lettre
+  8.89      0.28     0.04        1    40.00    49.97  generer_texte
+  8.89      0.32     0.04                             _init
+  6.67      0.35     0.03   217318     0.00     0.00  normaliser_ligne
+  4.44      0.37     0.02 12656214     0.00     0.00  en_minuscule
+  4.44      0.39     0.02  3413876     0.00     0.00  egales
+  4.44      0.41     0.02  2500000     0.00     0.00  est_mot_vide
+  2.22      0.42     0.01  9027924     0.00     0.00  alea
+  2.22      0.43     0.01  1499989     0.00     0.00  compter_mot
+  2.22      0.44     0.01  1499989     0.00     0.00  hacher_mot
+  2.22      0.45     0.01        1    10.00    10.00  fusionner_entrees
+  0.00      0.45     0.00  1499989     0.00     0.00  chercher_mot
+  0.00      0.45     0.00    68597     0.00     0.00  doit_echanger
+  0.00      0.45     0.00    27010     0.00     0.00  copier
+  0.00      0.45     0.00    20994     0.00     0.00  longueur
+  0.00      0.45     0.00    20934     0.00     0.00  ajouter
+  0.00      0.45     0.00    15787     0.00     0.00  comparer
+  0.00      0.45     0.00        1     0.00     0.00  construire_rapport
+  0.00      0.45     0.00        1     0.00     0.00  ecart_type_longueur
+  0.00      0.45     0.00        1     0.00     0.00  empreinte
+  0.00      0.45     0.00        1     0.00     0.03  generer_vocabulaire
+  0.00      0.45     0.00        1     0.00     0.00  longueur_moyenne
+  0.00      0.45     0.00        1     0.00     0.00  racine
+  0.00      0.45     0.00        1     0.00    10.00  trier_entrees
+
+			Call graph
+
+
+granularity: each sample hit covers 4 byte(s) for 2.22% of 0.45 seconds
+
+index % time    self  children    called     name
+                                                 <spontaneous>
+[1]     91.1    0.00    0.41                 main [1]
+                0.06    0.06  217318/217318      compter_mots_ligne [2]
+                0.08    0.03       1/1           analyser_bigrammes [3]
+                0.03    0.03  217318/217318      normaliser_ligne [4]
+                0.06    0.00       1/1           decouper_lignes [5]
+                0.04    0.01       1/1           generer_texte [6]
+                0.00    0.01       1/1           trier_entrees [17]
+                0.00    0.00       1/1           generer_vocabulaire [18]
+                0.00    0.00       1/1           longueur_moyenne [27]
+                0.00    0.00       1/1           ecart_type_longueur [25]
+                0.00    0.00       1/1           racine [28]
+                0.00    0.00       1/1           construire_rapport [24]
+                0.00    0.00       1/1           empreinte [26]
+-----------------------------------------------
+                0.06    0.06  217318/217318      main [1]
+[2]     26.7    0.06    0.06  217318         compter_mots_ligne [2]
+                0.02    0.01 2500000/2500000     est_mot_vide [9]
+                0.01    0.02 1499989/1499989     compter_mot [10]
+-----------------------------------------------
+                0.08    0.03       1/1           main [1]
+[3]     24.1    0.08    0.03       1         analyser_bigrammes [3]
+                0.03    0.00 37544897/52929320     est_lettre [7]
+-----------------------------------------------
+                0.03    0.03  217318/217318      main [1]
+[4]     13.7    0.03    0.03  217318         normaliser_ligne [4]
+                0.02    0.00 12656214/12656214     en_minuscule [11]
+                0.01    0.00 15384423/52929320     est_lettre [7]
+-----------------------------------------------
+                0.06    0.00       1/1           main [1]
+[5]     13.3    0.06    0.00       1         decouper_lignes [5]
+-----------------------------------------------
+                0.04    0.01       1/1           main [1]
+[6]     11.1    0.04    0.01       1         generer_texte [6]
+                0.01    0.00 8999990/9027924     alea [14]
+-----------------------------------------------
+                0.01    0.00 15384423/52929320     normaliser_ligne [4]
+                0.03    0.00 37544897/52929320     analyser_bigrammes [3]
+[7]      8.9    0.04    0.00 52929320         est_lettre [7]
+-----------------------------------------------
+                                                 <spontaneous>
+[8]      8.9    0.04    0.00                 _init [8]
+-----------------------------------------------
+                0.02    0.01 2500000/2500000     compter_mots_ligne [2]
+[9]      6.9    0.02    0.01 2500000         est_mot_vide [9]
+                0.01    0.00 1864665/3413876     egales [12]
+                0.00    0.00      60/20994       longueur [21]
+-----------------------------------------------
+                0.01    0.02 1499989/1499989     compter_mots_ligne [2]
+[10]     6.5    0.01    0.02 1499989         compter_mot [10]
+                0.00    0.02 1499989/1499989     chercher_mot [13]
+                0.00    0.00    6076/27010       copier [20]
+-----------------------------------------------
+                0.02    0.00 12656214/12656214     normaliser_ligne [4]
+[11]     4.4    0.02    0.00 12656214         en_minuscule [11]
+-----------------------------------------------
+                0.01    0.00 1549211/3413876     chercher_mot [13]
+                0.01    0.00 1864665/3413876     est_mot_vide [9]
+[12]     4.4    0.02    0.00 3413876         egales [12]
+-----------------------------------------------
+                0.00    0.02 1499989/1499989     compter_mot [10]
+[13]     4.2    0.00    0.02 1499989         chercher_mot [13]
+                0.01    0.00 1499989/1499989     hacher_mot [15]
+                0.01    0.00 1549211/3413876     egales [12]
+-----------------------------------------------
+                0.00    0.00   27934/9027924     generer_vocabulaire [18]
+                0.01    0.00 8999990/9027924     generer_texte [6]
+[14]     2.2    0.01    0.00 9027924         alea [14]
+-----------------------------------------------
+                0.01    0.00 1499989/1499989     chercher_mot [13]
+[15]     2.2    0.01    0.00 1499989         hacher_mot [15]
+-----------------------------------------------
+                               12150             fusionner_entrees [16]
+                0.01    0.00       1/1           trier_entrees [17]
+[16]     2.2    0.01    0.00       1+12150   fusionner_entrees [16]
+                0.00    0.00   68597/68597       doit_echanger [19]
+                               12150             fusionner_entrees [16]
+-----------------------------------------------
+                0.00    0.01       1/1           main [1]
+[17]     2.2    0.00    0.01       1         trier_entrees [17]
+                0.01    0.00       1/1           fusionner_entrees [16]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[18]     0.0    0.00    0.00       1         generer_vocabulaire [18]
+                0.00    0.00   27934/9027924     alea [14]
+                0.00    0.00   20934/20934       ajouter [22]
+-----------------------------------------------
+                0.00    0.00   68597/68597       fusionner_entrees [16]
+[19]     0.0    0.00    0.00   68597         doit_echanger [19]
+                0.00    0.00   15787/15787       comparer [23]
+-----------------------------------------------
+                0.00    0.00    6076/27010       compter_mot [10]
+                0.00    0.00   20934/27010       ajouter [22]
+[20]     0.0    0.00    0.00   27010         copier [20]
+-----------------------------------------------
+                0.00    0.00      60/20994       est_mot_vide [9]
+                0.00    0.00   20934/20994       ajouter [22]
+[21]     0.0    0.00    0.00   20994         longueur [21]
+-----------------------------------------------
+                0.00    0.00   20934/20934       generer_vocabulaire [18]
+[22]     0.0    0.00    0.00   20934         ajouter [22]
+                0.00    0.00   20934/20994       longueur [21]
+                0.00    0.00   20934/27010       copier [20]
+-----------------------------------------------
+                0.00    0.00   15787/15787       doit_echanger [19]
+[23]     0.0    0.00    0.00   15787         comparer [23]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[24]     0.0    0.00    0.00       1         construire_rapport [24]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[25]     0.0    0.00    0.00       1         ecart_type_longueur [25]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[26]     0.0    0.00    0.00       1         empreinte [26]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[27]     0.0    0.00    0.00       1         longueur_moyenne [27]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[28]     0.0    0.00    0.00       1         racine [28]
+-----------------------------------------------
+
+Index by function name
+
+   [8] _init                  [20] copier                 [16] fusionner_entrees
+  [22] ajouter                 [5] decouper_lignes         [6] generer_texte
+  [14] alea                   [19] doit_echanger          [18] generer_vocabulaire
+   [3] analyser_bigrammes     [25] ecart_type_longueur    [15] hacher_mot
+  [13] chercher_mot           [12] egales                 [21] longueur
+  [23] comparer               [26] empreinte              [27] longueur_moyenne
+  [10] compter_mot            [11] en_minuscule            [4] normaliser_ligne
+   [2] compter_mots_ligne      [7] est_lettre             [28] racine
+  [24] construire_rapport      [9] est_mot_vide           [17] trier_entrees

profil_avant.txt

@@ -0,0 +1,177 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  ms/call  ms/call  name    
+ 28.02      0.26     0.26 121889737     0.00     0.00  egales
+ 13.74      0.38     0.12  2500000     0.00     0.00  est_mot_vide
+ 12.09      0.49     0.11        1   110.00   145.47  analyser_bigrammes
+  7.69      0.56     0.07        1    70.00    70.00  decouper_lignes
+  6.59      0.62     0.06        1    60.00    79.94  generer_texte
+  6.59      0.68     0.06                             _init
+  5.49      0.73     0.05 52929320     0.00     0.00  est_lettre
+  4.40      0.77     0.04  1499989     0.00     0.00  chercher_mot
+  4.40      0.81     0.04   217318     0.00     0.00  normaliser_ligne
+  2.75      0.83     0.03    15787     0.00     0.00  comparer
+  2.20      0.85     0.02  9027924     0.00     0.00  alea
+  2.20      0.88     0.02  1499989     0.00     0.00  compter_mot
+  1.65      0.89     0.01  1499989     0.00     0.00  hacher_mot
+  1.10      0.90     0.01 12656214     0.00     0.00  en_minuscule
+  1.10      0.91     0.01   217318     0.00     0.00  compter_mots_ligne
+  0.00      0.91     0.00    68597     0.00     0.00  doit_echanger
+  0.00      0.91     0.00    39162     0.00     0.00  longueur
+  0.00      0.91     0.00    27010     0.00     0.00  copier
+  0.00      0.91     0.00    20934     0.00     0.00  ajouter
+  0.00      0.91     0.00        2     0.00     0.00  longueur_moyenne
+  0.00      0.91     0.00        1     0.00     0.00  construire_rapport
+  0.00      0.91     0.00        1     0.00     0.00  ecart_type_longueur
+  0.00      0.91     0.00        1     0.00     0.00  empreinte
+  0.00      0.91     0.00        1     0.00    25.00  fusionner_entrees
+  0.00      0.91     0.00        1     0.00     0.06  generer_vocabulaire
+  0.00      0.91     0.00        1     0.00     0.00  racine
+  0.00      0.91     0.00        1     0.00    25.00  trier_entrees
+
+			Call graph
+
+
+granularity: each sample hit covers 4 byte(s) for 1.10% of 0.91 seconds
+
+index % time    self  children    called     name
+                                                 <spontaneous>
+[1]     93.4    0.00    0.85                 main [1]
+                0.01    0.46  217318/217318      compter_mots_ligne [2]
+                0.11    0.04       1/1           analyser_bigrammes [5]
+                0.06    0.02       1/1           generer_texte [6]
+                0.07    0.00       1/1           decouper_lignes [8]
+                0.04    0.02  217318/217318      normaliser_ligne [9]
+                0.00    0.03       1/1           trier_entrees [16]
+                0.00    0.00       1/1           generer_vocabulaire [20]
+                0.00    0.00       1/2           longueur_moyenne [24]
+                0.00    0.00       1/1           ecart_type_longueur [26]
+                0.00    0.00       1/1           racine [28]
+                0.00    0.00       1/1           construire_rapport [25]
+                0.00    0.00       1/1           empreinte [27]
+-----------------------------------------------
+                0.01    0.46  217318/217318      main [1]
+[2]     51.1    0.01    0.46  217318         compter_mots_ligne [2]
+                0.12    0.25 2500000/2500000     est_mot_vide [3]
+                0.02    0.06 1499989/1499989     compter_mot [7]
+-----------------------------------------------
+                0.12    0.25 2500000/2500000     compter_mots_ligne [2]
+[3]     41.4    0.12    0.25 2500000         est_mot_vide [3]
+                0.25    0.00 120340526/121889737     egales [4]
+-----------------------------------------------
+                0.00    0.00 1549211/121889737     chercher_mot [11]
+                0.25    0.00 120340526/121889737     est_mot_vide [3]
+[4]     28.0    0.26    0.00 121889737         egales [4]
+-----------------------------------------------
+                0.11    0.04       1/1           main [1]
+[5]     16.0    0.11    0.04       1         analyser_bigrammes [5]
+                0.04    0.00 37544897/52929320     est_lettre [12]
+-----------------------------------------------
+                0.06    0.02       1/1           main [1]
+[6]      8.8    0.06    0.02       1         generer_texte [6]
+                0.02    0.00 8999990/9027924     alea [17]
+-----------------------------------------------
+                0.02    0.06 1499989/1499989     compter_mots_ligne [2]
+[7]      8.6    0.02    0.06 1499989         compter_mot [7]
+                0.04    0.02 1499989/1499989     chercher_mot [11]
+                0.00    0.00    6076/27010       copier [22]
+-----------------------------------------------
+                0.07    0.00       1/1           main [1]
+[8]      7.7    0.07    0.00       1         decouper_lignes [8]
+-----------------------------------------------
+                0.04    0.02  217318/217318      main [1]
+[9]      7.1    0.04    0.02  217318         normaliser_ligne [9]
+                0.01    0.00 15384423/52929320     est_lettre [12]
+                0.01    0.00 12656214/12656214     en_minuscule [19]
+-----------------------------------------------
+                                                 <spontaneous>
+[10]     6.6    0.06    0.00                 _init [10]
+-----------------------------------------------
+                0.04    0.02 1499989/1499989     compter_mot [7]
+[11]     6.4    0.04    0.02 1499989         chercher_mot [11]
+                0.01    0.00 1499989/1499989     hacher_mot [18]
+                0.00    0.00 1549211/121889737     egales [4]
+-----------------------------------------------
+                0.01    0.00 15384423/52929320     normaliser_ligne [9]
+                0.04    0.00 37544897/52929320     analyser_bigrammes [5]
+[12]     5.5    0.05    0.00 52929320         est_lettre [12]
+-----------------------------------------------
+                0.00    0.03   68597/68597       fusionner_entrees [15]
+[13]     2.7    0.00    0.03   68597         doit_echanger [13]
+                0.03    0.00   15787/15787       comparer [14]
+-----------------------------------------------
+                0.03    0.00   15787/15787       doit_echanger [13]
+[14]     2.7    0.03    0.00   15787         comparer [14]
+-----------------------------------------------
+                               12150             fusionner_entrees [15]
+                0.00    0.03       1/1           trier_entrees [16]
+[15]     2.7    0.00    0.03       1+12150   fusionner_entrees [15]
+                0.00    0.03   68597/68597       doit_echanger [13]
+                               12150             fusionner_entrees [15]
+-----------------------------------------------
+                0.00    0.03       1/1           main [1]
+[16]     2.7    0.00    0.03       1         trier_entrees [16]
+                0.00    0.03       1/1           fusionner_entrees [15]
+-----------------------------------------------
+                0.00    0.00   27934/9027924     generer_vocabulaire [20]
+                0.02    0.00 8999990/9027924     generer_texte [6]
+[17]     2.2    0.02    0.00 9027924         alea [17]
+-----------------------------------------------
+                0.01    0.00 1499989/1499989     chercher_mot [11]
+[18]     1.6    0.01    0.00 1499989         hacher_mot [18]
+-----------------------------------------------
+                0.01    0.00 12656214/12656214     normaliser_ligne [9]
+[19]     1.1    0.01    0.00 12656214         en_minuscule [19]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[20]     0.0    0.00    0.00       1         generer_vocabulaire [20]
+                0.00    0.00   27934/9027924     alea [17]
+                0.00    0.00   20934/20934       ajouter [23]
+-----------------------------------------------
+                0.00    0.00    6076/39162       ecart_type_longueur [26]
+                0.00    0.00   12152/39162       longueur_moyenne [24]
+                0.00    0.00   20934/39162       ajouter [23]
+[21]     0.0    0.00    0.00   39162         longueur [21]
+-----------------------------------------------
+                0.00    0.00    6076/27010       compter_mot [7]
+                0.00    0.00   20934/27010       ajouter [23]
+[22]     0.0    0.00    0.00   27010         copier [22]
+-----------------------------------------------
+                0.00    0.00   20934/20934       generer_vocabulaire [20]
+[23]     0.0    0.00    0.00   20934         ajouter [23]
+                0.00    0.00   20934/39162       longueur [21]
+                0.00    0.00   20934/27010       copier [22]
+-----------------------------------------------
+                0.00    0.00       1/2           ecart_type_longueur [26]
+                0.00    0.00       1/2           main [1]
+[24]     0.0    0.00    0.00       2         longueur_moyenne [24]
+                0.00    0.00   12152/39162       longueur [21]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[25]     0.0    0.00    0.00       1         construire_rapport [25]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[26]     0.0    0.00    0.00       1         ecart_type_longueur [26]
+                0.00    0.00    6076/39162       longueur [21]
+                0.00    0.00       1/2           longueur_moyenne [24]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[27]     0.0    0.00    0.00       1         empreinte [27]
+-----------------------------------------------
+                0.00    0.00       1/1           main [1]
+[28]     0.0    0.00    0.00       1         racine [28]
+-----------------------------------------------
+
+Index by function name
+
+  [10] _init                  [22] copier                 [15] fusionner_entrees
+  [23] ajouter                 [8] decouper_lignes         [6] generer_texte
+  [17] alea                   [13] doit_echanger          [20] generer_vocabulaire
+   [5] analyser_bigrammes     [26] ecart_type_longueur    [18] hacher_mot
+  [11] chercher_mot            [4] egales                 [21] longueur
+  [14] comparer               [27] empreinte              [24] longueur_moyenne
+   [7] compter_mot            [19] en_minuscule            [9] normaliser_ligne
+   [2] compter_mots_ligne     [12] est_lettre             [28] racine
+  [25] construire_rapport      [3] est_mot_vide           [16] trier_entrees