COVER LAPORAN Diisi kantor Diisi kantor

Universitas Islam Negeri Program Studi Teknik Elektro Tanggal masuk: Tanggal
Sultan Syarif Kasim Riau keluar:

MAHASISWA – Silahkan isi bagian A dan B saja.

BAGIAN A - Identitas
Semester Genap TA. 2019/2020
Kode Nama Lokal: VII A
PTE1774 Pemrosesan Paralel
Praktikum: Praktikum: (Komputer)
Judul Tanggal: 05 Desember
Nomor Modul: MODUL 2 Clause OpenMP
Modul: 2020
Nomor Nama
11755101888 Fadhlin Ritonga
Mahasiswa: Mahasiswa:

Instruktur Praktikum: Oktaf Billian Kharisma, ST. MT Hubungi Instruktur Praktikum jika ada
pertanyaan

BAGIAN B - Deklarasi Mahasiswa

Segala bentuk plagiarisme, penjiplakan, kolusi dan pelanggaran terhadap integritas akademik lainnya
adalah pelanggaran serius dan dapat berakibat dijatuhkannya sanksi serius pada mahasiswa.
Jika Anda tidak yakin bahwa laporan Anda sudah bebas segala bentuk pelanggaran di atas, silahkan
hubungi Instruktur Praktikum.

 Dengan ini saya bersumpah bahwa laporan yang saya kumpulkan ini adalah hasil pekerjaan saya
sendiri dan tidak menyontek hasil pekerjaan praktikan lain.

Dinyatakan oleh: (Fadhlin Ritonga)

BAGIAN C – Komentar Penilai

Nilai : Nama Penilai: Tanggal :

 CLAUSE OPENMP

2.1 Tujuan
Menguasai clause dalam OpenMP

2.2 Landasan teori

Pertimbangan penting untuk pemrograman OpenMP adalah pemahaman dan penggunaan
cakupan data, karena OpenMP didasarkan pada model pemrograman shared memory,
sebagian besar variabel digunakan bersama secara default. Variabel terdiri dari variabel
global dan variabel private. Variabel global meliputi variabel lingkup file, sedangkan
variabel private meliputi variabel indeks loop dan variabel stack dalam subrutin
dipanggil dari daerah paralel. Daftar clause bersama dengan nama- direktif seperti
terlihat pada Tabel 1.

Tabel 1 kombinasi clause dan nama-direktif

Clause Parallel For Sections Single Parallel Parallel

for sections
Copyin() ● ● ● ● ●
Copyprivate() ●
Default() ● ● ● ● ●
Firstprivate() ● ● ● ● ● ●
If() ● ● ● ● ●
Lastprivate() ● ● ● ●
Nowait ● ● ●
Num_threads() ● ● ● ● ●
Ordered ● ●
Private() ● ● ● ● ● ●
Reduction() ● ● ● ● ●
Schedule() ● ●
Shared() ● ● ● ● ●

Clause copyin() hanya dapat digunakan dalam nama-direktif parallel, for, sections,
parallel for, dan parallel sections.

2.3 Peralatan yang digunakan

Visual Studio 2013 Express

2.4 Eksperimen
Buatlah seluruh program paralel di bawah ini dan jelaskan dalam laporan praktikum.
 2.4.1 Clause copyin(var):
#include <cstdio>
int i;
#pragma omp threadprivate(i)
int main()
{
int n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for copyin (i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.2 Clause copyprivate(var):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp single copyprivate(i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.3 Clause default(shared/none):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for default(shared)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}
#pragma omp parallel for default(shared)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.4 Clause firstprivate(var):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for firstprivate(i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.5 Clause if(expression):

#include <cstdio>
#include <omp.h>
void test(int nilai)
{
#pragma omp parallel if (nilai)
if (omp_in_parallel())
{
#pragma omp single
printf_s("nilai = %d, diparalelkan dengan %d thread\n", nilai,
omp_get_num_threads());
}
else
{
printf_s("nilai = %d, diserialkan\n", nilai);
}
}
int main( )
{
omp_set_num_threads(2);
test(0);
test(2);
}
 2.4.6 Clause lastprivate(var):
#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for lastprivate(i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.7 Clause nowait:

#include <iostream>
#define SIZE 5
using namespace std;
void test(int *a, int *b, int *c, int size)
{
int i;
#pragma omp parallel
{
#pragma omp for nowait
for (i = 0; i < size; i++)
b[i] = a[i] * a[i];
#pragma omp for nowait
for (i = 0; i < size; i++)
c[i] = a[i] / 2;
}
}
int main()
{
int a[SIZE], b[SIZE], c[SIZE];
int i;
for (i = 0; i < SIZE; i++)
a[i] = i;
test(a, b, c, SIZE);
for (i = 0; i < SIZE; i++)
cout << "" << a[i] << ", " << b[i] << ", " << c[i] << endl;
}

2.4.8 Clause num_threads(number):

#include <cstdio>
#include <omp.h>
int main() {
#pragma omp parallel num_threads(4)
{
int i = omp_get_thread_num();
printf_s("Hello dari thread %d\n", i);
}
}
 2.4.9 Clause ordered:
#include <iostream>
using namespace std;
void work(int k)
{
#pragma omp ordered
{
cout << "" << k << endl;
}
}
void ordered_example(int lb, int ub, int stride)
{
int i;
#pragma omp parallel for ordered
for (i = lb; i < ub; i += stride)
{
work(i); }
}
int main()
{
ordered_example(0, 100, 5);
return 0;
}

2.4.10 Clause private(var):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for private(i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.11 Clause reduction(operation : var):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
 }
#pragma omp parallel for reduction(+:result)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.12 Clause schedule(dynamic/guided/runtime/static, size):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp for schedule(dynamic,chunk)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}

2.4.13 Clause shared(var):

#include <cstdio>
int main()
{
int i, n, chunk;
double a[100], b[100], result;
n = 100;
chunk = 10;
result = 0.0;
for (i=0; i < n; i++)
{
a[i] = i * 1.0;
b[i] = i * 2.0;
}
#pragma omp parallel for shared(i)
for (i=0; i < n; i++)
result = result + (a[i] * b[i]);
printf("Final result= %f\n",result);
}
2.5 Hasil Pengamatan Praktikum
2.5.1 Clause copyin(var):

Gambar 2.1 Hasil Pengamatan Caluse copyin(var)

2.5.2 Clause copyprivate(var):

Gambar 2.2 Hasil Pengamatan Clause copyprivate(var)

2.5.3 Clause default(shared/none):

Gambar 2.3 Hasil Pengamatan Clause default(share/none)

2.5.4 Clause firstprivate(var):

Gambar 2.4 Hasil Pengamatan Clause firstprivate(var)

2.5.5 Clause if(expression):

Gambar 2.5 Hasil Pengamatan Clause if(expression)

2.5.6 Clause lastprivate(var):

Gambar 2.6 Hasil Pengamatan Clause lastprivate(var)

2.5.7 Clause nowait:

Gambar 2.7 Hasil Pengamatan Clause nowait

2.5.8 Clause num_threads(number):

Gambar 2.8 Hasil Pengamatan Caluse num_threads(number)

2.5.9 Clause ordered:

Gambar 2.9 Hasil Pengamatan Clause ordered

2.5.10 Clause private(var):

Gambar 2.10 Hasil Pengamatan Clause private

2.5.11 Clause reduction(operation : var):

Gambar 2.11 Hasil Pengamatan Clause reduction(operation : var)

2.5.12 Clause schedule(dynamic/guided/runtime/static, size):

Gambar 2.12 Hasil Pengamatan

Clause schedule(dynamic/guided/runtime/static,size)
2.5.13 Clause shared(var):

Gambar 2.13 Hasil Pengataman Clause shared(var)

2.6 Analisa Pembahasan
2.6.1 Clause copyin(var):
Sebenarnya Copyin ini meruoakan jenis clause yang mirip dengan private, dimana
pada post private itu dia akan melakukan private terhadap memori disimpan pada
program ini sehingga tidak dilakukan secara paralel, kemudian untuk
inisialisasinya data private itu berisfat private untuk masing-masing trid sehingga
data yang inisialisai tidak menggunakan nilai dari variabel dengan menggunakan
nama yang sama dari master trid. Tetapi terdapat beberapa perbedaann antara post
private dengan copyin, pada copyin itu terdapat variabel yang belum diinisialisai
#pragma omp threadprivate (i). Kemudian (i) itu belum diinisialisasi nilainya itu
berapa, itu bedanya dengan post private. Sebenarnya untuk mengetahui nilai dari
hasil simulasi.
2.6.2 Clause copyprivate(var):
Biasanya digunakan dengan sendiri untuk mendukung penyalinan data, jadi data
yang ada pada tridnya itu akan disalin menjadi objek tetap yang bersifat private,
dimana akan disalin ke trid yang lain. Setelah disimulasikan nilainya itu sama aja
dengan perhitungan yang sama, tapi ada yang berbeda ada di #pragma omp single
copyprivate(i), menggunakan OpenMp dengan direktif single dengan clause
copyprivate, dimana menggunakan variabel (i), sama dengan percobaan
sebelumnya untuk mengganti nilai 100 menjadi 50, itu akan terdapat bebrapa
perbedaan misalnya error atau lainnya.
2.6.3 Clause default(shared/none):
Memorinya akan di share kepada trid yang lainnya, jadi caluse default ini
memungkinkan bahwa data dari program itu bersifat fault, sehingga data program
ini dapat dijalankan secara paralel, #pragma omp parallel for default(shared) semua
program yang ada akan dijalankan oleh masing-masing trid. Misalnya kita
mengganti nilai n=50 dan simulasikan hasilnya itu akan berbeda.
2.6.4 Clause firstprivate(var):
Apabila clause firstprivate ini di copyin itu terdapat trid yang belum
dideklarasikan. Pada percobaan ini nilai firstprivate tidak dimasukkan tetapi
masuk kedalam variabel ini #pragma omp parallel for firstprivate(i), a[i] = i * 1.0;
dijumlahkan sampai n=100 hingga nanti (i) lebih kecil dari n. Jika kita
menghitungnya secara matamatis dapat kita lakukan dengan sikma atau sam
sebagai parameter, hasilnya akan tetap sama disini kita menggunakan paralel.
2.6.5 Clause if(expression):
Untuk clause if ini, dia akan melakakukan paralelisasi terhadap variabel nilai
dimana variabel nilai itu bersifat intiger, setelah kita simulasikan terdapat dua
baris dimana nilai = 0, diserialkan kemudian baris kedua nilai = 2, diparalelkan
dengan 2 trid. Angka 2 itu tardapat pada jumlah tridnya omp_set_num_threads(2);
kalau kita ingin jumlah yang lain juga bisa, misalnya jumalah tridnya 4, nilainya tetap
sama diparalelkan dengan 4 trid. Kemdudian test(0); maka nilainya 0, test(2); maka
nilainya 2.
2.6.6 Clause lastprivate(var):
Pada clause lastprivate ini akan dilakukan pembaharuan data setelah program
dijalankan sama dengannya dengan firstprivate. Jadi setiap ada proses pemrosesan
paralel maka setiap itu ada pembaharuan, untuk hasil simulasinya sama dengan
caluse sebelumnya.
2.6.7 Clause nowait:
Pada clause nowait ini dia akan menjalankan program dan menetapkan bahwa trid
untuk menyelesaikan pekerjaan yang ditugaskan itu dapat dilanjutkan tanpa
menunggu trid yang lainnya. Jadi misalnya kita menggunakan 4 buah trid atau
procesor kemudian pada program ini ternyata pada procesor ke-3 terdapat delay
sehingga diperkirakan akan terdapat terjadi data yang terlambat di proses, sehingga
procesor 1, 2, dan 4 dapat melakukan prosesnya tanpa perlu menunggu procesor
ke-3 selesai dengan paralelisasi datanya. Setelah disimulasikan 0, 0, 0 itu terdapat
perhitungan didalamnya, misalnya kita ganti sizenya 8 maka setiap trid akan
menangani 2 kali perhitungan trid nomor 1, 2 dan 3. Kalau sizenya 10 maka akan
menggunakan 5 buah trid.
2.6.8 Clause num_threads(number):
Pada clause num_threads dia akan menggunakan pemrosesan secara paralel
dimana dilakukan oleh trid-4 #pragma omp parallel num_threads(4), jadi dia akan
melakukan perhitungan sebanya 4 kali dimana procesor akan menjalankan
program ini int i = omp_get_thread_num();. Kemudian pada trid yang
menjalankan bersifat acak, tidak bersifat berurutan karena procesor akan terus
menjalankan program yang terpanggil selagi komputer itu berjalan. Jadi fungsi
num threads ini menentukan jumlah trid yang akan kita gunakan dengan
menggunakan direktif paralel.
2.6.9 Clause ordered:
Untuk mengurutkan program paralel yang kita jalankan, setelah disimulasikan
terdapat angka yang berurut dimana perhitungannya ordered_example(0, 100, 5);
nilai minimalnya 0 nilai maksimalnya 100 dan jarak antara nilainya 5 misalnya 0,
5, 10, 15 sampai dengan 100.
2.6.10 Clause private(var):
Cara kerjanya sama dengan sebelumnya tapi disini supaya memori pada program
ini tidak tibagi dengan trid-trid yang lainnnya sehingga pertukaran data antar trid
itu diminalisir.
2.6.11 Clause reduction(operation : var):
Pada caluse ini hasilnya sama saja dengan caluse sebelumnya, yang berbeda
adalah cara kerja pemrosesan paralel di latar belakanganya. Apabila kita merubah
nilai n=50, maka Final resultnya menjadi = 80850.000000, dimanaya nilai n
sebelumnya adalah 100.
2.6.12 Clause schedule(dynamic/guided/runtime/static, size):
Pada clause ini hasilnya sama saja biasanya terdapat beberapa tipe seperti
(dynamic/guided/runtime/static, size), disini kita menggunakan #pragma omp for
schedule(dynamic,chunk) kemudian kita simulasikan ternyata hasilnya sama saja, tetapi
proses dibaliknya yang berbeda. Misalnya kita ganti nilai n=10 kemudian nilai a10 b50
dan kita jalankan dengan jenis dynamic, jadi hasil yang didapat adalah double walaupun
jenisnya kita buat stati hasilnya juga tetap sama.
2.6.13 Clause shared(var):
Pada clause ini dimana variabelnya itu data-data didalam wilayah paralel for (i=0;
i < n; i++) disini ada bagian paralelisasi setelah pragma omp itu. Jadi fungsi
didalam wilayah tadi itu akan digunakan secara bersama-sama yang berarti akan
dapat diakses oleh semua trid. Setelah kita simulasikan hasilnya tetap sama tetapi
yang berpengaruh didalamnya adalah jenis-jenisnya seperti paralelisasi data,
clausenya seperti apa.
2.7 Kesimpulan
Clause OpenMP adalah model pemrograman dimana memori dalam pemrosesan
program menggunakan secara bersamaan atau biasa disebut dengan set memori , tetapi
terkadang ada beberapa program ataupun kondisi yang harus menggunakan kita untuk
memori secara private tujuannya apa supaya dari program itu saling mengejar tidak
saaling kejer mengejar an dalam running suatu program sehingga jika program itu
dilaksanakan secara paralel itu dia tidak saling bertukar informasi anatara satu dengan
lainnya.