Sinkronasi pada openmp [parallel computing]

sinkronasi merupakan hal yang perlu diperhatikan. bagaimana tidak? jika kita telah membagi-bagi pekerjaan kebeberapa thread /  processor, hal terakhir yang harus kita lakukan yaitu menyatukan data-data hasil proses yang telah dikerjakan masing-masing processor.

ada tiga jenis sinkronasi pada openmp:
critical
Direktif untuk membuat wilayah kritis dalam wilayah paralel, hanya satu thread dalam satu waktu yang bisa masuk ke wilayah kritis ini. Wilayah kritis perlu dibuat untuk melindungi shared variable dari race condition yang mengakibatkan inkonsistensi data.

atomic
Direktif yang fungsinya sama seperti critical, tetapi hanya berlaku untuk satu statement aritmatika saja.

barrier
Direktif untuk membuat batas, thread akan menunggu sampai semua thread sampai pada batas ini.

bagaimana menggunakan nya? berikut contoh program yang akan saya sampaikan. kode saa sadur dari sini

############################
atomic
############################

1. tulis program misalkan dengan nama <task2.c>

#include <stdio.h>
#include <omp.h>
#define N 1200
#define T 4

int main() {
    int sum = 0;
    #pragma omp parallel num_threads(T)
    {
        int i;
        for (i = 0; i < N/T; i++)
            sum++;                  // critical section
    }
    printf("%d\n", sum);

    return 0;
}

2. lakukan kompilasi

$ gcc task2.c -o task2 -fopenmp

$ ./task2

coba lakukan running program berkali-kali, maka akan didapatkan hasil yang tidak konsisten. bagaimana cara agar hasil yang didapatkan sama seperti yang diharapkan (1200) dan hasilnya konsisten?

caranya yaitu lindungi daerah "critical section" dengan sintax sinkronasi dari openmp. kode dimodifikasi sebagai berikut:

#include <stdio.h>
#include <omp.h>
#define N 1200
#define T 4

int main() {
    int sum = 0;
    #pragma omp parallel num_threads(T)
    {
        int i;
        for (i = 0; i < N/T; i++)
            #pragma omp atomic
            sum++;                  // critical section
    }
    printf("%d\n", sum);

    return 0;
}

maka hasil yang didapatkan akan konsisten,, yaitu 1200.


############################
Critical
############################
yang kedua, kita akan melakukan proses sinkronasi menggunakan critical. apakah perbedaan dengan yang atomic? dan pada kasus apa critical digunakan.

berikut kode yang digunakan untuk melakukan pencarian nilai maksimal

<task3.c>

#include <stdio.h>
#include <omp.h>

#define N 16 
#define T 4

int main() {
    int max = 0;
    int A[N] = {1,2,3,4,57,6,7,8,9,10,11,12,13,14,15,16};
    #pragma omp parallel num_threads(T)
    {
        int i;
 int max_loc = 0;
        int id = omp_get_thread_num();
 int start = id*N/T;
 int stop = (id+1)*N/T;
        for (i = start; i < stop; i++)
  if (A[i] > max_loc) 
   max_loc = A[i];

 #pragma omp critical
  if (max_loc > max)
   max = max_loc;
    }
    printf("%d\n", max);

    return 0;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ sekian ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


referensi: http://cs.ipb.ac.id/~auriza/parallel/pp.html