Dentang vs GCC - yang menghasilkan binari yang lebih baik? [Tutup]


238

Saat ini saya menggunakan GCC, tetapi saya menemukan Dentang baru-baru ini dan saya sedang mempertimbangkan untuk beralih. Ada satu faktor penentu - kualitas (kecepatan, jejak memori, keandalan) dari biner yang dihasilkannya - jika gcc -O3dapat menghasilkan biner yang berjalan 1% lebih cepat atau membutuhkan memori 1% lebih sedikit, itu adalah pemecah kesepakatan.

Clang menawarkan kecepatan kompilasi yang lebih baik dan jejak memori waktu kompilasi yang lebih rendah daripada GCC, tapi saya benar-benar tertarik pada tolok ukur / perbandingan dari perangkat lunak yang dikompilasi yang dihasilkan - bisakah Anda mengarahkan saya ke beberapa atau menggambarkan pengalaman Anda?


5
Sepertinya pertanyaan dan tanggapan yang berharga, dan banyak yang tertarik.
YasserAsmi

9
@YasserAsmi: Dan dua metrik - jejak memori dan kecepatan eksekusi - jauh dari sewenang-wenang atau tunduk pada "pendapat". Tetapi tampaknya penyakit Fisika. SE menyebar di sini dan orang-orang mulai memilih untuk menutup tanpa membaca detail teks pertanyaan di sini juga.
SF.

12
pertanyaannya meminta tolok ukur dan perbandingan, jawabannya memberikan keduanya ... mengapa pendapat ini bukannya perbandingan faktual?
oemb1905

2
Jangan lihat mengapa pertanyaan ini ditutup. Entah itu berdasarkan opini atau fakta, kami ingin mengetahui jawabannya, dan menandainya sebagai tertutup akan memberikan kesan negatif, di mana seharusnya tidak ada.
Timothy Makobu

2
@ TomZych: Jika Anda ingin mengetahui faktor-faktor ini, ajukan pertanyaan yang berbeda. Yang ini sangat spesifik dan tidak ambigu - meminta kecepatan eksekusi dan jejak memori. Anda mungkin tertarik pada faktor-faktor lain, baik untuk Anda, itu tidak berarti pertanyaan ini tidak valid, hanya saja tidak memenuhi minat pribadi Anda. Sepertinya Anda seorang programmer Java dan ingin menutup setiap pertanyaan C # karena itu tidak berbicara tentang Java.
SF.

Jawaban:


239

Berikut adalah beberapa penemuan terbaru meskipun sempit dari tambang dengan GCC 4.7.2 dan Dentang 3.2 untuk C ++.

UPDATE: GCC 4.8.1 v clang 3.3 perbandingan ditambahkan di bawah ini.

UPDATE: GCC 4.8.2 v clang 3.4 ditambahkan untuk itu.

Saya memelihara alat OSS yang dibangun untuk Linux dengan GCC dan Dentang, dan dengan kompiler Microsoft untuk Windows. Alat, coan, adalah preprocessor dan penganalisa file sumber C / C ++ dan kodelines seperti: jurusan profil komputasional pada penguraian dan penanganan file rekursi-keturunan. Cabang pengembangan (yang terkait dengan hasil ini) terdiri saat ini sekitar 11K LOC dalam sekitar 90 file. Ini dikodekan, sekarang, dalam C + + yang kaya akan polimorfisme dan templat dan tetapi masih terperosok dalam banyak tambalan oleh masa lalunya yang tidak terlalu jauh dalam peretasan bersama C. Semantik yang dipindahkan tidak dieksploitasi secara tegas. Ini single-threaded. Saya tidak mencurahkan upaya serius untuk mengoptimalkannya, sementara "arsitektur" sebagian besar tetap ToDo.

Saya menggunakan Clang sebelum 3.2 hanya sebagai kompiler eksperimental karena, terlepas dari kecepatan kompilasi yang superior dan diagnostik, dukungan standar C ++ 11 yang tertinggal versi GCC kontemporer dalam hal yang dilakukan oleh coan. Dengan 3.2, celah ini telah ditutup.

Linux harness test saya untuk proses pengembangan coan saat ini kira-kira 70K sumber file dalam campuran kasus parser satu-file, tes stres mengkonsumsi 1000-an file dan tes skenario mengkonsumsi <1K file. Selain melaporkan hasil pengujian, harness terakumulasi dan menampilkan total file yang dikonsumsi dan run time yang dikonsumsi dalam coan (itu hanya melewati setiap baris perintah coan ke timeperintah Linux dan menangkap dan menambahkan angka yang dilaporkan). Pengaturan waktu tersanjung oleh fakta bahwa sejumlah tes yang mengambil 0 waktu yang dapat diukur semuanya akan bertambah hingga 0, tetapi kontribusi tes tersebut dapat diabaikan. Statistik waktu ditampilkan di akhir make checkseperti ini:

coan_test_timer: info: coan processed 70844 input_files.
coan_test_timer: info: run time in coan: 16.4 secs.
coan_test_timer: info: Average processing time per input file: 0.000231 secs.

Saya membandingkan kinerja uji harness antara GCC 4.7.2 dan Dentang 3.2, semua hal sama kecuali kompiler. Pada Clang 3.2, saya tidak lagi memerlukan diferensiasi preprocessor antara traktat kode yang akan dikompilasi oleh GCC dan Clang alternatif. Saya membangun perpustakaan C ++ yang sama (GCC) di setiap kasus dan menjalankan semua perbandingan secara berurutan dalam sesi terminal yang sama.

Level optimalisasi standar untuk build rilis saya adalah -O2. Saya juga berhasil menguji build di -O3. Saya menguji setiap konfigurasi 3 kali back-to-back dan rata-rata 3 hasil, dengan hasil sebagai berikut. Angka dalam sel data adalah jumlah rata-rata mikrodetik yang dikonsumsi oleh coan yang dapat dieksekusi untuk memproses masing-masing file input ~ 70K (baca, parsing dan tulis output serta diagnostik).

          | -O2 | -O3 |O2/O3|
----------|-----|-----|-----|
GCC-4.7.2 | 231 | 237 |0.97 |
----------|-----|-----|-----|
Clang-3.2 | 234 | 186 |1.25 |
----------|-----|-----|------
GCC/Clang |0.99 | 1.27|

Setiap aplikasi tertentu sangat mungkin memiliki sifat-sifat yang bermain secara tidak adil terhadap kekuatan atau kelemahan kompiler. Benchmarking yang ketat menggunakan beragam aplikasi. Dengan mengingat hal itu, fitur penting dari data ini adalah:

  1. Optimasi -O3 sedikit merugikan GCC
  2. -O3 optimasi penting bermanfaat bagi Dentang
  3. Pada optimasi -O2, GCC lebih cepat daripada Dentang hanya dengan kumis
  4. Pada optimasi -O3, Dentang penting lebih cepat daripada GCC.

Perbandingan lebih lanjut yang menarik dari kedua penyusun muncul secara tidak sengaja setelah penemuan-penemuan itu. Coan secara bebas menggunakan pointer pintar dan satu seperti itu banyak dilakukan dalam penanganan file. Tipe smart-pointer khusus ini telah diketik dalam rilis sebelumnya demi diferensiasi kompiler, menjadi std::unique_ptr<X>jika kompiler yang dikonfigurasi memiliki dukungan yang cukup matang untuk penggunaannya seperti itu, dan sebaliknya std::shared_ptr<X>. Bias untuk std::unique_ptrmenjadi bodoh, karena pointer ini sebenarnya ditransfer sekitar, tetapi std::unique_ptrtampak seperti opsi yang lebih bugar untuk mengganti std::auto_ptrpada titik ketika varian C ++ 11 baru bagi saya.

Dalam proses pembuatan eksperimental untuk mengukur kebutuhan Clang 3.2 yang terus-menerus untuk diferensiasi ini dan yang serupa, saya secara tidak sengaja membangun std::shared_ptr<X>ketika saya bermaksud membangun std::unique_ptr<X>, dan terkejut melihat bahwa hasil yang dapat dieksekusi, dengan standar -O2 optimasi, adalah yang tercepat telah melihat, terkadang mencapai 184 msecs. per file input. Dengan satu perubahan pada kode sumber, hasil yang sesuai adalah ini;

          | -O2 | -O3 |O2/O3|
----------|-----|-----|-----|
GCC-4.7.2 | 234 | 234 |1.00 |
----------|-----|-----|-----|
Clang-3.2 | 188 | 187 |1.00 |
----------|-----|-----|------
GCC/Clang |1.24 |1.25 |

Poin-poin yang perlu diperhatikan di sini adalah:

  1. Kompiler sekarang tidak mendapat manfaat sama sekali dari -O3 optimasi.
  2. Dentang mengalahkan GCC sama pentingnya pada setiap tingkat optimasi.
  3. Kinerja GCC hanya sedikit terpengaruh oleh perubahan tipe smart-pointer.
  4. Kinerja-O2 dentang penting dipengaruhi oleh perubahan tipe smart-pointer.

Sebelum dan setelah perubahan tipe smart-pointer, Clang dapat membangun eksekusi yang jauh lebih cepat pada optimasi -O3, dan itu dapat membangun eksekusi yang sama cepatnya pada -O2 dan -O3 ketika pointer-type itu yang terbaik - std::shared_ptr<X>- untuk pekerjaan.

Sebuah pertanyaan yang jelas bahwa saya tidak kompeten untuk mengomentari adalah mengapa Dentang harus dapat menemukan 25% -O2 percepatan dalam aplikasi saya ketika tipe smart-pointer yang banyak digunakan berubah dari unik ke berbagi, sedangkan GCC acuh tak acuh untuk perubahan yang sama. Saya juga tidak tahu apakah saya harus menghibur atau mencemooh penemuan bahwa optimasi-O2 Clang memiliki sensitivitas yang sangat besar terhadap kebijaksanaan pilihan smart-pointer saya.

PEMBARUAN: GCC 4.8.1 v dentang 3.3

Hasil yang sesuai sekarang adalah:

          | -O2 | -O3 |O2/O3|
----------|-----|-----|-----|
GCC-4.8.1 | 442 | 443 |1.00 |
----------|-----|-----|-----|
Clang-3.3 | 374 | 370 |1.01 |
----------|-----|-----|------
GCC/Clang |1.18 |1.20 |

Fakta bahwa keempat executable sekarang mengambil waktu rata-rata yang jauh lebih besar daripada sebelumnya untuk memproses 1 file tidak mencerminkan kinerja kompiler terbaru. Hal ini disebabkan oleh fakta bahwa cabang pengembangan selanjutnya dari aplikasi pengujian telah mengambil banyak kecanggihan parsing sementara itu dan membayarnya dengan cepat. Hanya rasio yang signifikan.

Poin-poin penting sekarang bukan novel baru:

  • GCC tidak peduli dengan optimasi -O3
  • Dentang manfaat sangat sedikit dari optimasi -O3
  • Dentang mengalahkan GCC dengan margin yang sama pentingnya pada setiap tingkat optimasi.

Membandingkan hasil ini dengan yang untuk GCC 4.7.2 dan clang 3.2, menonjol bahwa GCC telah mencabut kembali sekitar seperempat dari lead clang di setiap tingkat optimasi. Tetapi karena aplikasi pengujian telah banyak dikembangkan untuk sementara waktu, seseorang tidak dapat dengan yakin menghubungkan ini dengan ketertinggalan dalam pembuatan kode GCC. (Kali ini, saya telah mencatat snapshot aplikasi dari mana timing diperoleh dan dapat menggunakannya lagi.)

PEMBARUAN: GCC 4.8.2 v dentang 3.4

Saya menyelesaikan pembaruan untuk GCC 4.8.1 v Dentang 3.3 mengatakan bahwa saya akan tetap menggunakan coan snaphot yang sama untuk pembaruan lebih lanjut. Tetapi saya memutuskan untuk menguji snapshot itu (rev. 301) dan snapshot pengembangan terbaru yang saya miliki melewati test suite-nya (rev. 619). Ini memberikan hasil sedikit bujur, dan saya punya motif lain:

Posting asli saya mencatat bahwa saya tidak mencurahkan upaya untuk mengoptimalkan kecepatan untuk coan. Ini masih terjadi pada rev. 301. Namun, setelah saya membuat aparatus timing ke dalam harness test coan, setiap kali saya menjalankan test suite dampak kinerja dari perubahan terbaru menatap wajah saya. Saya melihat bahwa itu seringkali luar biasa besar dan trennya lebih negatif daripada yang saya rasakan layaknya keuntungan dalam fungsionalitas.

Oleh rev. 308 waktu pemrosesan rata-rata per file input dalam test suite telah lebih dari dua kali lipat sejak posting pertama di sini. Pada saat itu saya mengubah kebijakan 10 tahun saya yang tidak mengganggu kinerja. Dalam serangkaian revisi intensif hingga 619, kinerja selalu menjadi pertimbangan dan sebagian besar dari mereka murni untuk menulis ulang pembawa beban utama pada saluran yang secara fundamental lebih cepat (walaupun tanpa menggunakan fitur kompiler non-standar untuk melakukannya). Akan menarik untuk melihat reaksi masing-masing kompiler terhadap putaran U ini,

Ini adalah matriks timing yang sekarang sudah umum untuk versi build dua kompiler terbaru dari rev.301:

coan - rev.301 hasil

          | -O2 | -O3 |O2/O3|
----------|-----|-----|-----|
GCC-4.8.2 | 428 | 428 |1.00 |
----------|-----|-----|-----|
Clang-3.4 | 390 | 365 |1.07 |
----------|-----|-----|------
GCC/Clang | 1.1 | 1.17|

Kisah di sini hanya sedikit berubah dari GCC-4.8.1 dan Clang-3.3. Pertunjukan GCC sedikit lebih baik. Dentang sedikit lebih buruk. Kebisingan bisa menjelaskan ini. Dentang masih keluar di depan -O2dan -O3margin yang tidak penting di sebagian besar aplikasi tetapi akan penting bagi beberapa.

Dan di sini adalah matriks untuk rev. 619.

coan - rev.619 hasil

          | -O2 | -O3 |O2/O3|
----------|-----|-----|-----|
GCC-4.8.2 | 210 | 208 |1.01 |
----------|-----|-----|-----|
Clang-3.4 | 252 | 250 |1.01 |
----------|-----|-----|------
GCC/Clang |0.83 | 0.83|

Mengambil angka 301 dan 619 berdampingan, beberapa poin berbicara.

  • Saya bertujuan untuk menulis kode lebih cepat, dan kedua kompiler dengan tegas membenarkan upaya saya. Tapi:

  • GCC membayar upaya itu jauh lebih murah daripada Dentang. Pada -O2 optimasi, Clang 619 build adalah 46% lebih cepat daripada build 301: pada -O3peningkatan Clang adalah 31%. Bagus, tetapi pada setiap level optimisasi GCC 619 build lebih dari dua kali lebih cepat dari 301.

  • GCC lebih dari membalikkan keunggulan mantan Clang. Dan pada setiap level optimasi, GCC sekarang mengalahkan Dentang sebesar 17%.

  • Kemampuan dentang di 301 membangun untuk mendapatkan lebih banyak leverage daripada GCC dari -O3optimasi hilang di build 619. Tidak ada kompiler yang memperoleh manfaat dari -O3.

Saya cukup terkejut dengan pembalikan nasib ini yang saya kira saya mungkin secara tidak sengaja membuat bangunan lamban dari dentang 3.4 itu sendiri (karena saya membangunnya dari sumber). Jadi saya menjalankan kembali tes 619 dengan stok distro saya, Dentang 3.3. Hasilnya praktis sama dengan untuk 3.4.

Jadi mengenai reaksi terhadap putar-U: Pada angka-angka di sini, Clang telah melakukan jauh lebih baik daripada GCC pada kecepatan perasutan dari kode C ++ saya ketika saya tidak memberikan bantuan. Ketika saya berusaha membantu, GCC melakukan pekerjaan yang jauh lebih baik daripada Dentang.

Saya tidak mengangkat pengamatan itu menjadi sebuah prinsip, tetapi saya mengambil pelajaran bahwa "Kompiler mana yang menghasilkan biner yang lebih baik?" adalah pertanyaan yang, bahkan jika Anda menentukan suite tes yang jawabannya relatif, masih bukan masalah yang jelas hanya menentukan waktu binari.

Apakah biner Anda yang lebih baik biner tercepat, atau apakah itu yang terbaik mengkompensasi kode yang dibuat murah? Atau kompensasi terbaik untuk kode yang dibuat mahal yang memprioritaskan perawatan dan penggunaan kembali melebihi kecepatan? Tergantung pada sifat dan bobot relatif dari motif Anda untuk menghasilkan biner, dan kendala yang Anda gunakan.

Dan dalam hal apa pun, jika Anda sangat peduli dalam membangun biner "yang terbaik" maka Anda sebaiknya terus memeriksa bagaimana iterasi beruntun dari kompiler mewujudkan ide Anda tentang "yang terbaik" daripada iterasi berurutan dari kode Anda.


9
mengapa dentang lebih cepat? misalnya, kompiler intel menggunakan spesialisasi chip intel. apa yang menggunakan dentang untuk mendapatkan keuntungan? dapatkah kode ditulis ulang sehingga gcc memiliki kinerja yang sama?
kirill_igum

27
@krill_igum GCC dan dentang adalah program yang berbeda (sangat rumit) yang ditulis oleh kelompok pemrogram yang berbeda untuk melakukan pekerjaan yang sama: menerjemahkan kode sumber ke dalam kode objek. Hampir tidak dapat dihindari bahwa salah satu dari mereka akan melakukan pekerjaan itu secara terukur lebih baik daripada yang lain dalam setiap tes yang dipilih pada suatu titik waktu. Tidak harus ada "hal" khusus yang pemenang "gunakan" untuk "mendapatkan keuntungan", dan karena kedua program bersifat open-source, mereka tidak memiliki rahasia satu sama lain.
Mike Kinghan

3
Dimungkinkan untuk menggunakan kcachegrinduntuk menunjukkan fungsi-fungsi di mana kinerja executable berbeda dalam kinerja.

4
-1: Ini lebih merupakan novel (atau posting blog) daripada jawaban.
John Saunders

60
@JohnSaunders: Apa yang bagi satu orang merupakan jawaban yang terperinci dan mendalam, bagi yang lain adalah novel yang tidak layak diperhatikan. Katakan apa yang membedakan kedua orang ini.
SF.

48

Phoronix melakukan beberapa tolok ukur tentang ini, tetapi ini tentang versi snapshot dari Dentang / LLVM dari beberapa bulan yang lalu. Hasilnya adalah hal-hal yang lebih atau kurang dorongan; baik GCC maupun Dentang secara definitif lebih baik dalam semua kasus.

Karena Anda akan menggunakan dentang terbaru, itu mungkin sedikit kurang relevan. Kemudian lagi, GCC 4.6 dijadwalkan untuk memiliki beberapa optimasi utama untuk Core 2 dan i7, rupanya.

Saya pikir kecepatan kompilasi Clang yang lebih cepat akan lebih baik untuk pengembang asli, dan kemudian ketika Anda mendorong kode keluar ke dunia, distro Linux / BSD / dll. pengguna akhir akan menggunakan GCC untuk binari yang lebih cepat.


2
Hanya hari ini saya menjalankan beberapa tolok ukur pada kecepatan kompilasi dentang dan itu sangat mengecewakan untuk C. murni. Mengkompilasi 35 file C dengan 270 KLOC dentang hanya 25% lebih cepat. Ketika saya melihat seberapa cepat tinycc di linux itu adalah hasil yang buruk untuk kompiler tertulis baru. Itu menjadi lebih baik ketika menggunakan optimasi -O2 / -O3 tetapi karena mereka digunakan untuk rilis membangun kinerja kompiler tidak masalah dalam kasus ini.
Lothar

7
@mcandre Mungkin Nietzche-jou dikompilasi dengan Dentang, sedangkan Anda dikompilasi dengan GCC.
Mateen Ulhaq

18

Fakta bahwa Clang mengkompilasi kode lebih cepat mungkin tidak sepenting kecepatan biner yang dihasilkan. Namun, berikut adalah serangkaian tolok ukur .


12
Sebenarnya itu benar. Selama pengembangan, waktu kompilasi (dan konsumsi sumber daya karena kompilasi) jauh lebih menghambat daripada kinerja biner. Bagaimanapun, kami mengkompilasi dalam mode Debug pada tahap ini. Hanya ketika tiba saatnya untuk menguji dan mengirim Anda beralih ke mode Rilis dan mencoba untuk mendapatkan biner secepat mungkin.
Matthieu M.

3
@ Matthieu M: Saya bersumpah jawaban itu mengatakan "mungkin ..", seolah-olah dia mengemukakan kekhawatiran potensial. Saya kira mungkin itu layak disebutkan karena itu, Anda tahu, terkait dengan OP.
JM Becker

Setuju, meskipun semua poin bagus di sini. Saya lebih suka melempar drive RAID 0 ke-2 atau ke-3, SSD, atau lebih banyak & lebih cepat RAM dan mendapatkan kinerja .exe terbaik - asalkan ukuran tersebut dapat membuat Anda paritas atau tutup. Terkadang juga membantu untuk mengembangkan dengan lebih dari satu kompiler. Ini dapat membuat Anda mengetahui fitur-fitur non-portabel, DAN menangkap kesalahan yang jika tidak terdeteksi, atau mengakibatkan berhari-hari waktu terbuang mencoba men-debug kode yang akan diperingatkan / dibuat salah oleh kompiler.

Saya mencoba hari ini membandingkan beberapa kode integer kritis kinerja ketat yang saya tulis dan GCC berlari jauh lebih cepat (22S clang-llvm 25S) menggunakan keduanya -O2 & -O3. Pikirkan menggunakan sakelar kompiler (gcc atau dentang) mencakup sebagian besar fitur non-standar dan peringatan statis. Dalam proyek besar Anda sendiri, bukan mengompilasi batch kode ppl lain, Anda melakukan sesuatu yang salah dalam sistem build Anda jika waktu kompilasi mendominasi waktu tautan. Ada alat seperti ccache.samba.org yang membantu jika Anda sering membersihkannya. Masalah lain dengan mengubah kompiler, adalah semua investasi waktu dalam pengujian / validasi yang dibuang.
Rob11311

code.google.com/p/distcc adalah proyek lain yang dapat mempercepat waktu kompilasi massal, jika seluruh perpustakaan perlu dikompilasi ulang karena perubahan struktur data atau untuk keperluan verifikasi / validasi
Rob11311

11

Ada sangat sedikit perbedaan keseluruhan antara GCC 4.8 dan dentang 3.3 dalam hal kecepatan biner yang dihasilkan. Dalam kebanyakan kasus, kode yang dihasilkan oleh kedua kompiler berkinerja sama. Tak satu pun dari kedua kompiler ini mendominasi yang lain.

Benchmark mengatakan bahwa ada perbedaan kinerja yang signifikan antara GCC dan dentang adalah kebetulan.

Kinerja program dipengaruhi oleh pilihan kompiler. Jika pengembang atau sekelompok pengembang secara eksklusif menggunakan GCC maka program dapat diharapkan berjalan sedikit lebih cepat dengan GCC daripada dengan dentang, dan sebaliknya.

Dari sudut pandang pengembang, perbedaan penting antara GCC 4.8+ dan dentang 3.3 adalah bahwa GCC memiliki -Ogopsi baris perintah. Opsi ini memungkinkan optimasi yang tidak mengganggu debugging, jadi misalnya selalu memungkinkan untuk mendapatkan jejak stack yang akurat. Tidak adanya opsi ini dalam dentang membuat dentang lebih sulit untuk digunakan sebagai kompilator pengoptimal untuk beberapa pengembang.


Akhir-akhir ini, (3.3 dan 4.8) saya tidak melihat banyak perbedaan antara waktu kompilasi. (dalam program "saya" dengan waktu kompilasi antara 10 detik dan 30 detik).
alfC

9

Satu-satunya cara untuk menentukan ini adalah dengan mencobanya. FWIW Saya telah melihat beberapa peningkatan yang sangat baik menggunakan Apple LLVM gcc 4.2 dibandingkan dengan 4.2 gcc biasa (untuk kode x86-64 dengan SSE yang cukup banyak), tetapi YMMV untuk basis kode yang berbeda. Dengan asumsi Anda bekerja dengan x86 / x86-64 dan Anda benar-benar peduli dengan beberapa persen terakhir maka Anda harus mencoba Intel ICC juga, karena ini sering mengalahkan gcc - Anda bisa mendapatkan lisensi evaluasi 30 hari dari intel.com dan coba itu.


8

Perbedaan aneh yang saya catat pada gcc 5.2.1 dan clang 3.6.2 adalah bahwa jika Anda memiliki loop kritis seperti:

for (;;) {
    if (!visited) {
        ....
    }
    node++;
    if (!*node) break;
  }

Maka gcc akan, ketika mengkompilasi dengan -O3atau -O2, membuka gulungan secara spekulatif delapan kali. Dentang tidak akan membuka gulungannya sama sekali. Melalui trial and error saya menemukan bahwa dalam kasus khusus saya dengan data program saya, jumlah yang tepat membuka gulungan adalah lima sehingga gcc melampaui dan bergantung undershot. Namun, overshotting lebih merusak kinerja sehingga gcc tampil jauh lebih buruk di sini.

Saya tidak tahu apakah perbedaan membuka gulungan adalah tren umum atau hanya sesuatu yang khusus untuk skenario saya.

Beberapa waktu yang lalu saya menulis beberapa pengumpul sampah untuk belajar lebih banyak tentang pengoptimalan kinerja dalam C. Dan hasil yang saya dapatkan ada dalam pikiran saya untuk sedikit menyukai dentang. Terutama karena pengumpulan sampah sebagian besar tentang pengejaran pointer dan menyalin memori.

Hasilnya adalah (angka dalam detik):

+---------------------+-----+-----+
|Type                 |GCC  |Clang|
+---------------------+-----+-----+
|Copying GC           |22.46|22.55|
|Copying GC, optimized|22.01|20.22|
|Mark & Sweep         | 8.72| 8.38|
|Ref Counting/Cycles  |15.14|14.49|
|Ref Counting/Plain   | 9.94| 9.32|
+---------------------+-----+-----+

Ini semua kode C murni dan saya tidak membuat klaim tentang kinerja kompiler ketika mengkompilasi kode C ++.

Di Ubuntu 15.10, x86.64, dan prosesor AMD Phenom (tm) II X6 1090T.


Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.