C++ Academy · Lección

Medición del rendimiento del código

Compare el rendimiento con chrono

Medición del rendimiento del código es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Por qué hacer benchmarking?

Medir cuánto tarda en ejecutarse el código le ayuda a encontrar cuellos de botella y verificar las optimizaciones. Con <chrono> obtiene una medición del tiempo portable y segura con respecto a los tipos.

Mida antes de optimizar.
Use un reloj estable para obtener intervalos 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;
}

El patrón básico

El patrón de benchmarking es siempre el mismo: capture now() antes del trabajo, ejecútelo, capture now() después y reste.

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

Elegir la unidad

Elija la unidad que se ajuste a la carga de trabajo. Use microseconds o nanoseconds para bucles rápidos y milliseconds para tareas más grandes.

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

Medición del tiempo con coma flotante

Para obtener segundos legibles con fracciones, use una duration<double> y conserve así la precisión inferior a un segundo.

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

Temporizador reutilizable

Encapsule el patrón en un pequeño auxiliar para poder medir limpiamente cualquier objeto invocable y evitar repetir código.

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

Evitar la eliminación de código muerto

Los compiladores pueden eliminar el trabajo cuyo resultado no se utiliza, lo que arruina las pruebas de rendimiento. Asegúrese siempre de consumir el resultado, por ejemplo, mostrándolo o acumulándolo en una 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;
}

Ejecuciones de calentamiento

La primera ejecución puede ser más lenta debido a las cachés y a la inicialización diferida. Realice una pasada de calentamiento antes de medir para obtener cifras más estables.

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

Promediar varias ejecuciones

Una sola medición contiene ruido. Ejecute el trabajo muchas veces, sume las duraciones transcurridas y divida para obtener un promedio estable.

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

Comparación de dos enfoques

El benchmarking resulta especialmente útil al comparar implementaciones. Mida el tiempo de cada una de la misma forma y compare las duraciones obtenidas.

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

Cuidado con la resolución

Si el trabajo medido dura menos que un tic del reloj, puede obtener cero. Repita el trabajo suficientes veces para superar la resolución del reloj.

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

Presentación de resultados

Convierta la duración final a una unidad legible e imprímala. Mantenga visible el resultado consumido para que el optimizador no pueda eliminar el trabajo.

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

Comprobación rápida

Compruebe cuánto entiende de los problemas del benchmarking.

Resumen

Ha aprendido a medir el rendimiento del código con <chrono>:

capture steady_clock::now() antes y después, y luego reste los valores
elija una unidad adecuada con duration_cast
realice un calentamiento, calcule el promedio de varias ejecuciones y consuma los resultados para evitar la eliminación de código muerto
tenga en cuenta la resolución del reloj en cargas de trabajo pequeñas

A continuación, explorará los tipos de calendario y zona horaria de C++20.

Preguntas frecuentes

¿La lección «Medición del rendimiento del código» es gratis?

Sí — el texto completo de «Medición del rendimiento del código» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Medición del rendimiento del código»?

Compare el rendimiento con chrono Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Medición del rendimiento del código»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy