Berapa banyak upaya yang harus kita keluarkan untuk pemrograman beberapa inti?

Prosesor semakin banyak inti hari ini, yang membuat saya bertanya-tanya ...

Haruskah kita, programmer, beradaptasi dengan perilaku ini dan menghabiskan lebih banyak upaya pada pemrograman untuk banyak core?

Sejauh mana kita harus melakukan dan mengoptimalkan ini? Benang? Afinitas? Optimalisasi perangkat keras? Sesuatu yang lain

Tidak peduli seberapa baik Anda, tidak mungkin Anda akan memiliki skema pengelolaan utas yang lebih baik, dll. Daripada tim yang mengembangkan bahasa dan kompiler tempat Anda menulis kode.

Jika Anda membutuhkan aplikasi Anda untuk multi-threaded kemudian buat utas yang Anda butuhkan dan biarkan kompiler dan OS melanjutkan pekerjaan mereka.

Anda perlu mengetahui cara pengelolaan thread tersebut sehingga Anda dapat menggunakan sumber daya sebaik mungkin. Tidak membuat terlalu banyak utas adalah satu hal yang muncul di benak sebagai contoh.

Anda juga perlu menyadari apa yang sedang terjadi (lihat komentar Lorenzo) sehingga Anda dapat memberikan petunjuk kepada manajemen utas (atau menimpanya dalam kasus-kasus khusus), tetapi saya akan berpikir bahwa ini akan menjadi sedikit dan jauh antara.

Saya seorang programmer. NET, dan saya tahu bahwa .NET memiliki abstraksi tingkat tinggi untuk multithreading yang disebut Tugas. Ini melindungi Anda dari keharusan mengetahui terlalu banyak tentang cara melakukan multithreading dengan benar terhadap logam. Saya berasumsi bahwa platform pengembangan lain saat ini memiliki abstraksi serupa. Jadi jika Anda akan melakukan apa saja dengan multithreading, saya akan mencoba bekerja pada level itu jika memungkinkan.

Sekarang, untuk pertanyaan apakah Anda harus peduli tentang multithreading di aplikasi khusus Anda. Jawaban atas pertanyaan itu sangat tergantung pada aplikasi yang Anda tulis. Jika Anda menulis aplikasi yang memproses ribuan (atau lebih) hal independen, dan pemrosesan ini dapat dilakukan secara paralel, maka Anda hampir pasti akan mendapatkan keuntungan dari multithreading. Namun, jika Anda menulis layar entri data yang sederhana, multithreading mungkin tidak akan banyak memberi Anda.

Paling tidak, Anda harus khawatir dengan multithreading ketika Anda bekerja pada UI. Anda tidak ingin menjalankan operasi yang berjalan lama dari UI dan membuatnya menjadi tidak responsif karena Anda membajak utas UI untuk melakukan operasi itu. Matikan utas latar belakang, dan setidaknya berikan pengguna tombol Batalkan sehingga mereka tidak harus menunggu sampai selesai jika mereka melakukan kesalahan.

Di negara Objective-C dan Mac OS X dan iOS, kerangka kerja (seperti yang lainnya) ditulis untuk memanfaatkan peningkatan inti prosesor ini dan menghadirkan antarmuka yang bagus kepada pengembang untuk memanfaatkannya.

Contoh pada Mac OS X dan iOS adalah pengiriman Grand Central. Ada tambahan untuk libc(saya percaya) untuk memfasilitasi antrian berbasis multi-threading. Kemudian kerangka kerja Kakao dan Yayasan (antara lain) ditulis di atas GCD, memberikan pengembang akses mudah untuk mengirimkan antrian dan threading dengan kode pelat ketel yang sangat sedikit.

Banyak bahasa dan kerangka kerja memiliki konsep serupa.

Bagian yang sulit adalah semua dalam membagi algoritma intensif CPU Anda ke potongan eksekusi yang dapat diulir.

Kemudian, utas yang terus-menerus melompat dari satu inti ke inti lainnya akan memiliki penalti kinerja (karena cache CPU tingkat pertama dan kedua terlewatkan), terutama dalam arsitektur di mana dua mati fisik yang berbeda digunakan. Dalam hal ini afinitas thread-core adalah hal yang baik.

Kami sekarang (Oktober 2010) dalam masa transisi yang luar biasa.

Kami hari ini dapat membeli desktop 12 inti.
Kami hari ini dapat membeli kartu pemrosesan 448 inti (mencari NVidia Tesla).

Ada batasan seberapa banyak kita pengembang dapat bekerja dalam ketidaktahuan tentang lingkungan paralel yang luar biasa yang akan bekerja dalam program kita dalam waktu dekat.

Sistem operasi, lingkungan runtime, dan perpustakaan pemrograman hanya dapat melakukan banyak hal.

Di masa depan, kita harus mempartisi pemrosesan kita menjadi potongan diskrit untuk pemrosesan independen, menggunakan abstraksi seperti .NET "Task Framework" baru.

Detail seperti manajemen cache dan afinitas masih akan ada - tetapi hanya akan menjadi bukti aplikasi ultra-performant saja. Tidak ada pengembang yang sama yang ingin mengelola detail ini secara manual di mesin inti 10k.

baik, itu benar-benar tergantung pada apa yang Anda kembangkan. jawabannya, tergantung pada apa yang Anda kembangkan, dapat berkisar dari "itu tidak signifikan" hingga "itu benar-benar kritis, dan kami berharap semua orang di tim memiliki pemahaman yang baik dan penggunaan implementasi paralel".

untuk sebagian besar kasus, pemahaman yang kuat dan penggunaan kunci, utas, dan tugas dan kumpulan tugas akan menjadi awal yang baik ketika kebutuhan akan paralelisme diperlukan. (bervariasi menurut lang / lib)

menambah bahwa perbedaan dalam desain Anda harus membuat - untuk multi-pemrosesan nontrivial, kita harus sering belajar beberapa model pemrograman baru, atau strategi paralelisasi. dalam hal itu, waktu untuk belajar, gagal cukup waktu untuk memiliki pemahaman yang kuat, dan untuk memperbarui program yang ada dapat membutuhkan satu tim setahun (atau lebih). setelah Anda mencapai titik itu, Anda akan (mudah-mudahan!) tidak melihat atau mendekati masalah / implementasi seperti yang Anda lakukan hari ini (asalkan Anda belum melakukan transisi itu).

Kendala lain adalah Anda secara efektif mengoptimalkan program untuk eksekusi tertentu. jika Anda tidak diberi banyak waktu untuk mengoptimalkan program, maka Anda benar-benar tidak akan mendapat manfaat sebanyak yang Anda seharusnya. paralelisasi tingkat tinggi (atau yang jelas) dapat meningkatkan kecepatan program Anda yang dipersepsikan dengan sedikit usaha, dan itu sejauh yang dilakukan banyak tim hari ini: "Kami telah memaralelkan bagian-bagian aplikasi yang sangat jelas" - itu tidak masalah dalam beberapa kasus. Apakah manfaat dari mengambil buah yang menggantung rendah dan menggunakan parallization sederhana sebanding dengan jumlah inti? seringkali, ketika ada dua atau empat inti logis tetapi tidak terlalu sering di luar itu. dalam banyak kasus, itu merupakan pengembalian yang dapat diterima, mengingat investasi waktu. model paralel ini adalah pengantar banyak orang untuk menerapkan penggunaan paralelisme yang baik.

apa yang Anda pelajari menggunakan model paralel sepele ini tidak akan ideal dalam semua skenario paralel kompleks; efektif menerapkan desain paralel yang kompleks membutuhkan pemahaman dan pendekatan yang jauh berbeda. model-model sederhana ini sering terlepas atau memiliki interaksi sepele dengan komponen lain dari sistem. juga, banyak implementasi dari model-model sepele ini tidak skala baik untuk sistem paralel yang efektif kompleks - desain paralel kompleks yang buruk dapat memakan waktu selama untuk mengeksekusi sebagai model sederhana. ill: ini dieksekusi dua kali lebih cepat dari model single threaded, sementara menggunakan 8 core logis selama eksekusi. contoh paling umum menggunakan / membuat terlalu banyak utas dan gangguan sinkronisasi tingkat tinggi. secara umum, ini disebut perlambatan paralel. cukup mudah untuk ditemui jika Anda mendekati semua masalah paralel sebagai masalah sederhana.

jadi, katakanlah Anda benar - benar harus menggunakan multithreading yang efisien dalam program Anda (minoritas, dalam iklim saat ini): Anda harus menggunakan model sederhana secara efektif untuk mempelajari model yang kompleks dan kemudian mempelajari kembali bagaimana Anda mendekati aliran dan interaksi program. model yang kompleks adalah di mana program Anda pada akhirnya harus berada karena di situlah perangkat keras hari ini, dan di mana perbaikan yang paling dominan akan dilakukan.

pelaksanaan model-model sederhana dapat dibayangkan seperti garpu, dan model-model kompleks beroperasi seperti ekosistem yang kompleks. Saya pikir pemahaman model sederhana, termasuk penguncian umum dan threading harus atau akan segera diharapkan dari pengembang menengah ketika domain (di mana Anda mengembangkan) menggunakannya. memahami model yang kompleks masih agak tidak biasa saat ini (di sebagian besar domain), tetapi saya pikir permintaan akan meningkat cukup cepat. sebagai pengembang, lebih banyak program kami yang harus mendukung model-model ini, dan sebagian besar penggunaannya cukup jauh ketinggalan dalam memahami dan mengimplementasikan konsep-konsep ini. karena jumlah prosesor logis adalah salah satu area terpenting dari peningkatan perangkat keras, permintaan orang yang memahami dan dapat menerapkan sistem yang kompleks pasti akan meningkat.

akhirnya, ada banyak orang yang mengira solusinya hanyalah "tambahkan paralelisasi". Seringkali, lebih baik membuat implementasi yang ada lebih cepat. itu jauh lebih mudah dan jauh lebih mudah dalam banyak kasus. banyak program di alam tidak pernah dioptimalkan; beberapa orang hanya memiliki kesan bahwa versi yang tidak dioptimalkan akan dikalahkan oleh perangkat keras suatu hari nanti. meningkatkan desain atau algos dari program yang ada juga merupakan keterampilan penting jika kinerjanya penting - melempar lebih banyak inti pada masalah belum tentu merupakan solusi terbaik atau paling sederhana.

saat menargetkan PC modern, kebanyakan dari kita yang perlu menerapkan sistem paralel yang baik tidak perlu melampaui multithreading, mengunci, perpustakaan paralel, membaca buku, dan banyak pengalaman menulis dan menguji program (pada dasarnya, secara signifikan merestrukturisasi cara Anda pendekatan program penulisan).

Kami melakukannya, tetapi kami menulis perhitungan perangkat lunak yang berat sehingga kami mendapat manfaat langsung dari banyak core.

Terkadang scheduler sering menggerakkan thread di antara core. Jika itu tidak dapat diterima, Anda dapat bermain dengan afinitas inti.

Seperti berdiri, frekuensi prosesor tidak akan meningkat dalam waktu dekat. Kami terjebak di sekitar tanda 3 GHz (tanpa overclocking). Tentu saja, untuk banyak aplikasi mungkin tidak perlu melampaui multi-threading yang sangat mendasar. Tentunya jika Anda sedang membangun aplikasi antarmuka pengguna, setiap pemrosesan intensif harus dilakukan pada utas latar belakang.

Jika Anda sedang membangun aplikasi yang sedang memproses data dalam jumlah besar yang harus real-time, maka ya, Anda mungkin harus melihat ke dalam pemrograman multi-threading.

Untuk pemrograman multi-utas, Anda akan menemukan bahwa Anda akan mendapatkan pengembalian yang berkurang atas kinerja Anda; Anda dapat menghabiskan berjam-jam dan meningkatkan program dengan 15%, dan kemudian menghabiskan seminggu lagi dan hanya memperbaikinya dengan 5% lebih lanjut.