Apa's perbedaan antara "statis" dan "dinamis" promo di OpenMP?

Lain karena telah menjawab sebagian dari pertanyaan tetapi saya ingin menunjukkan beberapa kasus-kasus tertentu di mana tertentu penjadwalan jenis ini lebih cocok daripada yang lain. Jadwal kontrol bagaimana iterasi loop dibagi di antara benang. Memilih jadwal yang tepat dapat memiliki dampak yang besar pada kecepatan aplikasi. statis jadwal berarti bahwa iterasi blok yang dipetakan secara statis ke eksekusi benang di round-robin. Hal yang baik dengan penjadwalan statis adalah bahwa OpenMP run-time adalah bahwa jika anda memiliki dua loop dengan jumlah yang sama dari iterasi dan mengeksekusi mereka dengan jumlah yang sama dari benang menggunakan penjadwalan statis, maka setiap thread akan menerima persis sama iterasi range(s) di kedua daerah paralel. Hal ini cukup penting pada NUMA sistem: jika anda menyentuh beberapa memori dalam lingkaran pertama, itu akan berada di NUMA node mana yang mengeksekusi benang itu. Kemudian di putaran kedua benang yang sama bisa mengakses lokasi memori yang lebih cepat karena akan berada di sisi yang sama NUMA node. Bayangkan ada dua NUMA node: node 0 dan node 1, misalnya dua-socket Intel Nehalem papan dengan 4-core Cpu di kedua soket. Kemudian benang 0, 1, 2, dan 3 akan berada pada node 0 dan benang 4, 5, 6, dan 7 akan berada pada simpul 1:

|             | core 0 | thread 0 |
| socket 0    | core 1 | thread 1 |
| NUMA node 0 | core 2 | thread 2 |
|             | core 3 | thread 3 |

|             | core 4 | thread 4 |
| socket 1    | core 5 | thread 5 |
| NUMA node 1 | core 6 | thread 6 |
|             | core 7 | thread 7 |

Masing-masing core dapat mengakses memori dari masing-masing simpul NUMA, tapi remote akses lebih lambat (1.5 x - 1,9 x lebih lambat pada Intel) dari node lokal akses. Anda menjalankan sesuatu seperti ini:

char *a = (char *)malloc(8*4096);

#pragma omp parallel for schedule(static,1) num_threads(8)
for (int i = 0; i < 8; i++)
   memset(&a[i*4096], 0, 4096);

4096 byte dalam hal ini adalah standar ukuran satu halaman memori pada Linux x86 jika besar halaman yang tidak digunakan. Kode ini akan nol seluruh 32 KiB array a. The malloc() panggilan hanya cadangan ruang alamat virtual, tapi tidak benar-benar "sentuh" memori fisik (ini adalah perilaku default kecuali beberapa versi lain dari malloc digunakan, misalnya salah satu yang nol memori seperti calloc() tidak). Sekarang ini hotel yang bersebelahan tetapi hanya di memori virtual. Dalam memori fisik setengah dari itu akan berbaring di dalam memori yang terpasang ke soket 0 dan setengah dalam memori yang terpasang ke soket 1. Hal ini karena bagian-bagian yang berbeda yang memusatkan perhatian oleh berbagai benang dan benang-benang berada pada core yang berbeda dan ada sesuatu yang disebut first touch NUMA kebijakan yang berarti bahwa halaman memori yang dialokasikan pada NUMA simpul pada benang yang pertama "menyentuh" halaman memori berada.

|             | core 0 | thread 0 | a[0]     ... a[4095]
| socket 0    | core 1 | thread 1 | a[4096]  ... a[8191]
| NUMA node 0 | core 2 | thread 2 | a[8192]  ... a[12287]
|             | core 3 | thread 3 | a[12288] ... a[16383]

|             | core 4 | thread 4 | a[16384] ... a[20479]
| socket 1    | core 5 | thread 5 | a[20480] ... a[24575]
| NUMA node 1 | core 6 | thread 6 | a[24576] ... a[28671]
|             | core 7 | thread 7 | a[28672] ... a[32768]

Sekarang mari kita menjalankan lain loop seperti ini:

#pragma omp parallel for schedule(static,1) num_threads(8)
for (i = 0; i < 8; i++)
   memset(&a[i*4096], 1, 4096);

Setiap thread yang akan mengakses sudah dipetakan memori fisik dan akan memiliki yang sama pemetaan benang untuk memori wilayah sebagai satu selama loop pertama. Itu berarti bahwa benang hanya akan mengakses memori terletak di daerah blok memori yang akan menjadi cepat. Sekarang bayangkan bahwa penjadwalan yang lain skema ini digunakan untuk loop kedua: jadwal(statis,2). Ini akan "chop" iterasi ruang dalam blok-blok dari dua iterasi dan akan ada 4 blok tersebut secara total. Apa yang akan terjadi adalah bahwa kita akan memiliki thread berikut untuk lokasi memori mapping (melalui iterasi jumlah):

|             | core 0 | thread 0 | a[0]     ... a[8191]  

Saya pikir kesalahpahaman berasal dari fakta bahwa anda kehilangan titik tentang OpenMP. Dalam kalimat OpenMP memungkinkan anda untuk menjalankan program anda lebih cepat dengan memungkinkan paralelisme. Dalam program paralelisme dapat diaktifkan dengan berbagai cara dan salah satu adalah dengan menggunakan benang. Misalkan anda memiliki dan array:

[1,2,3,4,5,6,7,8,9,10]

dan anda ingin kenaikan semua elemen 1 dalam array ini.

Jika anda akan menggunakan

#pragma omp for schedule(static, 5)

itu berarti bahwa untuk setiap thread akan diberikan 5 bersebelahan iterasi. Dalam hal ini thread pertama akan mengambil 5 angka. Yang kedua akan mengambil lagi 5 dan seterusnya sampai tidak ada lagi data untuk proses atau jumlah maksimum dari benang tercapai (biasanya sama dengan jumlah core). Berbagi beban kerja yang dilakukan selama kompilasi.

Dalam kasus

#pragma omp for schedule(dynamic, 5)

Pekerjaan akan dibagi di antara benang tetapi prosedur ini akan terjadi pada saat runtime. Dengan demikian melibatkan lebih banyak overhead. Kedua parameter ini menentukan ukuran dari chunk data.

Tidak sangat akrab dengan OpenMP aku mengambil risiko untuk mengasumsikan bahwa tipe dinamis adalah lebih tepat bila disusun kode yang akan dijalankan pada sistem yang memiliki konfigurasi yang berbeda yang satu di mana kode yang disusun.

Saya akan merekomendasikan halaman bawah di mana ada dibahas teknik-teknik yang digunakan untuk parallelizing kode, prasyarat dan keterbatasan

https://computing.llnl.gov/tutorials/parallel_comp/

Link tambahan:
http://en.wikipedia.org/wiki/OpenMP
https://stackoverflow.com/questions/4261087/difference-between-static-and-dynamic-schedule-in-openmp-in-c
http://openmp.blogspot.se/

Loop skema partisi yang berbeda. Statis scheduler akan membagi sebuah lingkaran dari unsur-unsur N ke M himpunan bagian, dan masing-masing bagian kemudian akan mengandung ketat N/M elemen.

Pendekatan dinamis menghitung ukuran subset on the fly, yang dapat berguna jika subset' perhitungan waktu bervariasi.

Pendekatan statis harus digunakan jika perhitungan waktu bervariasi tidak banyak.