C++ Academy · Pelajaran

Mengukur Prestasi Kod

Lakukan penanda aras dengan chrono

Pelajaran 3 daripada 413 langkah

Mengukur Prestasi Kod ialah pelajaran C++ Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran C++ Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Mengapa Menanda Aras?

Mengukur tempoh kod berjalan membantu anda mencari kesesakan prestasi dan mengesahkan pengoptimuman. Dengan <chrono>, anda mendapat pengukuran masa yang mudah alih dan selamat dari segi jenis.

Ukur sebelum mengoptimumkan.
Gunakan jam yang stabil untuk mendapatkan selang masa yang boleh dipercayai.

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

Corak Asas

Corak penandaarasan sentiasa sama: tangkap now() sebelum kerja bermula, jalankannya, tangkap now() selepas selesai, kemudian tolak kedua-duanya.

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

Memilih Unit

Pilih unit yang sesuai dengan beban kerja. Gunakan microseconds atau nanoseconds untuk gelung pantas dan milliseconds untuk tugas yang lebih besar.

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

Pengukuran Masa Titik Terapung

Untuk mendapatkan saat yang mudah dibaca manusia dengan nilai pecahan, gunakan duration<double> supaya ketepatan bawah satu saat dapat dikekalkan.

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

Pemasa Boleh Guna Semula

Bungkus corak ini dalam pembantu kecil supaya anda boleh mengukur masa bagi sebarang fungsi yang boleh dipanggil dengan kemas tanpa mengulangi kod.

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

Elakkan Penghapusan Kod Mati

Pengkompil mungkin membuang kerja yang hasilnya tidak digunakan, sekali gus merosakkan penandaarasan. Sentiasa gunakan hasilnya, contohnya dengan mencetaknya atau mengumpulkannya ke dalam pemboleh ubah yang boleh diperhatikan.

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

Larian Pemanasan

Larian pertama mungkin lebih perlahan disebabkan oleh cache dan pemulaan malas. Lakukan larian pemanasan sebelum mengukur untuk mendapatkan nombor yang lebih stabil.

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

Memuratakan Berbilang Larian

Satu pengukuran boleh dipengaruhi hingar. Jalankan kerja itu banyak kali, jumlahkan tempoh yang berlalu, kemudian bahagikan untuk mendapatkan purata yang stabil.

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

Membandingkan Dua Pendekatan

Penandaarasan sangat berguna apabila membandingkan pelaksanaan. Ukur masa setiap pelaksanaan dengan cara yang sama dan bandingkan tempoh yang terhasil.

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

Berhati-hati dengan Resolusi

Jika kerja yang diukur lebih singkat daripada satu detik jam, Anda mungkin membaca sifar. Ulangi kerja itu secukupnya supaya melebihi resolusi jam.

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

Melaporkan Keputusan

Tukarkan tempoh akhir kepada unit yang mudah dibaca dan cetakkannya. Pastikan hasil yang digunakan kekal kelihatan supaya pengoptimum tidak membuang kerja tersebut.

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

Semakan Pantas

Uji pemahaman Anda tentang perangkap penandaarasan.

Jawab dalam pelajaran interaktif

Ulang Kaji

Anda telah mempelajari cara menanda aras kod dengan <chrono>:

ambil steady_clock::now() sebelum dan selepas, kemudian tolak kedua-duanya
pilih unit yang sesuai dengan duration_cast
panaskan kod, puratakan beberapa pelaksanaan dan gunakan hasil untuk menghalang penghapusan kod mati
berhati-hati dengan resolusi jam untuk beban kerja yang sangat kecil

Seterusnya, Anda akan meneroka jenis kalendar dan zon waktu C++20.

Percuma untuk bermula

Pelajari C++ dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 51
Pelajaran: 203

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengukur Prestasi Kod” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran C++ Academy, termasuk “Mengukur Prestasi Kod”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengukur Prestasi Kod”?

Lakukan penanda aras dengan chrono Anda berlatih C++ Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan C++ Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran C++ Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Mengukur Prestasi Kod” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy