Ne devine pas où le temps passe : demande au profileur. L'intuition se trompe presque toujours sur l'endroit du goulot.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : avancé · 🏅 Badge : Chasseur de points chauds
🎬 L'histoire
Kodi est sûr que la génération du rapport mensuel est lente à cause de la base de données. Il passe une journée à optimiser les requêtes. Gain : 3 %. Sam lance le profileur : 82 % du temps est passé dans une fonction de mise en forme de texte, appelée 400 000 fois.
« L'intuition nous dit "c'est la base", ou "c'est ce qui est compliqué", dit Sam. Le profileur dit où le CPU est réellement consommé. Il coûte cinq minutes et fait économiser des jours. Et il suit une règle : on optimise ce qui est chaud, jamais ce qui est froid. »
Tu apprends à profiler avec cProfile, à lire un profil, à distinguer temps propre et temps cumulé, à bâtir ton propre profileur par échantillonnage, et à corriger un point chaud en vérifiant le gain.
🎯 Ta mission
À la fin, je serai capable de :
- utiliser
cProfileetpstatspour identifier les fonctions les plus coûteuses - distinguer temps propre (tottime) et temps cumulé (cumtime)
- expliquer la différence entre profilage par instrumentation et par échantillonnage
- corriger un point chaud (algorithme, structure de données, appels répétés) et mesurer le gain
- appliquer Amdahl à une série d'optimisations
🧩 Défi d'échauffement (5 XP)
Une cuisine met 45 minutes à servir un plat. Le chef pense que la cuisson est trop lente. Un observateur chronomètre chaque étape : préparation 5 min, cuisson 8 min, attente d'un ingrédient qu'on va chercher en cave 30 min, dressage 2 min. Où faut-il agir ? Qu'aurait-on fait en suivant l'intuition du chef ?
💡 Le concept
Pourquoi profiler
Les programmeurs devinent mal où le temps passe. Les loi de Pareto s'applique : 80 % du temps dans 20 % du code (souvent 95 % dans 5 %). Optimiser du code froid est du temps perdu et rend le code plus complexe pour rien. Citation célèbre de Knuth : « l'optimisation prématurée est la racine de tous les maux » — optimiser avant d'avoir mesuré.
Deux familles de profileurs
| Instrumentation (déterministe) | Échantillonnage (statistique) | |
|---|---|---|
| Principe | enregistre chaque appel et retour de fonction | regarde périodiquement (100 fois/s) quelle fonction s'exécute |
| Précision | exacte (nombre d'appels, temps) | approximative, mais statistiquement fiable |
| Coût | élevé (ralentit le programme, fausse les petites fonctions) | faible (utilisable en production) |
| Exemples | cProfile, profile | py-spy, perf, profileurs de production |
cProfile : le profileur standard de Python
python -m cProfile -s cumtime mon_script.py # en ligne de commande
Ou dans le code :
profil = cProfile.Profile()
profil.enable(); ma_fonction(); profil.disable()
stats = pstats.Stats(profil).sort_stats("tottime")
stats.print_stats(10)
Lire un profil
| Colonne | Sens |
|---|---|
ncalls | nombre d'appels (10/3 : 10 appels dont 3 primitifs, la différence venant de la récursion) |
tottime | temps propre : passé dans la fonction elle-même, sans ses sous-appels |
percall | temps par appel |
cumtime | temps cumulé : la fonction et tout ce qu'elle appelle |
- Un
tottimeélevé désigne le code qui calcule : c'est le point chaud. - Un
cumtimeélevé avec un faibletottimedésigne un chef d'orchestre : cherche plus bas. - Un
ncallsénorme avec un petitpercall: le coût vient du nombre d'appels (peut-être un appel dans une boucle qui pourrait sortir de la boucle).
Les points chauds fréquents
| Cause | Symptôme dans le profil | Remède |
|---|---|---|
| Algorithme quadratique (HEF-030) | tottime croissant plus vite que les données | meilleur algorithme / structure de données |
| Recalcul identique | même fonction avec les mêmes arguments, ncalls élevé | mémoïsation, sortir de la boucle |
| Concaténation de chaînes en boucle | tottime dans le code de concaténation | join |
| Recherche dans une liste | in sur liste dans une boucle | set / dict |
| Conversions inutiles | str, int, list(...) dans la boucle |
Méthode en 5 étapes
- Baseline : mesurer le temps total sur une charge représentative.
- Profiler sur cette charge.
- Identifier le point chaud (celui qui a le plus fort
tottime). - Corriger une seule chose.
- Remesurer et vérifier que le résultat est identique. Recommencer, jusqu'à atteindre le budget.
Amdahl appliqué à l'optimisation
Si une fonction représente une part f du temps et qu'on la rend s fois plus rapide, l'accélération globale est 1 / ((1 − f) + f / s). Rendre ×100 plus rapide un code qui ne pèse que 5 % du total donne au mieux ×1,05. Il faut viser le plus gros morceau d'abord, et recommencer : le point chaud suivant devient visible.
Profileur par échantillonnage maison
En Python, sys._current_frames() donne la pile de chaque thread. Un thread secondaire qui l'interroge 200 fois par seconde et compte les fonctions rencontrées construit un profil statistique à très faible coût.
🧠 Astuce : profile avec des données réalistes. Un profil sur trois lignes de données ment sur le comportement avec trois millions.
🔍 Exemple pas à pas
Problème : profiler un générateur de rapport lent, identifier le point chaud avec cProfile, le corriger, et vérifier que le résultat est identique et que le gain correspond à la prédiction d'Amdahl.
import cProfile, io, pstats, time
# ---------------- le programme lent ----------------
def charger(n):
return [{"membre": f"m{i % 800}", "cours": f"HEF-{(i * 7) % 90:03d}", "montant": (i * 37) % 200} for i in range(n)]
def est_membre_premium(membre, premiums):
return membre in premiums # premiums est une LISTE : recherche en O(n)
def formater_ligne(e):
texte = ""
for morceau in (e["membre"], " ", e["cours"], " ", str(e["montant"]), "€"):
texte += morceau # concaténation répétée
return texte
def rapport_lent(evenements, premiums):
total_premium, lignes = 0, []
for e in evenements:
if est_membre_premium(e[], premiums):
total_premium += e[]
lignes.append(formater_ligne(e))
total_premium, .join(lignes)
EVENEMENTS = charger()
PREMIUMS = [ i (, , )]
profil = cProfile.Profile()
profil.enable()
resultat_lent = rapport_lent(EVENEMENTS, PREMIUMS)
profil.disable()
sortie = io.StringIO()
stats = pstats.Stats(profil, stream=sortie).sort_stats()
total = stats.total_tt
lignes = (((v[], k[]) k, v stats.stats.items() k[] == k[] k[] k[]), reverse=)
()
tottime, nom lignes[:]:
()
chaud = lignes[][]
chaud ==
():
premiums = (premiums)
total_premium, lignes = , []
e evenements:
e[] premiums:
total_premium += e[]
lignes.append(formater_ligne(e))
total_premium, .join(lignes)
():
meilleur = ()
_ (n):
d = time.perf_counter(); f(*args); meilleur = (meilleur, time.perf_counter() - d)
meilleur
t0, t1 = temps(rapport_lent, EVENEMENTS, PREMIUMS), temps(rapport_v2, EVENEMENTS, PREMIUMS)
rapport_v2(EVENEMENTS, PREMIUMS) == resultat_lent
()
t0 / t1 >
profil = cProfile.Profile(); profil.enable(); rapport_v2(EVENEMENTS, PREMIUMS); profil.disable()
stats = pstats.Stats(profil, stream=io.StringIO())
suivant = (((v[], k[]) k, v stats.stats.items() k[] (, , )), default=(, ))
(, suivant[])
():
premiums = (premiums)
total_premium = (e[] e evenements e[] premiums)
total_premium, .join( e evenements)
t2 = temps(rapport_v3, EVENEMENTS, PREMIUMS)
rapport_v3(EVENEMENTS, PREMIUMS) == resultat_lent
()
t2 < t1
part_chaude, acceleration_locale = ,
()
( / (( - part_chaude) + part_chaude / acceleration_locale), ) ==
Lecture :
- Le profil désigne
est_membre_premium(recherche dans une liste) comme point chaud — pas la mise en forme que l'intuition aurait suspectée. - Passer la liste en ensemble donne un gain de plusieurs fois, résultat identique vérifié.
- Après correction, le profil change : un nouveau point chaud apparaît (le formatage). On recommence — c'est un cycle.
- Amdahl prédit le gain : un point chaud de 80 % rendu 50 fois plus rapide ne donne que ×4,6 global. Les 20 % restants deviennent la limite.
✍️ À toi, avec aide (10 XP)
Compare quatre façons de construire une grande chaîne à partir de 100 000 petits morceaux, avec timeit (ou ton banc de la mission 2) :
texte += morceaudans une boucle ;"".join(liste);io.StringIOavecwrite;- une liste de morceaux puis
"".joinsur un générateur.
Classe-les, calcule le rapport entre la plus lente et la plus rapide, et assure-toi que les quatre produisent le même texte. Conclus : quelle serait ta règle générale ?
💡 Indice 1
Prépare morceaux = [str(i) for i in range(100000)] une fois.
💡 Indice 2
Utilise timeit.timeit(fonction, number=5).
💡 Indice 3
Vérifie l'égalité des résultats avec assert.
✅ Réponse
import io, timeit
morceaux = [str(i) for i in range(100000)]
def concat():
t = ""
for m in morceaux: t += m
return t
def jointure(): return "".join(morceaux)
def flux():
s = io.StringIO()
for m in morceaux: s.write(m)
return s.getvalue()
def generateur(): return "".join(m for m in morceaux)
assert concat() == jointure() == flux() == generateur()
resultats = {f.__name__: min(timeit.repeat(f, number=3, repeat=5)) / 3 for f in (concat, jointure, flux, generateur)}
for nom, t in sorted(resultats.items(), key=lambda kv: kv[1]):
print(f"{nom:10s} {t * 1000:7.2f} ms")
assert (resultats, key=resultats.get) ==
🚀 À toi, en solo (20 XP)
Écris ton propre profileur par échantillonnage. Avec threading et sys._current_frames() :
- un thread échantillonneur interroge la pile du thread principal toutes les 2 ms et note le nom de la fonction en haut de pile, ainsi que la chaîne d'appelants ;
- à l'arrêt, il produit un tableau : fonction, nombre d'échantillons, pourcentage, avec distinction « propre » (en haut de pile) et « cumulé » (présente dans la pile) ;
- teste-le sur un programme qui passe ~70 % de son temps dans
fonction_a, ~25 % dansfonction_bet ~5 % ailleurs ; - vérifie que ton profil s'approche de ces proportions (à 15 points près) ;
- compare avec
cProfilesur le même programme.
✅ Pistes de correction
import cProfile, collections, io, pstats, sys, threading, time
class Echantillonneur:
def __init__(self, intervalle=0.002):
self.intervalle, self.propre, self.cumule, self.total = intervalle, collections.Counter(), collections.Counter(), 0
self._stop, self._cible = threading.Event(), threading.get_ident()
self._thread = threading.Thread(target=self._boucle, daemon=True)
def _boucle(self):
while not self._stop.is_set():
frame = sys._current_frames().get(self._cible)
if frame is not None:
noms = []
while frame:
noms.append(frame.f_code.co_name); frame = frame.f_back
self.propre[noms[0]] += 1
for n in set(noms): self.cumule[n] += 1
self.total += 1
time.sleep(.intervalle)
(): ._thread.start();
(): ._stop.(); ._thread.join()
():
[(n, c, c / .total) n, c .propre.most_common()]
():
fin = time.perf_counter() + duree
x =
time.perf_counter() < fin:
x +=
x
(): travailler()
(): travailler()
():
fonction_a(); fonction_b(); travailler()
Echantillonneur() e:
programme()
nom, c, part e.tableau()[:]:
()
cumul_a, cumul_b = e.cumule[] / e.total, e.cumule[] / e.total
(cumul_a - ) < (cumul_b - ) <
e.cumule[] / e.total >
pr = cProfile.Profile(); pr.enable(); programme(); pr.disable()
st = pstats.Stats(pr, stream=io.StringIO())
cum = {k[]: v[] k, v st.stats.items()}
()
(cum[] / cum[] - cumul_a) <
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Optimiser par intuition | On améliore ce qui est froid | Profiler d'abord, optimiser le point chaud |
| Profiler sur des données minuscules | Le profil ne reflète pas la charge réelle | Données représentatives |
| Changer plusieurs choses à la fois | On ne sait pas ce qui a aidé | Un changement, une mesure |
| Oublier de vérifier le résultat | Une version plus rapide mais fausse | Comparer les sorties avant et après |
🐉 Mini-boss (40 XP)
Série d'optimisations guidée par le profil. On te donne (ou tu écris) un programme rapport.py de 80 lignes avec quatre points chauds cachés (liste au lieu d'ensemble, recalcul dans une boucle, concaténation de chaînes, expression régulière recompilée) sur 50 000 enregistrements.
- mesure la baseline avec le banc de la mission 2 ;
- profile avec
cProfile, désigne le point chaud n°1, prédis le gain avec Amdahl, corrige, mesure ; - recommence jusqu'à avoir traité les quatre ;
- à chaque étape : tableau (étape, correction, temps, accélération cumulée, accélération prédite par Amdahl) ;
- vérifie à chaque étape que la sortie est strictement identique ;
- trace un graphique texte du temps après chaque étape et explique pourquoi le gain par étape diminue ;
- conclus : à quel moment aurais-tu arrêté d'optimiser, et pourquoi ?
✅ Pistes de correction
Un bon travail : un tableau du type « étape 1 : liste→ensemble, ×6 ; étape 2 : sortir le calcul de la boucle, ×1,9 ; … » avec des gains décroissants (loi des rendements décroissants : chaque étape traite une part plus petite du temps restant), la prédiction d'Amdahl proche de la mesure, des sorties identiques à chaque étape. L'arrêt se justifie par l'atteinte du budget ou par le fait que le prochain gain est inférieur au coût de maintenance du code plus complexe.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Dans un profil, tottime mesure :
- A. le temps total du programme
- B. le temps passé dans la fonction elle-même, sans ses sous-appels
- C. le nombre d'appels
2. La première étape d'une optimisation est de :
- A. réécrire le code en C
- B. ajouter du cache partout
- C. profiler pour identifier le point chaud
3. Un profileur par échantillonnage :
- A. observe périodiquement quelle fonction s'exécute, avec un faible coût
- B. enregistre chaque appel sans coût
- C. remplace les tests
4. 🔁 Révision mission 02 : Pour décrire la latence ressentie par les moins chanceux, on regarde :
- A. la moyenne uniquement
- B. les percentiles élevés (p95, p99)
- C. le nombre de serveurs
5. 🔁 Révision mission 02 : Si les intervalles de confiance de deux versions se chevauchent largement :
- A. la version B est meilleure
- B. la version A est meilleure
- C. la différence n'est pas démontrée
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quelle partie de ton code crois-tu lente par intuition, sans l'avoir profilée ?
- À partir de quel gain estimé arrêterais-tu d'optimiser un point chaud ?
🎒 À retenir
- Profiler avant d'optimiser : 80/20, voire 95/5.
- tottime (propre) contre cumtime (cumulé) ; ncalls élevé = piste.
- Instrumentation (précis, coûteux) contre échantillonnage (léger, statistique).
- Un changement à la fois, résultat vérifié identique.
- Amdahl : le gain global dépend de la part du point chaud.
flowchart LR
T(["Profilage CPU"])
T --> R1["1. Profiler avant d'optimiser : 80/20, voire 95/5."]
T --> R2["2. tottime propre contre cumtime cumulé ; ncalls élevé = piste."]
T --> R3["3. Instrumentation précis, coûteux contre échantillonnage léger,…"]
T --> R4["4. Un changement à la fois, résultat vérifié identique."]
T --> R5["5. Amdahl : le gain global dépend de la part du point chaud."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chasseur de points chauds
← Mission 02 — Métriques et budgets · Mission 04 — Mémoire et allocations →
HEF-130 — Performance

