Update - Superkomputer dengan Native GNU/ Linux - Final

(UPDATE) RAIH DUNIA DENGAN SUPERKOMPUTER
DI LINUX NATIVE
(CATCH THE WORLD WITH SUPERCOMPUTER IN NATIVE LINUX)
Hary Cahyono
tifosilinux.wordpress.com | h4ry.oop@gmail.com
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 <M>. 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-
<kernel_version> .
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 <service_name> 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 <path_device> 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 <package_name>) 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 supercomputer’s performance at a
small fraction of one’s 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 <address_of_headnode>:/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-<file>-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 <hostname_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
<hostname_node>,<hostname_node>,… 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 <network_interface_used_by_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 =
<mpi_type_from_show_option> 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 <file_name> . 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://<head_ip>/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 <nama_file> <nama_file>.c &&
mpirun -np 4 <nama_file> . 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 <stdio.h>
/* 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<numberRects; 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: %fn", 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 <stdio.h>
/* 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 intervaln");
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: %fn", 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: O’Reilly 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 Berjama’ah
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 : h4ry.oop@gmail.com
Phone: 085695042489
Skype: hary_122
BBM: 7943F602

Update - Superkomputer dengan Native GNU/ Linux - Final

More Related Content

What's hot

Viewers also liked

More from Hary HarysMatta

Update - Superkomputer dengan Native GNU/ Linux - Final