Update-superkomputer Dengan Native Linux_final

(UPDATE) RAIH DUNIA DENGAN SUPERKOMPUTER

DI LINUX NATIVE

(CATCH THE WORLD WITH SUPERCOMPUTER IN NATIVE LINUX)

Hary Cahyono

tifosilinux.wordpress.com | [email protected]

Version 2.0

TIFOSILINUX.WORDPRESS.COM

Jakarta

2015

Raih Dunia dengan Superkomputer di GNU/ Linux Native Vol. 2, No. 1, 15 March 2015: 1-57

1

DISCLAIMER

Penulis mencoba memberikan sebuah konsep bagaimana membangun sebuah cluster

superkomputer dengan menggunakan beberapa teknologi baik dari sisi kernel maupun aplikasi di

lingkungan GNU/ Linux. Entah mengapa saya sebagai penulis selalu membawa GNU dalam

penulisan linux karena saya merasa bahwa linux dibangun dari bermacam-macam tools hasil

ciptaan seorang Richard M. Stallman lewat project GNU-nya, sehingga user dapat dengan sangat

nyaman menjalankan aplikasi robust diatas kernel hasil ciptaan Linus Torvalds dan kawan-kawan.

Pada tulisan ini ada 3 (tiga) teknologi yang ingin saya sampaikan dalam merancang bangun

sebuah cluster superkomputer didalam sebuah aplikasi virtual. Meskipun mungkin ada aplikasi

atau teknologi lain semisal Ricci dan Luci (Conga) serta lainnya, saya coba batasi sedikit

pembahasan hanya pada seputar teknologi cluter supercomputer dengan OpenMOSIX (merupakan

fitur patch di kernel), OSCAR (Open Source Cluster Application Resources), Rocks, MPI

(Message Passing Interface), dan Beowulf.

Pada kenyataannya, konsep cluster supercomputer dengan tujuan HPC (High Performance

Computing) ataupun masalah HA (High Availability) adalah berbeda dengan konsep Grid

Computing dan Cloud Computing.

Seluruh gambar yang digunakan mutlak merupakan hasil dari percobaan sendiri sehingga

tidak mengganggu masalah copyright. Begitupun dengan mesin virtual dan OS yang digunakan

merupakan sebuah media pembelajaran saja tanpa ada kepentingan bisnis untuk masalah ini.

Pada akhirnya, semoga panduan berikut dapat memberikan sedikit sumbangan pada

teknologi di Indonesia khususnya sehingga mempermudah tahap implementasi di skala yang lebih

besar dan luas. Mari kita raih dunia !!!


2

Daftar Isi

1. Pengantar .................................................................................................................................3

2. Kebutuhan Dasar ....................................................................................................................3

2.1 Hardware .............................................................................................................................3

2.2 Software ..............................................................................................................................4

3. GNU/ Linux Cluster Setup .....................................................................................................4

3.1 OpenMOSIX .......................................................................................................................4

3.1.1 Hardware dan Topologi .............................................................................................4

3.1.2 Sistem Operasi dan Software .....................................................................................5

3.1.3 Rancangan, Tes dan Hasil ..........................................................................................7

3.2 MPI (Message Passing Interface) .....................................................................................15

3.2.1 Hardware dan Topologi ...........................................................................................15

3.2.2 Sistem Operasi dan Software ...................................................................................16

3.2.3 Rancangan, Tes dan Hasil ........................................................................................16

3.3 Beowulf .............................................................................................................................23

3.3.1 Hardware dan Topologi ...........................................................................................23

3.3.2 Sistem Operasi dan Software ...................................................................................24

3.3.3 Rancangan, Tes dan Hasil ........................................................................................26

4. Cluster Tools ..........................................................................................................................29

4.1 OSCAR (Open Source Cluster Application Resources) ...................................................29

4.1.1 OSCAR Architecture ...............................................................................................29

4.1.2 Mengelola OSCAR ..................................................................................................30

4.2 Rocks .................................................................................................................................39

4.2.1 Rocks Architecture ...................................................................................................39

4.2.2 Mengelola Rocks .....................................................................................................40

5. Cluster Programming ...........................................................................................................46

6. Debugging dan Profiling .......................................................................................................54

7. Kesimpulan ............................................................................................................................56

8. Referensi ................................................................................................................................57


3

1. Pengantar

Kebutuhan manusia akan sebuah informasi semakin jelas terlihat semakin meningkat dari

waktu ke waktu. Sebuah informasi atau ilmu pengetahuan yang awalnya hanya dari kumpulan

data atau entitas yang tidak memiliki makna, sehingga dapat menjadi satu kesatuan yang

bernilai guna. Maka muncul berbagai metode-metode dalam upaya bagaimana mengolah dan

menjadikan ribuan, juta-an, bahkan miliaran data dan informasi tersebut tetap terjaga dan

memiliki nilai tambah bagi para decision maker.

Namun dibalik itu semua, sebenarnya ada sesuatu yang berperan paling besar dalam fase

pemrosesan data tersebut, yakni sekumpulan alat-alat komputasi yang merepresentasikan dan

menunjang berbagai metode yang diterapkan oleh para ilmuwan dan user. Informasi dari

weather forecast, customer banking, bursa saham, data transaksi para nasabah dan berbagai

riset yang diolah dengan menggunakan metode prediksi, asosiasi, dan klasifikasi didalam Data

Mining misalnya, terkadang tidak cukup hanya dengan menggunakan sebuah komputer

mainframe atau bahkan laptop sekalipun dengan spesifikasi luar biasa.

Jika kasusnya sudah menjadi petadata atau rendering image dengan teknologi nextgen

seperti di dalam game Assassins Creed Unity misalnya yang ingin diolah, maka rasanya hal

tersebut sangatlah beresiko. Bahkan terkadang kita ingin mendayagunakan perangkat

lama agar bisa berfungsi kembali dan bisa menunjang pekerjaan kita.

Terdapat beberapa tambahan dimana saya harapkan dapat sedikit memperjelas apa saja

opsi-opsi dan langkah membangun superkomputer.

2. Kebutuhan Dasar

2.1 Hardware

Pada tulisan ini saya coba mendayagunakan sebuah notebook ASUS tipe X450J

dengan processor i7-4710HQ 2.5 GHz, GEFORCE 840M, 12GB of RAM dan HDD

sebesar 1TB.

Requirement tersebut secara global digunakan untuk seluruh percobaan, dimana

tidak mengabaikan perencanaan mulai tahap design (yakni menentukan misi keseluruhan

cluster yang ingin dibangun), arsitektur, sistem operasi, cluster software, bagaimana

besarnya tingkat pemrosesan yang ditujukan pada cluster, berapa resources yang di


4

alokasikan untuk setiap cluster, berapa banyak cluster/ node yang dibangun, tingkat

keamanan (bisa menggunakan pfilter) dan sebagainya.

2.2 Software

Karena sifatnya sebuah uji coba dengan harapan agar dapat di implementasi dengan

mudah di praktek sebenarnya, maka saya gunakan VMware Workstation 8.0.0 build-

471780. Semua node baik master maupun slave nantinya akan berjalan didalam VMware

dengan alokasi sumber daya setiap node nya sesuai kebutuhan yang diperlukan didalam

praktek tulisan ini.

3. GNU/ Linux Cluster Setup

3.1 OpenMOSIX

3.1.1 Hardware dan Topologi

Disini saya menggunakan topologi fully connected dimana setiap node

dapat melakukan request satu sama lain.

Untuk spesifikasi hardware masing-masing node saya alokasikan cukup dengan

memori sebesar 256MB dan storage sebesar 8GB. Banyaknya node sesuai dengan

kebutuhan riset anda dan semakin besar data yang ingin diolah, tentu semakin besar

pula resource yang harus disediakan.


5

Namun jangan khawatir masalah kompleksitas dan oldest version yang

mungkin muncul jika kita menggunakan OpenMosix, The OpenMosix community

has provided numerous ways for new users to easily and rapidly build clusters

(Latter, Ian. (2006). How To - Instant openMosix). OpenMosix dengan konsep load

balancing yang berjalan pada level kernel telah menyediakan sejumlah besar cara

yang mudah dan cepat sebagai solusi bahkan untuk user pemula sekalipun.

OpenMosix menjadi sebuah fitur yang terpenting di kernel didalam masalah

pendistribusian proses.

Mekanisme preemptive process migration (PPM) merupakan teknologi

yang digunakan oleh OpenMosix dimana sebuah proses tidak dapat dihentikan

sebelum waktunya.

OpenMosix tidak memiliki kontrol pusat atau hubungan master/ slave

diantara node-node, tiap node bisa berjalan sebagai sistem yang berjalan secara

otomatis, dan OpenMosix membuat semua keputusan kontrol secara independen

(Laksono, Mutiara, dan Heruseto, 2004)

3.1.2 Sistem Operasi dan Software

Dua distro GNU/ Linux saya gunakan dalam uji coba ini, meskipun

keduanya tergolong ancient distro, namun hanya dengan mengganti kernel vanilla

lama dengan versi minor 3.1.x maka akan terlihat baru . Fedora Core 1 mesin

i386 (dengan kernel vanilla 2.4.22) dan Slackware 10.0 mesin x86 (dengan kernel

vanilla 2.4.26) saya gunakan sebagai contoh.

Untuk software nya sendiri, silahkan download beberapa packages berikut:

a. openMosix-kernel-2.4.26-openmosix1.i386.rpm

b. openmosix-tools-0.3.6-2.i386.rpm

c. openMosix-2.4.24-2.bz2

d. linux-2.4.24.tar.bz2 (from http://kernel.org/)

e. openmosix-tools-0.3.6-2.tar.gz

f. openMosixview-1.3-redhat72.i386.rpm

g. openMosixview-1.3.tar.gz


6

h. povlinux-3.6.tgz

Sebagai catatan, beberapa paket diatas terdapat penyesuaian jika distro yang

digunakan berbasis selain RPM dan Debian, maka kita harus melakukan patching

kernel mosix sesuai dengan versi kernel yang digunakan, Slackware salah satunya

(dalam kasus ini saya downgrade kernel di slackware dari kernel vanilla awal ke

kernel 2.4.24). Namun cukup dengan meletakkan patch kernel tersebut ke direktori

source kernel asli kemudian menggunakan parameter bzcat openMosix-2.4.24-

2.bz2 | patch Np1 .

Kemudian kegiatan compiling kernel dengan make config atau make

oldconfig atau make menuconfig dan symbolic link agar folder kernel terlihat rapi

menjadi wajib bagi pengguna Slackware dengan menentukan module kernel mana

yang perlu dan tidak diperlukan, apakah kita menggunakan metode built-in/

monolitik [*] atau module . Setelah selesai, lakukan perintah make clean &&

make bzImage && make modules && make modules_install . Salin file bzImage

didalam folder arch/i386/boot/ menuju folder /boot/ dengan nama vmlinuz-

.

Sebenarnya cukup dengan langkah tersebut dalam kompilasi kernel, namun

ada beberapa case dimana kita memerlukan atau membuat initial ramdisk atau

initrd serta menyalin System.map hasil kompilasi ke folder /boot/ .

Jangan lupa juga me-disfungsi layanan-layanan yang saat ini tidak

diperlukan seperti acpid, apmd, atd, gpm, kudzu, portmap, sendmail, smartd, dan

lainnya dengan parameter chkconfig off. Jadi, ketika saya

melakukan tes kondisi server benar-benar dalam keadaan clear tanpa load yang

tinggi. Untuk sistem operasi Fedora, set value default ke nilai 0 pada

/boot/grub/menu.lst , kemudian grub-install untuk partisi yang

telah kita tanamkan sistem operasi tersebut.


7

3.1.3 Rancangan, Tes dan Hasil

Saat semua requirement sudah kita siapkan, kita sudah bisa tes dengan

masuk kedalam kernel openMosix yang telah di patch tersebut dan melakukan

instalasi aplikasi pendukung seperti openmosix-tools-0.3.6-2.i386.rpm dan

openMosixview-1.3-redhat72.i386.rpm (lakukan instalasi di Fedora dengan

parameter rpm -ivh ) serta openmosix-tools-0.3.6-2.tar.gz dan

openMosixview-1.3.tar.gz (lakukan instalasi di Slackware dengan tahap ./configure

&& make && make install).


8

Ketika aplikasi selesai di install, kita akan mendapati node yang terdaftar

untuk setiap node yang terhubung pada file /etc/openmosix.map atau jalankan

perintah showmap yang akan muncul hasilnya dengan format:

Pada slackware, kita bisa daftarkan secara manual di file

/etc/openmosix.map seperti contoh berikut:


9

Ketika seluruh node yang dibutuhkan terhubung, kita bisa lakukan

pengecekkan apakah pendistribusian proses berjalan sempurna atau tidak dengan

membuat script perl sederhana, kemudian simpan dengan nama tes.sh dan berikan

akses executable melalui chmod +x tes.sh:

#!/usr/bin/perl

$i=1;

while($i){

$i++;

}

Kemudian jalankan pada salah satu node dengan mode background ./tes.sh & secara

redundan dan lakukan monitor dengan parameter mosmon seperti berikut:


10

Kita bisa melihat bahwa proses didistribusikan secara rapi ke setiap node.

Dari sini kita bisa lakukan kembali pengujian dengan proses rendering image

menggunakan aplikasi povlinux-3.6.tgz . Sebagai informasi, aplikasi POV-Ray

(The Persistence of Vision Raytracer) yang memiliki official site di

www.povray.org ini adalah sebuah free tool yang digunakan untuk menciptakan

sebuah stunning three-dimensional graphics serta banyak kegunaan yang lainnya.

Kemudian lakukan instalasi dengan parameter tar zxvf povlinux-3.6.tgz &&

cd povray-3.6 && ./install . Setelah itu kita sudah bisa memanggil fungsi povray

untuk menjalankan sebuah perintah khusus untuk melakukan rendering image.

Sebagai contoh, saya menggunakan sample yang lebih berat daripada

menggunakan contoh bawaan didalam folder scenes yakni me-render sebuah image

ak47 dan sci-fi seperti dalam film yang dapat didownload di

http://www.oyonale.com dan dijalankan dengan parameter povray ak47.pov &&

povray scifi_demo.pov seperti berikut:


11

Setelah kita jalankan, kita bisa lihat bagaimana kernel melakukan

pendistribusian dan penjadwalan proses untuk melakukan tugas rendering image

tersebut. Pemindahan proses terjadi hanya jika kernel merasa bahwa sudah

mencapai sebuah titik jenuh setelah mengerahkan seluruh resource mandiri yang

dimiliki.


12

Disini terlihat node lain menunggu untuk diberikan beban untuk membantu proses

rendering/ buffering image. Seluruh catatan interval waktu dan alokasi memori

yang digunakan dapat kita lihat pada display konsol node.

Melalui tools yang telah disediakan oleh OpenMosix organization, kita

dapat melakukan instalasi berbagai keperluan baik untuk mengatur limit kecepatan


13

proses setiap node, melakukan analisis dari log yang dihasilkan untuk setiap proses

node, dan sebagainya. Beberapa kegunaan yang bisa kita peroleh:

openMosixView : Aplikasi utama untuk administrasi+monitor.

openMosixprocs : Sebuah process-box untuk mengelola proses.

openMosixcollector : Koleksi daemon yang mana berisi informasi mengenai

cluster+node.

openMosixanalyzer : Untuk menganalisis data yang dikumpulkan oleh

openMosixcollector.

openMosixhistory : History proses dari cluster.

3dmosmon : Tampilan 3D untuk memonitor cluster.


14


15

3.2 MPI (Message Passing Interface)


Disini saya masih menggunakan topologi fully connected dimana setiap

node dapat melakukan request satu sama lain.

Untuk spesifikasi hardware masing-masing node saya alokasikan memori sebesar

128MB, storage sebesar 15GB dan processor minimum, yakni single core.

Kembali saya informasikan bahwa banyaknya node sesuai dengan kebutuhan riset

anda dan semakin besar data yang ingin diolah, tentu semakin besar pula resource

yang harus disediakan.

Message Passing Interface (MPI) pada dasarnya merupakan sebuah

gagasan atau metode bagaimana menyelesaikan masalah secara bersama-sama pada

waktu yang bersamaan, tanpa adanya waktu tunggu untuk selanjutnya

didistribusikan kepada node yang lain untuk diselesaikan. Memanfaatkan berbagai

macam algoritma dan fungsi pemrograman paralel, kita bisa mengambil banyak

keuntungan dari metode ini karena implementasinya bisa kita gabungkan dengan

teknologi Network File System (NFS) dan thin client (penamaan di Windows) atau

Linux Terminal Server Project (LTSP) atau Fully Automatic Installation (FAI)


16

dimana node tidak memiliki media penyimpanan atau diskless. Pemanfaatan jenis

prosesor-prosesor lama juga menjadi sebuah alternatif tersendiri bagi dunia riset.

Message Passing Interface (MPI) ini digunakan untuk komputasi paralel

dalam sistem yang terdistribusi. Pengguna MPI dapat menuliskan programnya

dengan bahasa C, C++, FORTRAN77, dan FORTRAN90 untuk menjalankannya

secara paralel dengan memanggil rutin library yang sesuai (Ajinagoro, Bagus

Irawan. (2005). Aplikasi Sistem Paralel Menggunakan Prosesor Host 486 Berbasis

Linux Debian).


Distro GNU/ Linux yang saya gunakan adalah Debian Sarge 3.1 yang hanya

menggunakan 5 CD mirror dari total 14 CD guna mengatasi dependency paket.

Untuk software pendukung, saya hanya membutuhkan package

mpich.tar.gz (anda bisa saja menggunakan lam) dan rcconf installer untuk .deb.

Jika kita cukup iseng agar mengetahui performance dari sepesifikasi atau

requirement node kita yang tidak seragam mulai dari sisi core, RAM, dan cache

memory, silahkan download juga perftest.tar .


Jika telah selesai melakukan instalasi distro Debian dan menghidupkan

beberapa service yang penting dengan fungsi rcconf seperti berikut:


17

Lakukan instalasi paket mpich.tar.gz dengan parameter tar zxvf mpich.tar.gz &&

cd mpich && ./configure --prefix=/usr/local/src/mpich | tee konfigurasi.log &&

make | tee make.log && make install . Opsi prefix akan mengantarkan direktori

hasil instalasi ke /usr/local/src/mpich. Yang pertama dan paling utama, pastikan

bahwa masing-masing node mendaftarkan nama hostname satu sama lain seperti

berikut:


18

Setelah itu, daftarkan setiap node di masing-masing node pada file

machines.LINUX di path /usr/local/src/mpich/share/ seperti berikut:

Karena konsep dari MPI atau komputasi paralel ini menyebabkan

pemrosesan tambahan, seperti kemampuan penggunaan data bersama-sama. Maka

diperlukan komunikasi passwordless dua arah diantara pemroses atau node yang


19

terhubung. Kita harus membuat antar node bisa autologin seperti matriks yang saya

gambarkan berikut ini:

Cluster Cluster

Sarge-3.1 Sarge-3.1-1 Sarge-3.1-2 Sarge-3.1-3

Sarge-3.1 >< >< ><

Sarge-3.1-1 >< >< ><

Sarge-3.1-2 >< >< ><

Sarge-3.1-3 >< >< ><

Ketika semuanya sudah berjalan lancar, kita bisa jalankan parameter berikut

pada direktori examples yang telah disediakan oleh mpich, make cpi &&

/usr/local/src/mpich/bin/mpirun -arch LINUX np 4 cpi dan hasilnya akan terlihat

bagaimana setiap node prosesor memberikan kontribusi secara paralel dalam

menjalankan sebuah task sederhana.

Saya lakukan empat kali pengujian untuk 4 node secara paralel, 3 node

secara paralel, dan 2 node secara paralel yang secara rekursif, serta hanya 1 node

independen.


20

Percobaan 1 (4 node paralel)

Node Frekuensi

Debian-Sarge3.1 :: Debian-Sarge3.1-1 :: Debian-Sarge3.1-2 :: Debian-Sarge3.1-3

1 0.001183

0.002206

0.002399

0.001472

0.000825

0.000913

0.000621

0.001818

0.001155

0.001994

2

3

4

5

6

7

8

9

10

Mean(Rerata)(s) 0.001459


Node Frekuensi

Debian-Sarge3.1 :: Debian-Sarge3.1-1 :: Debian-Sarge3.1-2

1 0.000337

0.000455

0.000320

0.000665

0.000261

0.000771

0.000452

0.000454

0.000534

0.000248

2

3

4

5

6

7

8

9

10



21


Node Frekuensi

Debian-Sarge3.1 :: Debian-Sarge3.1-1

1 0.000174

0.000226

0.000123

0.000132

0.000124

0.000153

0.000390

0.002030

0.000198

0.000193

2

3

4

5

6

7

8

9

10


Percobaan 4 (1 node)

Node Frekuensi

Debian-Sarge3.1

1 0.000029

0.000024

0.000030

0.000023

0.000023

0.000029

0.000026

0.000028

0.000029

0.000024

2

3

4

5

6

7

8

9

10


Kemudian plot[11] yang telah saya buat dari seluruh hasil percobaan diatas

melukiskan grafik perbedaan kecepatan pemrosesan yang sangat jelas:


22

Untuk hasil perftest nya sendiri, jika kita menggunakan sumber daya yang

heterogen dapat dilihat sebagai berikut:


23

3.3 Beowulf


Saya masih menggunakan topologi fully connected untuk uji coba kali ini,

bedanya satu node pusat tidak ikut melakukan pemrosesan data, hanya sebagai

pusat kendali proses untuk setiap node yang terhubung. Sebenarnya anda bisa saja

menggunakan switch sebagai alternatif lain.

Sebagai sebuah informasi, Beowulf merupakan koleksi atau kumpulan dari node-

node terintegrasi dengan aplikasi-aplikasi yang ditujukan untuk keperluan

komputasi. Beowulf dapat digunakan untuk solusi komputasi yakni sebagai aplikasi

HA (High Availibility) atau HP (High Performance).

A Beowulf cluster is a MIMD multiprocessor built from commodity off-

the-self personal computers connected via a dedicated network, running free open-

source software. Such a cluster can provide a supercomputers performance at a

small fraction of ones cost (Adams and Vos. (2001). Small-College

Supercomputing).


24

Node RAM yang saya gunakan pada percobaan ini sebesar 512MB, HDD

16GB dan 1024MB, HDD 16GB (untuk head node).


Distro GNU/ Linux yang saya gunakan adalah Ubuntu-11.10 amd64 dengan

4 buah node (satu sebagai head node). Untuk packages yang saya gunakan adalah

sebagai berikut:

a. nfs-kernel-server (head node)

b. nfs-client (others node)

c. scisoft packages (head node)(Optional)

d. mpich2 library (head+others node)

e. mpi4py-0.6.0.tar.gz (head+others node)

f. torque-4.1.7.tar.gz (head+others node)

g. iraf.lnux.x86_64.tar.gz (head node)

Berikut saya sajikan juga flowchart untuk keperluan tes ini menurut salah

satu proceedings yang telah ditulis oleh Navtej Singh didalam Parallel

Astronomical Data Processing or How to Build a Beowulf Class Cluster for High

Performance Computing?. Meskipun tidak terlalu textbook seperti yang

digambarkan, saya coba implementasikan dengan tahap yang cukup mudah untuk

dipahami.


25


26


Setelah seluruh packages dipersiapkan sesuai dengan kebutuhan masing-

masing node, jangan lupa untuk mendaftarkan hostname setiap node ke masing-

masing node yang terhubung sehingga dapat melakukan request dan akses yang

passwordless satu sama lain (Silahkan dilihat pada percobaan sebelumnya di tulisan

ini).

Kemudian kita buat user mpi (mpiu) dengan parameter berikut: useradd --

base-dir /home/mpiu --create-home --shell /bin/bash U mpiu dan atur password

untuk user tersebut. Saya pilih NFS server sebagai aplikasi share file sehingga node

yang lain yang cukup melakukan instalasi NFS client agar bisa memanfaatkan file

tanpa perlu ada di fisik node tersebut (Anda bisa menggunakan glusterfs sebagai

alternatif nya). Gunakan parameter berikut di sisi head node: mkdir -p /mirror/mpiu

&& chown -R mpiu:mpiu /mirror/mpiu . Jadi, direktori atau seluruh isi didalam

direktori /mirror/mpiu dimaksudkan agar dapat diakses dan dimanfaatkan oleh

node lain. Hal lain yang harus kita daftarkan adalah alamat dan hostname dari node

pada file /etc/exports seperti berikut:

Di sisi node yang lain, lakukan registrasi nfs dengan parameter berikut

mount -t nfs -o async :/mirror/mpiu /mirror/mpiu dan

masukan parameter tersebut pada file /etc/fstab agar dapat mounted secara otomatis.

Jika tidak ada masalah, setiap node akan mendapatkan akses share untuk direktori

di head node tersebut:


27

Setelah itu, instalasi paket iraf.lnux.x86_64.tar.gz untuk me-set terminal type dari

IRAF sebagai xgterm untuk user mpiu didalam direktori /home/mpiu dengan

parameter berikut tar zxvf iraf.lnux.x86_64.tar.gz && ./install && cd /home/mpiu

&& mkiraf .

Selanjutnya instalasi paket dari torque yang berfungsi untuk mangatur

sumber daya dari proses PBS (The Portable Batch System) secara free. cd

/usr/local/src/ && tar zxvf torque-4.1.7.tar.gz && cd torque-4.1.7 && ./configure

--prefix=/opt/torque --with-server-home=/opt/torque/spool --enable-server --

enable-clients --with-scp --enable-mom && export

PATH=$PATH:/opt/torque/sbin:/opt/torque/bin && make && make install &&

make packages .

Proses dari instalasi diatas akan menghasilkan beberapa torque-packages

seperti berikut:


28

Salin torque-package mom dan clients ke direktori /mirror/mpiu agar dapat

dimanfaatkan dan di instalasi oleh node yang lain (torque-package--linux-

x86_64.sh --install). Kemudian yang juga penting, salin file debian.pbs_server di

head node direktori contrib/init.d/ ke /etc/init.d/ dengan nama pbs_server dan file

debian.trqauthd ke /etc/init.d/ dengan nama pbs_trqauthd . Kemudian jalankan

update-rc.d pb_server defaults dan /etc/init.d/pbs_trqauthd start . Lakukan hal ini

untuk node client yang lain tentunya dengan beberapa penyesuaian file yang

digunakan.

Setelah semua layanan telah running, kita inisialisasi serverdb dan lakukan

restart di head node dengan parameter: pbs_server -t create &&

/etc/init.d/pbs_server restart . Daftarkan dan checking setiap node yang terhubung

ke head node dengan parameter berikut: qmgr -c create node

&& pbsnodes -a . Kita buat sebuah file script python di head node, untuk

mengujinya, simpan dengan nama helloworld.py pada direktori /mirror/mpiu

karena pemrosesan melibatkan seluruh node.


29

Jalankan parameter berikut di /mirror/mpiu : mpiexec -n 10 -host

,, python helloworld.py

Opsi n adalah banyaknya beban proses yang dapat kita berikan pada node agar

dapat diselesaikan secara paralel. Silahkan mencoba

4. Cluster Tools

4.1 OSCAR (Open Source Cluster Application Resources)

4.1.1 OSCAR Architecture

Sebuah alternatif yang ditawarkan OSCAR adalah sebuah kemudahan

(eliminating the downloading, installation, and configuration of individual

components) dalam membangun sebuah cluster di GNU/ Linux. Meskipun faktanya

OSCAR tidak hanya dapat digunakan untuk kepentingan High Performance


30

Computing (HPC), namun dapat digunakan sebagai dasar membangun High

Availibility (HA) cluster, hingga dapat di intergrasikan dengan floppy disk/ kickstart

pada saat kegiatan cloning untuk node (meskipun pada saat sekarang ini, penulis

menggunakan teknologi clone untuk node di VMware).

Berikut arsitektur yang saya gunakan dalam prakteknya, dimana peran

cluster dalam komputasi modern ini menerapkan Non-Uniform Memory Access

(NUMA) atau yang biasa disebut asymmetric multiprocessors (SMP), yakni secara

sederhana menjelaskan bagaimana CPU mengakses seluruh memori fisik

berdasarkan address map dari memori yang di share oleh setiap node cluster.

Pada head node bertugas mendistribusikan proses, file, dan image (jika kita

menggunakan mode instalasi melalui tftpboot dan floppy image) ke setiap node.

4.1.2 Mengelola OSCAR

Pada bagian ini saya tidak membahas bagaimana cara mengelola oscar ikan,

atau beternak dari bibit ikan oscar (mungkin Insya Allah lain kali saya diberikan

kesempatan untuk usaha ke arah sana). Baik, beberapa kelengkapan yang harus

disiapkan adalah sebagai berikut:


31

Redhat.9-Shrike (3 CDs untuk keperluan me-build image untuk node)

oscar-3.0.tar.gz

mpich.tar.gz

j2sdk-1.3.1-FCS-linux-i386.tar.bz2

Pada tahap ini kita fokus hanya pada head/ master dimana seluruh proses

dan file image akan didistribusikan dari head ke node. Proses ini memerlukan

direktori yang harus kita ciptakan di hierarki / (slash) dan menyalin seluruh rpm

packages dari 3 CD distribusi Redhat, mkdir -p /tftpboot/rpm && mount /mnt/cdrom

&& cp -pra /mnt/cdrom/RedHat/RPMS/*.rpm /tftpboot/rpm/ && eject cdrom .

Lakukan prosedur tersebut untuk setiap CD.

Berikutnya, unpack aplikasi Oscar yang telah di download sebelumnya

dengan parameter tar -zxvf oscar-3.0.tar.gz && cd oscar/ && ./configure && make

install . Namun sebelumnya jangan lupa me-set environment variables untuk OSCAR

dengan parameter OSCAR_HOME=/opt/oscar && export OSCAR_HOME . Agar

setiap sesi variable tersebut di load, daftarkan parameter ini di /etc/rc.local atau pada

profile di lingkungan shell tempat kita login atau gunakan (misalnya bashrc).

Selanjutnya kita jalankan ./install_cluster .

Jika tidak ada masalah, kita dapat melihat GUI seperti berikut:


32

Pada opsi OSCAR Packages To Install, biarkan semua paket default

dalam keadaan tercentang.


33

Berikutnya adalah kustomisasi kernel_picker dimana jika kita sebelumnya

menambahkan list kernel baru (openMosix misalnya), maka kita dapat memilih

kernel yang nantinya akan di load dengan menentukan path image dan module yang

digunakan oleh kernel tersebut.

Kembali harus kita ingat, karena pada prosedur ini kita berusaha untuk

menciptakan image berisi paket-paket aplikasi lengkap, baik scheduling dan lain-lain

yang sudah siap di tanam ke tiap-tiap node. Jadi, sesuaikan juga range IP, jumlah

node, dan MAC Address yang akan kita assign ke setiap node. Untuk setiap daftar

MAC Address yang akan digunakan, bisa kita letakkan daftarnya kedalam sebuah

file. Tentu saya tidak menjelaskan secara lebih detail untuk hal ini, namun semoga

cukup memberikan ilustrasi akan apa yang harus kita lakukan.


34


35

Setelah selesai me-build image, kita harus pastikan bahwa nama host dan

alokasi IP yang terdaftar untuk setiap node sudah sesuai yang kita inginkan. Baru

kemudian kita setup networking (sekaligus kita bisa create boot melalui floppy), pada

contoh ini saya gunakan boot order melalui floppy untuk setiap node (jika node

berjalan diatas virtual machine, jangan lupa menciptakan berkas boot floppy dengan

format .flp).


36

Tampilan diatasa adalah jika kita sukses melakukan instalasi cluster melalui order

floppy dimana nantinya seluruh file yang di share oleh head akan di proses melalui

bootftp. Kemudian bisa kita cek dan test apakah antara head dengan node telah

berkomunikasi dengan baik melalui test cluster setup.


37

Pada OSCAR, terdapat sebuah script yang dengan mudah membantu user untuk

mengubah lingkungan shell cluster. Switcher, sebuah modul paket yang bertugas

untuk itu. Pada head ataupun node dapat kita periksa paket apa yang menjadi default

untuk keperluam cluster kita, lam atau mpich. Cukup menjalankan perintah switcher

mpi --list atau switcher mpi --show maka kita akan mengetahui fiture MPI yang

sedang kita gunakan. Selanjutnya tinggal kita jalankan switcher mpi =

jika kita menginginkan perubahan.

Saya bisa menguji hasil konfigurasi diatas dengan terlebih dahulu membuat

berkas berisikan alamat host-host yang telah terhubung ke node dengan

menggunakan parameter lamboot . Kemudian dengan menggunakan

sample dari paket lam yang digunakan, kita bisa menguji cluster dalam masalah

distribusi proses komputasi (kita akan bahas selanjutnya pada bagian cluster

programming) dengan sebelumnya melakukan proses kompilasi.


38

Yang terakhir, karena kita akan membutuhkannya, jangan lupa melakukan

instalasi MPE (Multi-Processing Envireonment, yang merupakan extends library dari

MPI) melalui kode sumber, karena kelak fitur ini akan kita manfaatkan saat

melakukan profiling. Setelah kita memiliki paket mpich.tar.gz, pindahkan paket

tarball tersebut ke direktori /usr/local/src dan ekstrak dengan parameter gunzip

mpich.tar.gz && tar -xvf mpich.tar . Kita switch environment dari MPI ke mpich-

ch_p4-gcc-1.2.5.10 dan kita ekstrak source dari j2sdk-1.3.1-FCS-linux-i386.tar.bz2

di direktori yang sama dengan mpich dan kita export dengan cara berikut: export

PATH=/usr/local/src/j2sdk1.3.1/bin:$PATH && export MPI_INC=-I/opt/mpich-

1.2.5.10-ch_p4-gcc/include && export MPI_LIBS=-L/opt/mpich-1.2.5.10-ch_p4-

gcc/lib && export MPI_CC=mpicc && export MPI_F77=mpif77 . Baru kemudian

bisa kita configure, kompilasi dan install.


39

4.2 Rocks

4.2.1 Rocks Architecture

Pada dasarnya, arsitektur yang saya gunakan disini adalah sama dengan

yang diterapkan pada OSCAR, yakni NUMA architecture.

Metode yang digunakan pada Rocks ini juga tidak jauh berbeda, yakni

menggunakan protokol yang biasa digunakan untuk data shared sehingga dalam

implementasinya memudahkan user dalam hal node clone dan distribusi berkas.

Satu lagi yang harus saya informasikan adalah bahwa Rocks ini menggunakan

sistem roll dalam hal pemaketan aplikasi. Jadi, kita harus mengumpulkan rolls

mana saja yang sesuai dengan kebutuhan kita. Pada Rocks juga disediakan sebuah

aplikasi web frontend (tampilan dan fungsinya cukup familiar bagi para user yang

pernah menggunakan cacti atu nagios) bernama ganglia. Aplikasi tersebut

berfungsi untuk me-manage host yang terdaftar, baik penggunaan dari sisi

resources ataupun process yang berjalan.

Beberapa requirement i386 (yang saya pilih) yang harus dipersiapkan:


40

a. kernel-5.2-0.i386.disk1 (wajib)

b. os-5.2-0.i386.disk1 (wajib)

c. os-5.2-0.i386.disk2 (wajib)

d. base (wajib)

e. area51+ganglia+hpc+java+sge+web-server+xen-24.06.2009-

10.02.44.i386.disk1 (optional)

Ini merupakan prerequisites dimana bukan merupakan bundle dari Rocks.

4.2.2 Mengelola Rocks

Pada tampilan awal instalasi, kita diwajibkan mengetikkan frontend atau

build ketika ingin pertama kali membuat sebuah head/ master node. Karena

implementasinya menggunakan old kernel (anda dapat mengkajinya secara mandiri

jika menginginkan level kernel yang lebih tinggi), maka tipe dari harddisk yang

saya gunakan adalah IDE agar dapat dibaca dengan baik oleh sistem.


41

Berikutnya kita masukkan roll-roll CD guna membangun Rocks.


42


43

Jika tidak ada masalah saat proses instalasi, kita akan diminta menentukan kartu

jaringan yang terhubung ke jaringan internet dan lokal, antara eth0 dan eth1.

Lakukan proses ini untuk setiap node yang didaftarkan. Kemudian pada terminal/

konsol di master/ head, kita jalankan parameter insert ethers. Parameter tersebut

akan mengenali kartu jaringan yang terhubung secara lokal ke setiap node.

Selanjutnya, pada master/ head dapat kita cek setiap host/ node yang terhubung

dengan menggunakan aplikasi ganglia dengan mengakses

http:///ganglia


44


45


46

5. Cluster Programming

Pada section ini akan saya bahas sedikit mengenai salah satu library pemrograman yang

sudah kita gunakan sebelumnya, yakni Message Passing Interface (MPI). Untuk itu diperlukan

sebuah case agar dapat sedikit mendeskripsikan bagaimana library ini bekerja.

Inti dari MPI sudah sama-sama kita ketahui pada praktikum saat menjalankan mpirun di

bagian MPI didalam tulisan saya ini. Sebagai catatan, selalu gunakan parameter berikut

sebelum menjalankan program yang telah ditulis: mpicc -o .c &&

mpirun -np 4 . Jalankan script pada lokasi shared NFS.

MPI_Init

MPI_Init digunakan untuk menginisialisasi session dari MPI. Semua program MPI harus

menggunakan call ini sebelum functions lain dari MPI dipanggil, meskipun ada beberapa

pengecualian yakni MPI_Initialized yang dapat dipanggil sebelum MPI_Init dimana fungsi

tersebut berfungsi untuk melihat apakah MPI_Init sebelumnya telah dipanggil.

MPI_Finalize


47

MPI_Finalize dipanggil untuk me-shutdown MPI, dimana call ini dipanggil di bagian

terakhir program.

MPI_Comm_size

Routine ini digunakan untuk menentukan jumlah keseluruhan proses yang berjalan didalam

sebuah komunikator (MPI_COMM_WORLD; digunakan untuk membedakan proses-proses

yang berjalan kedalam sebuah kelompok tertentu). Yang menjadi point utama saat kita

menjalankan sebuah script adalah jumlah dari proses ini bukan merujuk pada jumlah dari

mesin yang digunakan.

MPI_Comm_rank

MPI_Comm_rank digunakan untuk menentukan rank atau peringkat dari proses yang

berjalan saat ini didalam komunikator (MPI_COMM_WORLD). Pada dasarnya, setiap proses

diberikan rank dari 0 hingga jumlah proses yang diberikan pada MPI_Comm_size. Sebagai

contoh, jika kita menjalankan 5 buah proses, setiap proses individu akan diberikan penomoran

0,1,2,3, dan 4. Berikutnya, pada saat pemrosesan setiap rank akan menentukan perannya

masing-masing dalam menyelesaikan masalah. Apakah rank 0 akan bekerja pada bagian

pertama dari penyelesaian masalah, baru kemudian rank 1 yang akan bekerja pada bagian yang

lain, dan seterusnya.

MPI_Get_processor_name

MPI_Get_process_name digunakan untuk mengambil nama host dari setiap mesin cluster.

Kita perlu ingat, bahwa kecepatan pemrosesan bergantung pada spesifikasi perangkat

lunak/ keras setiap mesin, load dari mesin cluster, dan jaringan yang terhubung antar mesin

cluster.

Perumusan Masalah

Disini saya coba membuat contoh dalam penyelesaian sebuah kasus perhitungan integrasi

numerik, ide nya adalah mencari luas ruang dari setiap persegi panjang yang ada didalam

kurva. Dimana tinggi dari persegi panjang merupakan nilai tengah dari sumbu X yang

dikuadratkan dalam fungsi f(x) = x * x . Namun, penentuan jumlah dari persegi panjang atau

rectangle ini dapat kita tentukan dari batas tertinggi dan batas terendah di koordinat (upper

limit dan lower limit).


48

Saya coba memasukkan jumlah rectangle sebanyak 6 buah dan batas tertinggi dan terendah

adalah 2 dan 5. Algoritma nya saya tuliskan terlebih dahulu dalam bentuk bahasa C yang nanti

dapat kita jalankan setelah proses kompilasi, baru kemudian kita terapkan dalam programming

library MPI. Berikut ilustrasi berupa plot graph yang telah saya buat beserta algoritma nya.

Algoritma sederhana diatas dapat kita pahami bahwa lebar atau jarak dari titik 2 ke 3, 3 ke

4, dan 4 ke 5 memiliki nilainya masing-masing mengikuti pola atau pattern dari width =


49

(upperLimit-lowerLimit) / numberRects; . Begitu juga nilai tengah yang bakal menjadi

penentu perhitungan tinggi dari rectangle dapat dilihat dari variabel at . Telah saya coba

jelaskan dengan komentar-komentar pada script diatas dengan tag /* */ .

Jika kita telah memahami algoritma diatas, maka kita dapat menulis solusi nya dengan

pemrograman MPI seperti berikut.

#include "mpi.h"

#include

/* problem parameters */

/* caution: this code keeps number of rectangles rather than adjust it to the number of processes, we'll try then */

#define f(x) ((x) * (x))

#define numberRects 6

#define lowerLimit 2.0

#define upperLimit 5.0

int main ( int argc, char * argv[] )

{

/* MPI variables */

int dest, noProcesses, processId, src, tag;

MPI_Status status;

/* problem variables */

int i;

double area, at, height, lower, width, total, range;

/* MPI setup, the MPI_COMM_WORLD is default communicators */

/* Communicators are used to distinguish and group messages */

MPI_Init(&argc, &argv);

MPI_Comm_size(MPI_COMM_WORLD, &noProcesses); /* It would be a part which is process presented by

rectangle. Keep in your mind that processes aren't necessarily the number of machines being used */

MPI_Comm_rank(MPI_COMM_WORLD, &processId);

/* adjust problem size for subproblem */

range = (upperLimit - lowerLimit) / noProcesses;

width = range / numberRects;

lower = lowerLimit + range * processId;

/* calculate area for subproblem */

area = 0.0;

for ( i=0; i


50

{

at = lower + i * width + width / 2.0;

height = f(at);

area = area + width * height;

}

/* collect information and print results. New stuff: one process will act as a collector to which the remaining

process will send their results. Using the rank 0 as the receiver is the logical choice. The remaining processes act as a

senders */

/* In here, we determines what will be done by the collector process and what will be done by all the remaining

processes */

tag = 0;

/* Below, the first branch will be executed by the single process with rank of 0 */

/* For example, for 100 processes, there are 99 calls to MPI_Send and 99 calls to MPI_Recv. (Process 0 already

knows what it calculated) */

if (processId == 0) /* if rank is 0, collect results from one of the other processes */

{

total = area;

for (src=1; src < noProcesses; src++) /* Loop that will execute once for each of the remaining nodes

in the cluster */

{

MPI_Recv(&area, 1, MPI_DOUBLE, src, tag, MPI_COMM_WORLD, &status);

total = total + area;

}

fprintf(stderr, "The area from %f to %f is: %f\n", lowerLimit, upperLimit, total);

}

/* Below, the second branch will be executed by each of the remanining processes */

else /* all other processes only send */

{

dest = 0;

MPI_Send(&area, 1, MPI_DOUBLE, dest, tag, MPI_COMM_WORLD); /* &area gives the address

of the data, dest is the rank of the receiver and both of destination and source is followed by a tag */

};

/* Finally, you should be aware that MPI_Send and MPI_Recv are both blocking calls. For example, if you try

to receive information that hasn't been sent, your process will be blocked or wait until it is sent before it can continue

executing */

/* finish */

MPI_Finalize();

return 0;

}


51

Dari kode-kode diatas dapat kita lihat kembali bahwa pada bagian logika percabangan

perlu menggunakan sebuah receiver dimana pada rank inilah kita menyimpan informasi/ status

dari proses. Secara logis, rank 0 dapat kita gunakan sebagai patokan awal untuk selanjutnya

sender kembali mengirimkan proses ke address range yang status sebelumnya telah diterima

oleh rank 0 dan seterusnya. Telah diingatkan juga bahwa kemungkinan-kemungkinan dari

proses ini akan menimbulkan blocking calls dimana jika informasi dari proses belum di

kirimkan ke destination (receiver), maka proses akan blocked atau berubah status menjadi wait

hingga proses selesai dikirim untuk kemudian dilanjutkan untuk dieksekusi.

MPI_Send

MPI_Send digunakan untuk mengirimkan informasi dari satu proses ke proses lainnya,

dimana korespondensi argumen dari call MPI_Send harus sesuai dengan korespondensi

argumen call di MPI_Recv, baik type dan tag nya. Kemungkinan lain penggunaan tipe data

yang dikirim adalah MPI_BYTE, MPI_CHAR, MPI_UNSIGNED, MPI_SHORT, dan

sebagainya. Sedangkan untuk tag secara default adalah menggunakan MPI_COMM_WORLD.

MPI_Recv

Argumen yang digunakan adalah kurang lebih sama dengan MPI_Send tetapi dengan

tambahan status field. MPI_STATUS sendiri merupakam sebuah struktur yang menyimpan

informasi tentang aktual size, source, dan tag dari pesan yang diterima.

Pada solusi script diatas tentu kita menyadari bahwa parameter-parameter secara individu

telah dikirim sekali pada satu waktu (untuk setiap proses). Sebagai contoh, jika kita

menggunakan 10 proses, ketika proses 0 berkomunikasi dengan proses 1, maka proses 2

sampai dengan 9 berada dalam keadaan idle. Ketika proses 0 berkomunikasi dengan proses 2,

maka proses 3 sampai dengan 9 berada dalam keadaan idle. Hal ini mungkin tidak menjadi

sebuah masalah yang besar jika kita hanya menjalankan setengah lusin proses, namun jika kita

menjalankan proses ini pada 1000 mesin tentu akan berdampak sangat besar dan membuang-

buang waktu. Pokok utamanya adalah bagaimana script menjadi efektif dan efisien.

MPI_Reduce

Berfungsi mengumpulkan data yang telah di olah dengan mengambil alamat proses dari

data yang diolah, menentukan tipe data baik penjumlahan (MPI_SUM) hingga logical dan


52

bitwise seperti AND, OR, XOR (MPI_LAND, MPI_LOR, MPI_LXOR, dsb), dan lainnya yang

dihimpun didalam sebuah argumen khusus seperti layaknya fungsi-fungsi yang lain.

MPI_Bcast

MPI_Bcast menyediakan sebuah mekanisme untuk mendistribusikan informasi pada saat

yang bersamaan ke setiap kelompok proses (hal ini dapat secara default ditangani secara

background oleh komunikator). Berikut sample script yang saya buat dengan menggunakan

mekanisme I/ O.

#include "mpi.h"

#include

/* We have eliminated the control structures with these codes */

/* Then MPI_Bcast provides an alternative for us ;) */

/* Problem Parameters */

#define f(x) ((x) * (x))

int main( int argc, char * argv[] )

{

/* MPI Variables */

int noProcesses, processId;

/* problem variables */

int i, numberRects;

double area, at, height, lower, width, total, range;

double lowerLimit, upperLimit;

/* MPI Setup */

MPI_Init(&argc, &argv);

MPI_Comm_size(MPI_COMM_WORLD, &noProcesses);

MPI_Comm_rank(MPI_COMM_WORLD, &processId);

if (processId == 0) /* if rank is 0, collect parameters */

{

fprintf(stderr, "Enter number of steps:\n");

scanf("%d", &numberRects);

fprintf(stderr, "Enter low end of interval\n");

scanf("%lf", &lowerLimit);

fprintf(stderr, "Enter high end of interval:\n");

scanf("%lf", &upperLimit);


53

}

MPI_Bcast(&numberRects, 1, MPI_INT, 0, MPI_COMM_WORLD);

MPI_Bcast(&lowerLimit, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);

MPI_Bcast(&upperLimit, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);

/* adjust problem size of subproblem */

range = (upperLimit - lowerLimit) / noProcesses;

width = range / numberRects;

lower = lowerLimit + range * processId;

/* calculate area of subproblem */

area = 0.0;

for (i=0; i < numberRects; i++)

{

at = lower + i * width + width / 2.0;

height = f(at);

area = area + width * height;

}

/* MPI_reduce has seven arguments like these that functionally to specify a data item to be accumulated, a storage

location or variable to accumulate in, and an operator to use when accumulating */

MPI_Reduce(&area, &total, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); /* The third argument

is the number of elements int the send buffer */

/* collect information and print results */

if (processId == 0) /* if rank is 0, print results */

{

fprintf(stderr, "The area from %f to %f is: %f\n", lowerLimit, upperLimit, total);

}

/* Finally, "broadcast" in MPI_Bcast simply means that the data is sent to all the processes. It does not necessarily

imply that an Ethernet-style broadcast will be used, although that is one obvious implementation strategy */

/* finish */

MPI_Finalize();

return 0;

}

Pada tag argumen pertama dari call MPI_Bcast merupakan address dari data yang di buffer

untuk selanjutnya akan di broadcast, baik jumlah rectangle, posisi tertinggi dan terendah


54

ordinat. Argumen kedua merupakan jumlah dari item yang di buffer. Argumen ketiga

merupakan tipe data, argument keempat merupakan rank dari proses yang me-generate

broadcast, pada contoh digunakan 0 sebagai call root nya (bukan sebuah keharusan

menggunakan rank 0, bisa kita pilih rank yang lain). Argumen terakhir merupakan default

communicator yang secara efektif mendefinisikan proses mana yang berpartisipasi untuk di

broadcast. Bagusnya lagi, MPI_Bcast ini membandingkan antara satu rank dengan rank proses

yang lain untuk dapat menentukan proses mana yang mengirim dan menerima data, sehingga

didalam script tidak diperlukan struktur kontrol tambahan .

6. Debugging dan Profiling

Disini saya tidak berbicara perihal IDE (Integrated Development Environment) yang ada

di sistem proprietary. Ada beberapa tools yang bisa menjadi debugger dan kita gunakan untuk

mengoreksi kode-kode pemrograman yang kita buat seperti gdb (GNU Debugger) dan ddd

(Data Display Debugger).

Untuk mengukur seberapa efektif dan efisien kode pemrograman yang telah kita tulis pada

section Cluster Programming di atas, kita bisa saja menjadikan waktu pemrosesan sebagai

tolak ukur seberapa cepat mesin cluster kita memberikan solusi dari sebuah masalah. Namun

secara umum di lingkungan GNU/ Linux tidak selamanya fungsi tools seperti time (untuk

melihat waktu eksekusi di sesi real, user dan sys (kernel)) di garansikan mampu di integrasikan

dengan fungsi mpirun pada seluruh versi MPI. Maka, gunakan saja MPE (sebagai alternatif

dari gprof (GNU Profiler) dan gcov (GNU Coverage)) yang sebelumnya telah kita instalasi

pada section OSCAR. Preview dari kode yang kita tulis dapat secara lengkap kita lihat dengan

terlebih dahulu melakukan konversi data log dari C log ke S log, C ke A (ASCII) ataupun S

log ke C log. Baru kemudian bisa kita baca log tersebut dengan jumpshot. Semoga bermanfaat


55


56

7. Kesimpulan

1. Beberapa metode clustering yang saya uji diatas berhasil dijalankan dengan requirement

minimal dan dapat diuji, di implementasikan, dan dilakukan inovasi untuk skala yang lebih

besar.

2. Kita tidak bisa membandingkan antar metode diatas hanya untuk sebuah case saja.

OpenMosix yang notabene merupakan pendistribusian proses, tidak dapat dibandingkan

dengan MPI hanya untuk me-render sebuah pencitraan, sehingga tentu openMosix akan

memakan waktu lebih lama. Begitu juga perihal cache memory, core processor, NIC atau

kartu jaringan yang digunakan dengan besarnya data transfer seperti 10/100/1000/dst

dalam kisaran Mbps sangat mempengaruhi interval waktu perpindahan atau

pendistribusian proses antar node.

3. Metode MPI atau Beowulf akan membagi rata secara langsung beban kerja pada node

sehingga lebih efektif.

4. Bahasa pemrograman C, C++ hingga FORTRAN masih menjadi bahasa pemrograman

yang robust lewat library nya dalam menangani masalah pemrograman parallel

processing.


57

8. Referensi

[1] Adams and Vos. (2001). Small-College Supercomputing: Building A Beowulf Cluster

At A Comprehensive College. 2001: 1-5. Retrieved 31 January 2015.

[2] Ajinagoro, Bagus Irawan (2005). Aplikasi Sistem Paralel Menggunakan Prosesor Host

486 Berbasis Linux Debian. 2005 (Jul): 1-71. Retrieved 25 January 2015.

[3] Laksono, Mutiara, & Heruseto. (2004, 24-25 August). Analisis Perbandingan Antara

Cluster OpenMosix dengan MPI terhadap Aplikasi Rendering POV-RAY. 2004 (Aug):

1-7. Retrieved 24 January 2015.

[4] Latter, Ian (2006). How To - Instant openMosix. How to build a working openMosix

cluster without touching a compiler. 2006 (Apr): 1-80. Retrieved 11 January 2015.

[5] Singh, Navtej (2012). Parallel Astronomical Data Processing or How to Build a Beowulf

Class Cluster for High Performance Computing?. 2012 (Jan): 1-21. Retrieved 31 January

2015.

[6] Sloan, Joseph D. (2004). High Performance - LINUX CLUSTER with OSCAR, Rocks,

openMosix & MPI. United States of America: OReilly Media.

[7] Susanto, Warmada, & Wiryana. (2001). Open Source Campus Agreement - GNUPLOT

Untuk Orang Lugu. 2001: 1-57. Retrieved 13 February 2015.

[8] http://www.beowulf.org

[9] http://www.kernel.org/

[10] http://www.mpich.org/

[11] http://www.oyonale.com

[12] http://www.povray.org

Lihat juga beberapa tulisan saya yang diantaranya:

1. Mengenal Java Sebagai Pemrograman Berorientasi Objek dan

Implementasi Thread di Lingkungan UNIX/ Linux.

2. Implementasi SMS Gateway dengan Kannel dan Modem

WAVECOM di Linux OpenSuSE 11.2.

3. Mengenal PL (Procedural Language)/ SQL.

4. Metode Praktis Penetapan Nishab Zakat.

5. Panduan Sholat dan Hadits Shahih - Mengevaluasi Cara Sholat

Kita.

6. Cloud Computing dengan VMWare - Panduan dan Implementasi.

7. Vcenter Server Appliance

8. Esensi Sholat Berjamaah

9. Raih Dunia dengan Superkomputer di Linux Native - Catch The

World with Supercomputer in Native Linux

Tulisan saya diatas telah saya unggah di situs :

1. tifosilinux.wordpress.com

2. slideshare.net

3. academia.edu

Supported by

tifosilinux

Dedikasi tulisan dari

Hary yang telah

published di berbagai

tempat. Silahkan baca

tulisan dan dokumen

saya yang lain dengan

mengunjungi situs

tifosilinux.wordpress.com

Contact:

Email : [email protected]

Phone: 085695042489

Skype: hary_122

BBM: 7943F602

Documents

Update-superkomputer Dengan Native Linux_final