C++ Academy · Lektion

Code-Performance messen

Mit chrono Benchmarks erstellen

Code-Performance messen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum benchmarken?

Wenn Sie messen, wie lange Code ausgeführt wird, können Sie Engpässe finden und Optimierungen überprüfen. Mit <chrono> erhalten Sie portable, typsichere Zeitmessungen.

Messen Sie vor dem Optimieren.
Verwenden Sie für zuverlässige Zeitintervalle eine stetige Uhr.

#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;
}

Das grundlegende Muster

Das Muster für Benchmarking ist immer gleich: Erfassen Sie vor der Arbeit now(), führen Sie sie aus, erfassen Sie danach erneut now() und subtrahieren Sie die beiden Werte.

#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;
}

Die Einheit auswählen

Wählen Sie die Einheit passend zur Aufgabe. Verwenden Sie microseconds oder nanoseconds für schnelle Schleifen und milliseconds für größere Aufgaben.

#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;
}

Zeitmessung mit Gleitkommawerten

Für gut lesbare Sekunden mit Nachkommastellen verwenden Sie eine duration<double>, damit die Genauigkeit unterhalb einer Sekunde erhalten bleibt.

#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;
}

Ein wiederverwendbarer Timer

Kapseln Sie das Muster in eine kleine Hilfsfunktion, damit Sie beliebige aufrufbare Objekte sauber messen können und Wiederholungen vermeiden.

#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;
}

Eliminierung von ungenutztem Code vermeiden

Compiler können Arbeit löschen, deren Ergebnis nicht verwendet wird, und dadurch Benchmarks verfälschen. Verwenden Sie das Ergebnis immer, indem Sie es beispielsweise ausgeben oder in einer sichtbaren Variable akkumulieren.

#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;
}

Aufwärmläufe

Der erste Lauf kann wegen Caches und verzögerter Initialisierung langsamer sein. Führen Sie vor der Messung einen Aufwärmlauf durch, um stabilere Werte zu erhalten.

#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;
}

Mehrere Läufe mitteln

Eine einzelne Messung ist ungenau. Führen Sie die Arbeit viele Male aus, addieren Sie die verstrichenen Zeitdauern und teilen Sie die Summe, um einen stabilen Durchschnitt zu erhalten.

#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;
}

Zwei Ansätze vergleichen

Benchmarking ist besonders nützlich, wenn Sie Implementierungen vergleichen. Messen Sie jede auf dieselbe Weise und vergleichen Sie anschließend die ermittelten Dauern.

#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;
}

Achten Sie auf die Auflösung

Wenn die gemessene Arbeit kürzer als ein Takt der Uhr ist, lesen Sie möglicherweise null. Führen Sie die Arbeit oft genug aus, um die Auflösung der Uhr zu überschreiten.

#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;
}

Ergebnisse ausgeben

Wandeln Sie die endgültige Dauer in eine gut lesbare Einheit um und geben Sie sie aus. Halten Sie das verwendete Ergebnis sichtbar, damit der Optimierer die Arbeit nicht entfernen kann.

#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;
}

Kurzer Check

Prüfen Sie Ihr Verständnis der Fallstricke beim Benchmarking.

Zusammenfassung

Sie haben gelernt, wie Sie Code mit <chrono> benchmarken:

Erfassen Sie vor und nach der Ausführung steady_clock::now() und bilden Sie anschließend die Differenz.
Wählen Sie mit duration_cast eine geeignete Einheit.
Wärmen Sie den Code auf, mitteln Sie mehrere Durchläufe und verwenden Sie die Ergebnisse, um die Eliminierung toten Codes zu verhindern.
Achten Sie bei sehr kleinen Arbeitsmengen auf die Auflösung der Uhr.

Als Nächstes erkunden Sie die Kalender- und Zeitzonentypen von C++20.

Häufig gestellte Fragen

Ist die Lektion „Code-Performance messen“ kostenlos?

Ja — der vollständige Text von „Code-Performance messen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Code-Performance messen“?

Mit chrono Benchmarks erstellen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Code-Performance messen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy