# Compte-rendu TD1

**Nom Binôme :** Luka PLOUVIER et Jimmy COLOMB-RAVAT

## 1. Mesurer

**Empreinte du rapport :** `1d53de903efd2b7c`

```text
real	0m2.638s
user	0m2.613s
sys	0m0.004s
```

## 3. Analyser

### Profil plat :

```text
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
 39.12      0.84     0.84 308701874     0.00     0.00  egales
 32.41      1.54     0.70 36009819     0.00     0.00  longueur
 12.04      1.80     0.26   150182     0.00     0.01  chercher_mot
```

La plupart du temps d'<del>éxecution</del><add>exécution</add> se passe par ces fonctions.
En observant le code, on se rend compte qu'il est difficile d'optimiser les fonctions `egales` et `longueur`.

### Graphe d'appels :

Dans `ecart_type_longueur` on voit qu'elle <del>appel</del><add>appelle</add> `longueur_moyenne` pour chaque <del>mots unique</del><add>mot unique</add> alors que la moyenne est déjà <del>calculer</del><add>calculée</add> dans le `main`.

```text
                 0.00    0.00       1/5867        main [1]
                0.07    0.67    5866/5867        ecart_type_longueur [7]
[6]     34.2    0.07    0.67    5867         longueur_moyenne [6]
                0.67    0.00 34415822/36009819     longueur [8]
```

`longueur_moyenne` <del>appel</del><add>appelle</add> 34.4 millions de fois `longueur` soit 95% des 36 millions d'appels pour 34.2% du temps total.

`chercher_mot` fait une <del>rechercher</del><add>recherche</add> linéaire pour chacune des 150 182 <del>occurences</del><add>occurrences</add>. Comme la table grandit jusqu'à 5866 entrées, c'est un comptage de mots x mots_uniques soit 296,6 millions d'appels à `égales` sur les 308,7 millions d'appels au total.

## 4. Proposer

* Faire une table de hachage pour le comptage des mots dans `chercher_mot`.
* Calculer la moyenne une seule fois dans `ecart_type_longueur`.

## 5. Optimiser

**Comparaison des appels à `egales` :**

*Avant :*
```text
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name 
39.12      0.84     0.84 308701874     0.00     0.00  egales
```

*Après :*
```text
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name 
2.25      1.03     0.03 12195414     0.00     0.00  egales
```

On peut voir que le nombre d'appels de `egales` a diminué de près de 296 millions.

```text
real	0m1.867s
user	0m1.829s
sys	0m0.000s
```

Le temps d'<del>éxecution</del><add>exécution</add> a diminué de 0,8 seconde.

**Comparaison des appels à `longueur` :**

*Avant :*
```text
%   cumulative   self              self     total           
time   seconds   seconds    calls  ms/call  ms/call  name 
63.06      0.70     0.70 36009819     0.00     0.00  longueur
```

*Après :*
```text
%   cumulative   self              self     total           
time   seconds   seconds    calls  ms/call  ms/call  name 
66.67      0.46     0.46  1605729     0.00     0.00  longueur
```

**Comparaison des appels à `longueur_moyenne` :**

*Avant :*
```text
%   cumulative   self              self     total           
time   seconds   seconds    calls  ms/call  ms/call  name 
9.91      0.81     0.11     5867     0.02     0.13  longueur_moyenne
```

*Après :*
```text
%   cumulative   self              self     total           
time   seconds   seconds    calls  ms/call  ms/call  name 
0.00      0.69     0.00        2     0.00     1.68  longueur_moyenne
```

On peut voir qu'on a diminué le nombre d'appels de `longueur` de 34,4 millions d'appels environ en n'appelant <del>que 1 seule fois</del><add>qu'une seule fois</add> `longueur_moyenne` dans `ecart_type_longueur`.

```text
real	0m1.205s
user	0m1.167s
sys	0m0.000s
```

On a encore diminué le temps d'<del>éxecution</del><add>exécution</add> de 0.8 seconde.