Tugas II Makassar, 07 Desember 2022

TUGAS

KOMPUTASI PARALEL

Nama : Nur Taufiqurrahman

NIM : 13020190348
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).
Arahan memperluas model pemrograman berurutan C dan C ++
dengan konstruksi single program multiple data (SPMD), konstruksi
berbagi kerja, dan konstruksi sinkronisasi. Mereka juga mendukung
berbagi dan privatisasi data. Kompiler yang mendukung OpenMP C dan C
++ API menyertakan opsi baris perintah ke kompiler yang mengaktifkan
dan memungkinkan interpretasi semua arahan kompiler OpenMP.
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. Fungsi Linkiungan eksekusi
Fungsi yang dijelaskan di bagian ini mempengaruhi dan memantau utas,
prosesor, dan lingkungan paralel:
▪ omp_set_num_threads
▪ omp_get_num_threads
▪ omp_get_max_threads
▪ omp_get_thread_num
▪ omp_get_num_procs
▪ omp_in_parallel
▪ omp_set_dynamic
 ▪ omp_get_dynamic
▪ omp_set_nested
▪ omp_get_nested
5. 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.)