C++ Academy · Leçon

Mesurer les performances du code

Évaluer les performances avec chrono

Mesurer les performances du code est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Pourquoi mesurer les performances ?

Mesurer la durée d’exécution du code vous aide à trouver les goulots d’étranglement et à vérifier les optimisations. Avec <chrono>, vous bénéficiez d’une mesure du temps portable et sûre du point de vue des types.

Mesurez avant d’optimiser.
Utilisez une horloge stable pour obtenir des intervalles fiables.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    auto end = steady_clock::now();
    std::cout << "Timed a block: " << ((end - start).count() >= 0) << '\n';
    return 0;
}

La méthode de base

La méthode de mesure des performances est toujours la même : capturez now() avant le travail, exécutez-le, capturez now() après, puis soustrayez les deux valeurs.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    long sum = 0;
    for (int i = 0; i < 100000; ++i) sum += i;
    auto end = steady_clock::now();
    std::cout << "Sum: " << sum << ", elapsed >= 0: " << ((end - start).count() >= 0) << '\n';
    return 0;
}

Choisir l’unité

Choisissez l’unité adaptée à la charge de travail. Utilisez microseconds ou nanoseconds pour les boucles rapides, et milliseconds pour les tâches plus importantes.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    long sum = 0;
    for (int i = 0; i < 500000; ++i) sum += i;
    auto end = steady_clock::now();
    auto us = duration_cast<microseconds>(end - start);
    std::cout << "Result: " << sum << ", us non-negative: " << (us.count() >= 0) << '\n';
    return 0;
}

Mesure du temps à virgule flottante

Pour obtenir des secondes lisibles avec des fractions, utilisez une duration<double> afin de conserver la précision inférieure à la seconde.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    long sum = 0;
    for (int i = 0; i < 200000; ++i) sum += i % 7;
    auto end = steady_clock::now();
    duration<double> secs = end - start;
    std::cout << "Computed " << sum << ", seconds >= 0: " << (secs.count() >= 0) << '\n';
    return 0;
}

Un minuteur réutilisable

Encapsulez cette méthode dans un petit utilitaire afin de pouvoir mesurer proprement n’importe quelle fonction et d’éviter de répéter le même code.

#include <iostream>
#include <chrono>

long long timeWork() {
    using namespace std::chrono;
    auto s = steady_clock::now();
    long acc = 0;
    for (int i = 0; i < 100000; ++i) acc += i;
    auto e = steady_clock::now();
    return duration_cast<microseconds>(e - s).count();
}

int main() {
    std::cout << "Microseconds non-negative: " << (timeWork() >= 0) << '\n';
    return 0;
}

Éviter la suppression du code mort

Les compilateurs peuvent supprimer un calcul dont le résultat n’est pas utilisé, ce qui fausse les mesures de performances. Veillez toujours à consommer le résultat, par exemple en l’affichant ou en l’accumulant dans une variable visible.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto s = steady_clock::now();
    volatile long sink = 0;
    for (int i = 0; i < 100000; ++i) sink += i;
    auto e = steady_clock::now();
    std::cout << "Sink used: " << (sink > 0) << ", elapsed >= 0: " << ((e - s).count() >= 0) << '\n';
    return 0;
}

Exécutions d’échauffement

La première exécution peut être plus lente à cause des caches et de l’initialisation différée. Effectuez un passage d’échauffement avant la mesure pour obtenir des résultats plus stables.

#include <iostream>
#include <chrono>

long work() {
    long a = 0;
    for (int i = 0; i < 50000; ++i) a += i;
    return a;
}

int main() {
    using namespace std::chrono;
    work();
    auto s = steady_clock::now();
    long r = work();
    auto e = steady_clock::now();
    std::cout << r << " measured, ok: " << ((e - s).count() >= 0) << '\n';
    return 0;
}

Moyenne de plusieurs exécutions

Une seule mesure est bruitée. Exécutez le travail de nombreuses fois, additionnez les durées écoulées, puis divisez le total pour obtenir une moyenne stable.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    long long total = 0;
    const int runs = 5;
    for (int r = 0; r < runs; ++r) {
        auto s = steady_clock::now();
        long acc = 0;
        for (int i = 0; i < 100000; ++i) acc += i;
        auto e = steady_clock::now();
        total += duration_cast<microseconds>(e - s).count();
    }
    std::cout << "Average us non-negative: " << ((total / runs) >= 0) << '\n';
    return 0;
}

Comparaison de deux approches

L'étalonnage est particulièrement utile pour comparer des implémentations. Mesurez le temps de chacune de la même manière, puis comparez les durées obtenues.

#include <iostream>
#include <chrono>
#include <vector>

int main() {
    using namespace std::chrono;
    std::vector<int> v;
    auto s1 = steady_clock::now();
    for (int i = 0; i < 10000; ++i) v.push_back(i);
    auto e1 = steady_clock::now();
    v.clear();
    v.reserve(10000);
    auto s2 = steady_clock::now();
    for (int i = 0; i < 10000; ++i) v.push_back(i);
    auto e2 = steady_clock::now();
    std::cout << "Both timed: " << (((e1 - s1).count() >= 0) && ((e2 - s2).count() >= 0)) << '\n';
    return 0;
}

Attention à la résolution

Si le travail mesuré est plus court qu'une oscillation de l'horloge, vous pouvez obtenir zéro. Répétez le travail suffisamment de fois pour dépasser la résolution de l'horloge.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto s = steady_clock::now();
    int x = 1 + 1;
    auto e = steady_clock::now();
    auto ns = duration_cast<nanoseconds>(e - s).count();
    std::cout << "x=" << x << ", tiny work may read low: " << (ns >= 0) << '\n';
    return 0;
}

Présentation des résultats

Convertissez la durée finale dans une unité lisible et affichez-la. Laissez le résultat utilisé visible afin que l'optimiseur ne puisse pas supprimer le travail.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto s = steady_clock::now();
    long acc = 0;
    for (int i = 0; i < 300000; ++i) acc += (i * 3) % 11;
    auto e = steady_clock::now();
    auto ms = duration_cast<milliseconds>(e - s).count();
    std::cout << "acc=" << acc << ", ms >= 0: " << (ms >= 0) << '\n';
    return 0;
}

Vérification rapide

Vérifiez votre compréhension des pièges de l'étalonnage.

Bilan

Vous avez appris à étalonner du code avec <chrono> :

capturez steady_clock::now() avant et après, puis soustrayez les deux valeurs
choisissez une unité appropriée avec duration_cast
effectuez une phase de préchauffage, calculez la moyenne de plusieurs exécutions et utilisez les résultats pour empêcher l'élimination du code mort
tenez compte de la résolution de l'horloge pour les charges de travail très petites

Ensuite, vous découvrirez les types de calendrier et de fuseaux horaires de C++20.

Questions Fréquemment Posées

La leçon « Mesurer les performances du code » est-elle gratuite ?

Oui — le texte complet de « Mesurer les performances du code » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mesurer les performances du code » ?

Évaluer les performances avec chrono Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Mesurer les performances du code » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy