Kecepatan kompilasi Rust yang lebih cepat melalui frontend paralel di versi nightly

Kompilasi lebih cepat dengan frontend paralel pada kompiler Rust

• Frontend kompiler Rust kini dapat sangat mengurangi waktu kompilasi dengan menggunakan eksekusi paralel.
• Frontend paralel adalah fitur eksperimental, dan dapat dicoba di kompiler nightly dengan opsi -Z threads=8.
• Fitur ini direncanakan akan dirilis di kompiler stabil pada 2024.

Waktu kompilasi dan paralelisme

• Waktu kompilasi Rust terus menjadi perhatian, dan working group performa kompiler telah secara konsisten meningkatkan performa kompiler selama beberapa tahun.
• Dalam 10 bulan pertama tahun 2023, waktu kompilasi rata-rata turun 13%, penggunaan memori 15%, dan ukuran biner 7%.
• Kompiler sudah sangat dioptimalkan sehingga makin sulit menemukan peningkatan baru, dan paralelisme tetap menjadi peningkatan besar namun menantang.

Paralelisme antarproses yang sudah ada

• Saat mengompilasi program Rust, Cargo menjalankan beberapa proses rustc secara paralel untuk mengompilasi banyak crate.
• Eksekusi paralel bekerja baik saat dependensi antarkrate sedikit, tetapi akan berkurang ketika dependensi meningkat.

Paralelisme dalam proses yang sudah ada: backend

• Kompiler dibagi menjadi frontend dan backend; backend bertugas menghasilkan kode, dan LLVM sudah menanganinya secara paralel.
• Frontend melakukan parsing, type checking, dan lainnya, tetapi hingga minggu ini belum dapat menggunakan eksekusi paralel.

Paralelisme dalam proses yang baru: frontend

• Frontend kini dapat melakukan pekerjaan kompilasi dengan paralelisme yang lebih halus menggunakan Rayon.
• Saat frontend paralel diaktifkan dan disetel menggunakan 8 thread, waktu eksekusi frontend dapat berkurang secara signifikan.

Penggabungan secara keseluruhan

• Kompilasi Rust sudah lama mendapat manfaat dari paralelisme antarproses melalui Cargo dan paralelisme dalam proses di backend, dan kini juga bisa mendapat manfaat dari paralelisme dalam proses di frontend.
• Kompiler menggunakan protokol jobserver untuk membatasi jumlah thread yang dibuat agar tidak melebihi jumlah core.

Cara penggunaan

• Kompiler nightly dirilis dengan frontend paralel yang sudah diaktifkan, tetapi secara default berjalan dalam mode single-thread.
• Pengguna dapat beralih ke mode multithread dengan opsi -Z threads.

Dampak performa

• Menjalankan frontend paralel dalam mode single-thread dapat membuat waktu kompilasi 0% hingga 2% lebih lambat dibanding sebelumnya.
• Dalam mode multithread, waktu kompilasi dapat berkurang hingga 50%, tetapi efeknya bervariasi tergantung karakteristik kode dan konfigurasi build.

Ketepatan

• Dalam mode single-thread, keandalannya diperkirakan tinggi.
• Dalam mode multithread, mungkin masih ada bug dan deadlock yang sudah diketahui, dan biner yang dihasilkan kompiler seharusnya sama apa pun frontend yang digunakan.

Umpan balik

• Jika ada masalah pada frontend paralel, Anda dapat memeriksa issue berlabel "WG-compiler-parallel" dan mengajukan issue baru.

Pekerjaan selanjutnya

• Pekerjaan untuk meningkatkan performa frontend paralel dan memperbaiki bug pada mode multithread sedang berlangsung.
• Pada 2024, ada rencana untuk menstabilkan opsi -Z threads agar rilisan stabil berjalan dalam mode multithread secara default.

Opini GN⁺

Poin terpenting dari artikel ini adalah bahwa frontend kompiler Rust kini mendukung eksekusi paralel sehingga dapat secara signifikan memangkas waktu kompilasi. Ini memberi manfaat besar bagi developer Rust berupa kecepatan kompilasi yang lebih baik, sekaligus membantu menciptakan lingkungan pengembangan yang lebih efisien. Kehadiran frontend paralel adalah kabar menarik bagi komunitas Rust dan dapat dilihat sebagai hasil dari upaya berkelanjutan untuk meningkatkan performa.

[GN⁺]

Komentar Hacker News

• Harapan terhadap peningkatan kecepatan kompilasi Rust
  • Kecepatan kompilasi Rust yang lambat sering disebut sebagai kekurangan, terutama saat bekerja pada repositori besar karena dapat meningkatkan biaya CI/CD dan memperlambat waktu pengembangan. Masalah ini terasa lebih parah ketika cache harus dihapus (yang kadang terjadi karena bug Docker). Ada tanggapan positif terhadap kemajuan ini.
• Pengalaman pribadi tentang kecepatan kompilasi Rust
  • Saat menggunakan Rust sejak lama, kecepatan kompilasinya terasa lambat, tetapi setelah kembali memakainya belakangan ini, waktu kompilasi hampir tidak lagi menjadi perhatian. Namun, ketika proyek membesar, jeda kompilasi mulai terasa, sehingga perbaikan seperti ini merupakan kabar yang sangat disambut secara pribadi.
• Pertanyaan tentang proses kompilasi Rust
  • Ada pertanyaan apakah backend Rust harus menunggu frontend menyelesaikan borrow checking sebelum mulai bekerja. Muncul dugaan bahwa jika backend bisa menemukan error borrow checking, mungkin pekerjaan spekulatif yang tidak perlu bisa dibuang.
• Pengamatan tentang kompilasi crate biner Rust
  • Berbeda dari crate pustaka, crate biner cenderung besar dan berstruktur tunggal secara default, sehingga kompilasinya tidak terparalelkan dan crate terbesar cenderung terserialisasi. Perbaikan terhadap masalah ini sangat disambut.
• Pertanyaan tentang pemanfaatan core CPU
  • Ada pertanyaan apakah jumlah core CPU saat kompilasi bisa digunakan secara otomatis, atau harus menetapkan nilai tetap dalam file konfigurasi yang juga dipakai di mesin lain.
• Peringatan tentang bug pada mode multithread
  • Ada bug dan deadlock yang sudah diketahui pada mode multithread, jadi jika kompilasi macet, kemungkinan mengalami salah satu masalah tersebut. Sikap terhadap penggunaan opsi -Z threads pun menjadi hati-hati.
• Penilaian positif terhadap kondisi terkini kecepatan kompilasi Rust
  • Setelah tidak memakai Rust selama beberapa tahun lalu mencobanya lagi belakangan ini, kecepatan kompilasinya terasa hampir seketika. Dengan alat seperti ChatGPT, masalah Rust yang dulu sulit dipecahkan kini bisa diselesaikan dengan mudah, sehingga kondisi saat ini dinilai sangat baik.
• Keraguan tentang arah optimasi kompilasi Rust
  • Ada kekhawatiran bahwa kompilasi Rust sudah sangat terparalelkan pada tingkat file, sehingga mempercepat kompilasi satu file justru bisa mengambil sumber daya dari paralelisme file tingkat lebih tinggi. Masalahnya, tidak ada data konkret mengenai hal ini.
• Komentar yang menyambut baik peningkatan kecepatan kompilasi Rust