0Pricing
C++ Academy · Pelajaran

Mengukur Performa Kode

Lakukan benchmark dengan chrono

Mengukur Performa Kode adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Mengapa Mengukur Kinerja?

Mengukur berapa lama kode berjalan membantu Anda menemukan hambatan kinerja dan memverifikasi pengoptimalan. Dengan <chrono>, Anda mendapatkan pengukuran waktu yang portabel dan aman tipe.

  • Lakukan pengukuran sebelum mengoptimalkan.
  • Gunakan jam yang stabil untuk interval yang andal.
#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;
}

Pola Dasar

Pola pengukuran kinerja selalu sama: ambil now() sebelum pekerjaan, jalankan pekerjaan tersebut, ambil now() setelahnya, lalu kurangkan.

#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 Satuan

Pilih satuan yang sesuai dengan beban kerja. Gunakan microseconds atau nanoseconds untuk perulangan cepat, 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 Waktu Titik Mengambang

Untuk menampilkan detik yang mudah dibaca manusia beserta pecahannya, gunakan duration<double> agar presisi di bawah satu detik tetap dipertahankan.

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

Pengukur Waktu yang Dapat Digunakan Kembali

Bungkus pola tersebut dalam pembantu kecil agar Anda dapat mengukur waktu objek apa pun yang dapat dipanggil dengan rapi dan tidak perlu mengulangi kode.

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

Hindari Penghapusan Kode Mati

Kompilator dapat menghapus pekerjaan yang hasilnya tidak digunakan, sehingga merusak pengukuran kinerja. Selalu gunakan hasilnya, misalnya dengan mencetaknya atau mengakumulasikannya ke dalam variabel yang dapat diamati.

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

Proses Pemanasan

Proses pertama dapat berjalan lebih lambat karena cache dan inisialisasi lambat. Lakukan satu proses pemanasan sebelum mengukur agar hasilnya 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;
}

Merata-ratakan Beberapa Proses

Satu pengukuran dapat menghasilkan angka yang tidak stabil. Jalankan pekerjaan tersebut berkali-kali, jumlahkan durasi yang telah berlalu, lalu bagi untuk mendapatkan rata-rata 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

Pembandingan kinerja sangat bermanfaat saat membandingkan implementasi. Ukur waktu masing-masing dengan cara yang sama, lalu bandingkan durasi yang dihasilkan.

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

Waspadai Resolusi

Jika pekerjaan yang diukur lebih singkat daripada satu detak jam, Anda mungkin membaca nol. Ulangi pekerjaan tersebut cukup banyak hingga melampaui 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 Hasil

Konversikan durasi akhir ke satuan yang mudah dibaca, lalu cetak hasilnya. Biarkan hasil yang digunakan tetap terlihat agar pengoptimal tidak dapat menghapus pekerjaan 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;
}

Uji Cepat

Uji pemahaman Anda tentang jebakan pembandingan kinerja.

Rangkuman

Anda telah mempelajari cara melakukan pembandingan kinerja kode dengan <chrono>:

  • ambil steady_clock::now() sebelum dan sesudah, lalu kurangkan hasilnya
  • pilih satuan yang sesuai dengan duration_cast
  • lakukan pemanasan, hitung rata-rata beberapa proses, dan gunakan hasilnya untuk mencegah eliminasi kode mati
  • waspadai resolusi jam pada beban kerja yang sangat kecil

Selanjutnya, Anda akan menjelajahi tipe kalender dan zona waktu C++20.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengukur Performa Kode” gratis?

Ya — teks lengkap “Mengukur Performa Kode” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengukur Performa Kode”?

Lakukan benchmark dengan chrono Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Mengukur Performa Kode” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Durasi dan Jam
  2. Titik Waktu
  3. Mengukur Performa Kode
  4. Kalender dan Zona Waktu
← Kembali ke C++ Academy