Tugas II Makassar, 7 Desember 2022

TUGAS

KOMPUTASI PARALEL

Nama : Roufur Rohim

NIM 13020190375
Kelas : A7

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS ILMU KOMPUTER

UNIVERSITAS MUSLIM INDONESIA

MAKASSAR

2022
1. Kesimpulan pengantar OPENMP sesuai pemahaman saya
Adapun kesimpulan dari pengantar OPENMP menurut pemahaman
saya, antara lain :
OpeMP merupakan direktori program C/C++ yang menggambarkan
penggunaan antarmuka program aplikasi untuk melakukan perhitungan
paralel di lingkungan memori secara bersamaan. OpenMP menggunakan
model fork-join dari eksekusi paralel di mana semua program di mulai
dengan single master thread yang dijalankan secara berurutan hingga
parallel region di temukan, saat itu membuat tim threads paralel (FORK).
Setelah selesai tim threads kemudia menyingkronkan dan mengakhiri dan
hanya menyisakan master thread yang di eksekusi secara berurutan (JOIN).
Adapun general code structure dari OpenMP sebagai berikut :
#include <omp.h>
main () {
int var1, var2, var3;
Serial code
...
/* Beginning of parallel section. Fork a team of threads. Specify variable
scoping*/
#pragma omp parallel private(var1, var2) shared(var3)
{
/* Parallel section executed by all threads */
...
/* All threads join master thread and disband*/
}
Resume serial code
...
}

Model data dari openMP ini terdiri atas private and shared variabels,
Variabel global data dapat di akses semua parallel threads(shared variabel).
 Sedangkan variables in a threads private hanya dapat di akses oleh thread
itu sendiri(private variables).
2. Program yang mengimplementasikan Work-Sharing Constructs
• Pragma omp for [clause]

// omp_for.cpp
// compile with: /openmp
#include <stdio.h>
#include <math.h>
#include <omp.h>

#define NUM_THREADS 4
#define NUM_START 1
#define NUM_END 10

int main() {
int i, nRet = 0, nSum = 0, nStart = NUM_START,
nEnd = NUM_END;
int nThreads = 0, nTmp = nStart + nEnd;
unsigned uTmp = (unsigned((abs(nStart - nEnd) +
1)) *

unsigned(abs(nTmp))) / 2;
int nSumCalc = uTmp;

if (nTmp < 0)
nSumCalc = -nSumCalc;

omp_set_num_threads(NUM_THREADS);

#pragma omp parallel default(none) private(i)

shared(nSum, nThreads, nStart, nEnd)
{
#pragma omp master
nThreads = omp_get_num_threads();

#pragma omp for

for (i=nStart; i<=nEnd; ++i) {
#pragma omp atomic
nSum += i;
}
}

if (nThreads == NUM_THREADS) {
printf_s("%d OpenMP threads were used.\n",
NUM_THREADS);
nRet = 0;
}
else {
 printf_s("Expected %d OpenMP threads, but %d
were used.\n",
NUM_THREADS, nThreads);
nRet = 1;
}

if (nSum != nSumCalc) {
printf_s("The sum of %d through %d should be
%d, "
"but %d was reported!\n",
NUM_START, NUM_END, nSumCalc,
nSum);
nRet = 1;
}
else
printf_s("The sum of %d through %d is %d\n",
NUM_START, NUM_END, nSum);
}

Output :

4 OpenMP threads were used.

The sum of 1 through 10 is 55

• Pragma omp section [clause]

// omp_sections.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main() {
#pragma omp parallel sections num_threads(4)
{
printf_s("Hello from thread %d\n",
omp_get_thread_num());
#pragma omp section
printf_s("Hello from thread %d\n",
omp_get_thread_num());
}
}

Output :

Hello from thread 0

Hello from thread 0
 • Pragma omp single [clause]

// omp_single.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main() {
#pragma omp parallel num_threads(2)
{
#pragma omp single
// Only a single thread can read the input.
printf_s("read input\n");

// Multiple threads in the team compute the

results.
printf_s("compute results\n");

#pragma omp single

// Only a single thread can write the
output.
printf_s("write output\n");
}
}

Output :

read input
compute results
compute results
write output

3. Ananlisis masing masing program dan penjelasan mengenai

perbedaan ketiga work sharing constructs di nomor 2 !
• Pragma omp for [clause]
untuk pekerjaan yang dilakukan dalam perulangan for di dalam
wilayah paralel dibagi di antara utas.
• Pragma omp section [clause]
Direktif sections dapat berisi nol atau lebih section direktif.
• Pragma omp single [clause]
Di gunakan untuk menentukan bahwa bagian kode hanya boleh
dijalankan pada utas utama, gunakan arahan master sebagai
gantunya.
 Perbedaan pada work sharing constructs di atas terletak pada
directif yang mendukung klausulnya masing masing. Di mana
Pragma omp for direktif for pendukung klausulnya sebagai berikut :
▪ Pribadi
▪ Firstprivate
▪ Lastprivate
▪ Pengurangan
▪ Memerintahkan
▪ Jadwal
▪ Nowait

Pragma omp sections [clause] direktif pendukung klausulnya

sebagai berikut :

▪ Pribadi
▪ Firstprivate
▪ Lastprivate
▪ Pengurangan
▪ Nowait

Pragma omp single [clause] direktif pendukung klausulnya sebagai

berikut :

▪ Pribadi
▪ Firstprivate
▪ Copyprivate
▪ Nowait
4. Mengunci Fungsi
Fungsi yang dijelaskan dalam bagian ini memanipulasi kunci yang digunakan untuk
sinkronisasi.
Untuk fungsi berikut, variabel kunci harus memiliki tipe omp_lock_t. Variabel ini
hanya boleh diakses melalui fungsi-fungsi ini. Semua fungsi kunci memerlukan
argumen yang memiliki penunjuk untuk omp_lock_t diketik.
▪ Fungsi omp_init_lock menginisialisasi kunci sederhana.
▪ Fungsi omp_destroy_lock menghilangkan kunci sederhana.
▪ Fungsi omp_set_lock menunggu sampai kunci sederhana tersedia.
▪ Fungsi omp_unset_lock melepaskan kunci sederhana.
▪ Fungsi omp_test_lock menguji kunci sederhana.
Untuk fungsi berikut, variabel kunci harus memiliki tipe omp_nest_lock_t. Variabel ini
hanya boleh diakses melalui fungsi-fungsi ini. Semua fungsi kunci nestable memerlukan
argumen yang memiliki pointer untuk omp_nest_lock_t diketik.
▪ Fungsi omp_init_nest_lock menginisialisasi kunci yang dapat bersarang.
▪ Fungsi omp_destroy_nest_lock menghilangkan kunci yang dapat
bersarang.
▪ Fungsi omp_set_nest_lock menunggu sampai kunci nestable tersedia.
▪ Fungsi omp_unset_nest_lock melepaskan kunci yang dapat bersarang.
▪ Fungsi omp_test_nest_lock menguji kunci yang dapat bersarang.
Fungsi kunci OpenMP mengakses variabel kunci sedemikian rupa sehingga mereka
selalu membaca dan memperbarui nilai terbaru dari variabel kunci. Oleh karena itu, tidak
perlu bagi program OpenMP untuk menyertakan arahan eksplisit flush untuk memastikan
bahwa nilai variabel kunci konsisten di antara thread yang berbeda. (Mungkin ada
kebutuhan untuk flush arahan untuk membuat nilai variabel lain konsisten.)