IMPLEMENTASI ALCHEMI DI LABORATORIUM GHPC FASILKOM UNIVERSITAS INDONESIA Studi Kasus : Penghitungan Nilai π

IMPLEMENTASI ALCHEMI DI LABORATORIUM GHPC FASILKOM UNIVERSITAS INDONESIA Studi Kasus : Penghitungan Nilai π

Oleh : Binti Solihah Chastine Fatichah Della Maulidiya Dhian Widya Widiyantono Wikan Pribadi

(0606025424) (0606025430) (0606025443) (0606025456) (0606025632) (0606025645)

Dibuat dalam rangka Final Project Topik dalam Komputasi Parallel : Grid and High Performance Computing (GHPC) Kuliah Program Magister Ilmu Komputer Dosen: Heru Suhartanto, Ph.D

FAKULTAS ILMU KOMPUTER UNIVERSITAS INDONESIA MEI 2007

IMPLEMENTASI ALCHEMI DI LABORATORIUM GHPC FASILKOM UNIVERSITAS INDONESIA Studi Kasus : Penghitungan Nilai π Abstrak Komputasi grid sebagai salah satu tipe dari sistem terdistribusi diharapkan mampu menangani masalahmasalah heterogenitas, transparansi, fault tolerance, dan kesalahan manajemen. Selain itu, sistem yang dibangun tersebut juga harus mempertimbangkan skalabilitas, concurrency, openness, extensibility, load balancing, migrasi dan keamanan (security). Alchemi dan Globus Toolkit merupakan dua open source software toolkits yang digunakan dalam lingkungan Grid berbasis Web Services. Meskipun kedua toolkits tersebut dirancang untuk tujuan yang sama namun arsitektur dan teknologi yang digunakan berbeda [5]. Alchemi Toolkit bekerja di lingkungan sistem operasi Windows dan menyediakan API untuk bahasa pemrograman C# dan C++. Framework komputasi grid Alchemi disusun agar konstruksi grid dan pengembangan perangkat lunak grid dilakukan semudah mungkin tanpa mengurangi fleksibilitas, skalabilitas, reliabilitas dan ekstensibilitas [2]. Alchemi Grids meniru arsitektur master-slave dengan penambahan kemampuan untuk menghubungkan banyak master secara hirarki atau peer-to-peer untuk menyediakan skalabilitas sistem. Bagian terkecil dari eksekusi parallel yaitu grid thread yang secara konseptual dan pragmatis sama dengan konsep thread object (dalam pemrograman berorientasi obyek). Konsep thread object memuat konsep multitasking operating systems thread. Komponen-komponen tersebar yang dimiliki Alchemi terdiri atas : Manager, Executor, Owner dan User Application [1]. Konfigurasi sistem yang dapat dibuat dengan menggunakan Alchemi meliputi : cluster (desktop grid), multi-cluster dan cross-platform grid (global grid) [1]. Konfigurasi cross-platform (global grid), memiliki suatu komponen grid middleware, misalnya broker, yang dapat menggunakan Cross-Platform Manager untuk mengeksekusi aplikasi-aplikasi lintas platform. Teknologi .NET framework yang dimiliki Alchemi menawarkan dua mekanisme eksekusi antar application domain yaitu Remoting dan Web Services. Kedua mekanisme ini memiliki tujuan yang sama yakni untuk komunikasi antar komponen Alchemi. Persyaratan sistem yang harus tersedia untuk mengembangkan grid menggunakan Alchemi yaitu : Windows NT/2000/XP/2003, Microsoft .NET Framework 1.1/2.0, SQL Server 2000 atau MSDE 2000, Internet Information Services (IIS) dan ASP.NET. Eksperimen yang dilakukan untuk mengevaluasi kinerja Alchemi yaitu menghitung nilai π (pi) dengan ketelitian yang bervariasi. Aplikasi grid computing menggunakan framework Alchemi untuk menghitung nilai π, diimplementasikan dengan C# yang berjalan diatas platform .NET. Algoritma penghitung π yang diimplementasikan diambil dari tulisan Plouffe Bellard [9]. Eksperimen dilakukan dengan dua skenario, yang Manager tidak diberlakukan sebagai Executor dan Manager diberlakukan sebagai Executor. Banyaknya Executor yang digunakan bervariasi dari satu sampai empat Executor. Selain itu, banyaknya digit yang dihitung juga bervariasi, yaitu 500, 1000, 1500, 2000, dan 2500. Hasil eksperimen yang diperoleh baik dengan skenario pertama maupun kedua menunjukkan waktu eksekusi yang semakin cepat dan speedup yang menaik seiring dengan bertambahnya Executor yang digunakan. Pada ketelitian hingga 2500 digit, waktu eksekusi dengan 4 Executor ¼ kali lebih cepat dibandingkan dengan menggunakan 1 Executor. Sedangkan efisiensinya tidak menunjukkan suatu pola tertentu. Speedup dan efisiensi terbaik dicapai pada penghitungan π dengan ketelitian 1500 digit. Apabila hasil dari kedua skenario ini dibandingkan, waktu eksekusi, speed up, dan efisiensi dengan skenario pertama lebih baik daripada skenario kedua.

1

DAFTAR ISI Abstrak ............................................................................................................................................ 1 DAFTAR ISI ................................................................................................................................... 2 DAFTAR TABEL ........................................................................................................................... 3 DAFTAR GAMBAR ...................................................................................................................... 4 BAB I PENDAHULUAN ............................................................................................................... 5 BAB II ARSITEKTUR ALCHEMI................................................................................................7 2.1 Manager .............................................................................................................................. 7 2.2 Executor .............................................................................................................................. 8 2.3 Owner.................................................................................................................................. 8 2.4 Konfigurasi Sistem Alchemi............................................................................................... 9 2.5 Desain dan Implementasi Alchemi ................................................................................... 10 BAB III ALCHEMI API : MODEL PEMROGRAMAN GRID THREAD ................................. 13 3.1 Grid Thread Model ........................................................................................................... 13 3.2 Grid Job Model ................................................................................................................. 13 3.3 Pengembangan Grid Application Menggunakan Alchemi.NET ...................................... 13 BAB IV INSTALASI DAN KONFIGURASI ALCHEMI...........................................................15 4.1 Persyaratan Sistem Grid Berbasis Alchemi ......................................................................15 4.2 Tahapan Instalasi .............................................................................................................. 16 4.2.1 Internet Information Services (IIS)............................................................................. 17 4.2.2 NET Framework 2.0 ................................................................................................... 17 4.2.3 Ms SQL Server 2000 Desktop Engine (MSDE 2000)................................................ 18 4.2.4 Instalasi Alchemi ........................................................................................................19 4.2.4.1 Alchemi Manager.................................................................................................. 19 4.2.4.2 Alchemi Executor.................................................................................................. 21 4.2.4.3 XP Manager........................................................................................................... 22 4.2.4.4 Achemi Console .................................................................................................... 24 BAB V EKSPERIMEN................................................................................................................. 25 5.1 Landasan Teori PiCalculator ............................................................................................ 25 5.2 Penelitian Terdahulu ......................................................................................................... 26 5.3 Eksperimen PiCalculator .................................................................................................. 27 5.3.1 Algoritma PiCalculator............................................................................................... 27 5.3.2 Implementasi dan Eksekusi Program PiCalculator .................................................... 28 5.3.2.1 Tahapan Implementasi .......................................................................................... 28 5.3.2.2 Eksekusi Program.................................................................................................. 34 5.4 Hasil Eksperimen dan Analisis Hasil................................................................................ 35 BAB VI KESIMPULAN............................................................................................................... 39 REFERENSI.................................................................................................................................. 40 LAMPIRAN .................................................................................................................................. 41

2

DAFTAR TABEL Tabel 1. Perbandingan antara Alchemi dan beberapa sistem desktop grid [2] ...............................6 Tabel 2. Perbedaan konfigurasi dedicated execution dan non-dedicated execution ....................... 8 Tabel 3. Perbedaan Remoting dan Web Services pada Alchemi.NET ..........................................10 Tabel 4. Analogi antara pemrograman multithread tradisional dan pemrograman grid [2] ........ 15 Tabel 5. Waktu eksekusi (dalam detik) PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager tidak sebagai Executor ............................................. 35 Tabel 6. Waktu eksekusi (dalam detik) PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager sebagai Executor ...................................................... 36

3

DAFTAR GAMBAR Gambar 1. Pengembangan Globus di Universitas Indonesia ......................................................... 5 Gambar 2. Arsitektur Alchemi dan Interaksi Antar Komponen [2]................................................7 Gambar 3. Berbagai konfigurasi sistem Alchemi ........................................................................... 9 Gambar 4. Arsitektur Layer di lingkungan Windows dan Unix untuk ........................................... 9 Gambar 5. Main Classes Implementasi Alchemi..........................................................................10 Gambar 6. Interaksi antara Owner dan Manager [1]..................................................................... 11 Gambar 7. Interaksi antara Executor dan Manager [1] ................................................................. 12 Gambar 8. Contoh grid application untuk perkalian dua bilangan bulat...................................... 14 Gambar 9. Contoh grid application menggunakan MultiplierThread ............................... 14 Gambar 10. Tampilan site untuk mendownload Alchemi.............................................................15 Gambar 11. Skema Tahapan Instalasi Alchemi PC yang berfungsi sebagai Manager .................16 Gambar 12. Skema Tahapan Instalasi Alchemi pada PC yang berfungsi sebagai Executor ........16 Gambar 13. Windows Component Wizard dan Internet Information Services ............................ 17 Gambar 14. Tampilan situs untuk mendownload .NET Framework 2.0 ...................................... 17 Gambar 15. Proses instalasi Microsoft .NET Framework 2.0 ...................................................... 18 Gambar 16. Situs untuk mendownload MSDE 2000 .................................................................... 18 Gambar 17. Proses instalasi pada command prompt (DOS) ......................................................... 19 Gambar 18. SQL Server Service Manager untuk menjalankan dan mematikan MSDE 2000...... 19 Gambar 19. Alchemi Grid............................................................................................................. 19 Gambar 20. Proses instalasi Alchemi Manager dengan User Interface ........................................20 Gambar 21. Proses instalasi database pada instalasi Alchemi Manager ....................................... 20 Gambar 22. Menjalankan Alchemi Manager ................................................................................ 21 Gambar 23. Proses setting koneksi ke Alchemi Manager pada Alchemi Executor......................21 Gambar 24. Proses instalasi XP Manager ..................................................................................... 22 Gambar 25. XP Manager yang telah terinstall pada Internet Information Services (IIS) ............. 23 Gambar 26. XP Manager diakses melalui browser Internet Explorer........................................... 23 Gambar 27. Proses setting pada Internet Information Services (IIS)............................................ 23 Gambar 28. Alchemi Console ....................................................................................................... 24 Gambar 29. Skema proses administrasi pada Alchemi ................................................................. 24 Gambar 30. Konfigurasi GAS grid sederhana [6]......................................................................... 26 Gambar 31. Algoritma Parallel Evolusioner ................................................................................. 26 Gambar 32. Pengukuran Speedup Algoritma Parallel Evolusioner Menggunakan Alchemi........ 26 Gambar 33. Perbandingan ukuran thread terhadap waktu eksekusi pada Alchemi cluster [2]. ... 27 Gambar 34. Penambahan Alchemi.Core ke dalam References..................................................... 34 Gambar 35. Aplikasi PiCalculator Grid ........................................................................................ 34 Gambar 36. Grafik waktu eksekusi PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager tidak sebagai Executor ............................................. 35 Gambar 37. Grafik Speedup hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager tidak sebagai Executor..................................................................................... 36 Gambar 38. Grafik Efisiensi hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager tidak sebagai Executor..................................................................................... 36 Gambar 39. Grafik waktu eksekusi PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager sebagai Executor ..................................................... 37 Gambar 40. Grafik SpeedUp hasil eksekusi PiCalculator berdasarkan banyaknya Executor.......37 pada skenario Manager sebagai Executor ..................................................................................... 37 Gambar 41. Grafik Efisiensi hasil eksekusi PiCalculator berdasarkan banyaknya Executor ....... 38 pada skenario Manager sebagai Executor ..................................................................................... 38 Gambar 42. Grafik Perbandingan Speedup dan Efisiensi hasil eksekusi PiCalculator.................38 pada kedua skenario untuk n = 1500............................................................................................. 38 4

BAB I PENDAHULUAN Seiring dengan meningkatnya kebutuhan penggunaan komputasi grid untuk menyelesaikan berbagai permasalahan yang kompleks, maka banyak dikembangkan penelitian di bidang ini. Komputasi grid sebagai salah satu tipe dari sistem terdistribusi diharapkan mampu menangani masalah-masalah heterogenitas, transparansi, fault tolerance, dan kesalahan manajemen. Selain itu, sistem yang dibangun tersebut juga harus mempertimbangkan skalabilitas, concurrency, openness, extensibility, load balancing, migrasi dan keamanan (security). Alchemi dan Globus Toolkit merupakan dua open source software toolkits yang digunakan dalam lingkungan Grid berbasis Web Services. Meskipun kedua toolkits tersebut dirancang untuk tujuan yang sama namun arsitektur dan teknologi yang digunakan berbeda [5]. Alchemi merupakan suatu .NET-based Grid framework yang dikembangkan sebagai bagian dari proyek Gridbus di University of Melbourne, Australia. Sedangkan Globus dikembangkan di Argonne National Laboratory, Amerika Serikat. Versi awal Globus Toolkit bekerja di lingkungan sistem operasi Linux, namun versiversi terbaru telah dapat digunakan untuk lingkungan sistem operasi Windows. Untuk membangun web services, Globus Toolkit mendukung bahasa pemrograman Java, C++ dan Perl namun tidak mendukung Windows.NET framework [5]. Globus Toolkit ini mengandung komponen-komponen yang telah terbukti kegunaannya dalam mengatasi permasalahan yang timbul ketika mengimplementasikan aplikasi dan sistem Grid. Komponen-komponen tersebut telah digeneralisasi sehingga dapat digunakan dalam bermacam-macam aplikasi. Namun, Globus Toolkit tidak dapat menyelesaikan setiap permasalahan. Fakultas Ilmu Komputer Universitas Indonesia sedang mengembangkan komputasi grid menggunakan Globus dalam proyek InGrid. Sejumlah algoritma parallel berbasis MPI telah diujicobakan di InGrid.

Gambar 1. Pengembangan Globus di Universitas Indonesia Globus Toolkit telah dirancang dan diimplementasikan untuk mendukung penggunaan standar yang ada dalam lingkungan seperti IETF, W3C, OASIS dan GGF. Tools dalam Globus Toolkit menggunakan standar ini, bukan menciptakan mekanisme baru yang melakukan hal sama dalam cara yang berbeda [8]. Berikut beberapa contoh mekanisme standar yang digunakan dalam Globus Toolkit : • • •

SSL/TLS v1 (dari OpenSSL) (IETF) LDAP v3 (dari OpenLDAP) (IETF) X.509 Proxy Certificates (IETF) 5

• • • •

SOAP (W3C) HTTP (W3C) GridFTP v1.0 (GGF) OGSI v1.0 (GGF)

Globus Toolkit juga mengandung implementasi reference dari beberapa standar baru yang diajukan dalam organisasi ini, yang menyediakan lingkungan dengan kode yang dapat digunakan untuk menguji coba standar dan menyediakan umpan balik mengenai kegunaannya. Contohnya meliputi WSRF (GGF, OASIS), DAI (GGF), WS-Agreement, WSDL 2.0 (W3C), WSDM, SAML (OASIS), dan XACML (OASIS). Alchemi menyediakan runtime machinery dan lingkungan pemrograman yang diperlukan untuk membangun desktop grid dan pengembangan aplikasi grid [2]. Oleh karena itu Alchemi dapat memberikan komposisi aplikasi yang fleksibel yang mendukung pemrograman aplikasi berorientasi obyek yang ditambahkan ke model file-based job. Dukungan cross-platform disediakan melalui antarmuka web service dan model eksekusi yang fleksibel. Tabel berikut memperlihatkan perbandingan antara Alchemi dan beberapa sistem desktop grid lain yaitu : Condor, SETI@home, Entropia, GridMP dan XtermWeb. Tabel 1. Perbandingan antara Alchemi dan beberapa sistem desktop grid [2]

Saat ini, akan dikembangkan implementasi komputasi grid menggunakan Alchemi.NET. Proses instalasi dan ujicoba pengukuran kinerja Alchemi.NET menjadi tugas akhir mata kuliah Topik Dalam Komputasi Grid pada semester genap TA. 2006/2007. Studi kasus yang digunakan untuk pengujian adalah penghitungan nilai π (pi) menggunakan algoritma Plouffe-Bellard.

6

BAB II ARSITEKTUR ALCHEMI Alchemi Toolkit bekerja di lingkungan sistem operasi Windows dan menyediakan API untuk bahasa pemrograman C# dan C++. Framework komputasi grid Alchemi disusun agar konstruksi grid dan pengembangan perangkat lunak grid dilakukan semudah mungkin tanpa mengurangi fleksibilitas, skalabilitas, reliabilitas dan ekstensibilitas [2]. Alchemi memiliki fiturfitur utama [4] berupa : ƒ Virtualisasi sumber daya pada LAN/Internet ƒ Mengurangi penyebaran dan pengaturan data ƒ Model pemrograman berorientasi obyek “Grid Thread” ƒ Model berbasis file “Grid Job” ƒ Antarmuka web services untuk saling bekerjasama dengan grid middleware yang lain ƒ Berbasis .NET yang open source dan proses instalasi mudah Alchemi Grids meniru arsitektur master-slave dengan penambahan kemampuan untuk menghubungkan banyak master secara hirarki atau peer-to-peer untuk menyediakan skalabilitas sistem. Bagian terkecil dari eksekusi parallel yaitu grid thread yang secara konseptual dan pragmatis sama dengan konsep thread object (dalam pemrograman berorientasi obyek). Konsep thread object memuat konsep multitasking operating systems thread. Komponen-komponen tersebar yang dimiliki Alchemi terdiri atas : Manager, Executor, Owner dan User Application [1]. Gambar 2 berikut mengilustrasikan komponen-komponen Alchemi dan interaksi antar komponen.

Gambar 2. Arsitektur Alchemi dan Interaksi Antar Komponen [2] 2.1 Manager Manager merupakan master atau pengontrol yang berfungsi melayani permintaan user untuk mendistribusikan beban kerja (workload) dan memilih thread. Komponen ini menerima permintaan user, otentikasi user dan mendistribusi beban kerja ke setiap Executor yang terhubung pada Manager tersebut [1]. Semua thread yang diterima dari Owner diletakkan dalam pool dan dijadwalkan berdasarkan priority atau first come first served (FCFS), selanjutnya dikirimkan ke Executor untuk dieksekusi. Prioritas untuk setiap thread dapat ditentukan secara 7

eksplisit pada saat thread dibuat dalam Owner atau akan diset sebagai prioritas tertinggi jika tidak ada yang dispesifikasikan. Sub-komponen Manager yang berupa sebuah interface web service yaitu CrossPlatform Manager. Komponen ini bersifat pilihan dan digunakan untuk mengatur eksekusi dari job grid yang tidak tergantung platform ( kebalikan dari aplikasi grid yang memanfaatkan model grid thread). Job yang disubmit ke Cross-Platform Manager diterjemahkan ke sebuah bentuk grid thread agar dapat diterima oleh Manager. Selanjutnya thread tersebut dijadwalkan dan dieksekusi. Grid-enabling dari aplikasi yang ada juga didukung oleh kemampuan CrossPlatform Manager yang memungkinkan middleware grid lainnya dapat dioperasikan bersama Alchemi pada sembarang platform yang mendukung web service misalnya Gridbus Grid Service Broker [1]. 2.2 Executor Sebuah Executor menerima threads dari Manager dan selanjutnya mengeksekusi thread-thread tersebut. Executor akan mengembalikan thread yang telah diselesaikan ke Manager yang dikirimkan secara subsequent atau dikumpulkan oleh Owner masing-masing. Proses eksekusi oleh Executor dapat diatur menjadi dedicated execution atau pun non-dedicated execution [1]. Tabel berikut menunjukkan perbedaan konfigurasi Executor tersebut.

No. 1. 2.

3.

Tabel 2. Perbedaan konfigurasi dedicated execution dan non-dedicated execution Keterangan Dedicated execution Non-dedicated execution Pengaturan sumber Dilakukan sepenuhnya oleh Diatur pada sebuah daya Manager volunteer basis melalui screen saver atau oleh user Komunikasi antara ƒ Komunikasi dua arah ƒ Komunikasi satu arah Executor - Manager ƒ Executor membuka sebuah ƒ Sumber daya tempat antarmuka (IExecutor) agar Executor berada diatur Manager berkomunikasi secara bersama ketika dengan Executor secara menerima thread langsung Contoh jaringan Manager dan Executor berada Manager dan Executor yang sesuai pada satu LAN yang sama dikoneksikan via internet

Tersedianya dua model eksekusi yang berbeda tersebut memungkinkan Alchemi untuk melakukan : • Manajemen sumber daya yang fleksibel karena dapat diatur secara terpusat atau tersebar sesuai kondisi yang diinginkan. • Pendistribusian yang fleksibel pada jaringan tertentu karena komponen-komponen dapat didistribusikan sebagai non-dedicated apabila komunikasi dua arah tidak diinginkan atau tidak mungkin (misal ketika berada dibalik firewall atau NAT/proxy server)

2.3 Owner Aplikasi grid dibuat menggunakan Alchemi API dan akan dieksekusi oleh Owner. Owner menyediakan interface yang menghubungkan antara pembuat aplikasi dengan aplikasi grid [1]. Istilah Owner dapat diartikan sebagai User [2]. Owner akan men-submit thread ke Manager dan mengumpulkan thread yang telah selesai melalui Alchemi API.

8

2.4 Konfigurasi Sistem Alchemi Konfigurasi sistem yang dapat dibuat dengan menggunakan Alchemi meliputi : cluster (desktop grid), multi-cluster dan cross-platform grid (global grid) [1]. Gambar berikut mengilustrasikan ketiga system tersebut.

Gambar 3. Berbagai konfigurasi sistem Alchemi [1] Sebuah cluster akan memuat sebuah Manager yang terhubung dengan banyak Executor [1]. Agar satu atau lebih Owner dapat mengeksekusi aplikasinya pada cluster maka Owner harus terhubung ke Manager. Lingkungan sistem ini sesuai untuk pengembangan Local Area Network (LAN). Sedangkan lingkungan multi-cluster dibangun dengan menghubungkan Manager, Executor dan Owner secara hirarki. sama seperti pada cluster, banyak Eksekutor dan Owner dapat terhubung ke Manager pada level hirarki yang sama. Konfigurasi ini sesuai diimplementasikan untuk Internet [1]. Sebuah Manager pada multi-cluster dapat memiliki bersifat seperti Executor bagi Manager lain yang berada pada level yang lebih tinggi. Manager yang demikian disebut Intermediate Manager dan harus diatur mempunyai konfigurasi dedicated atau non-dedicated execution. Konfigurasi cross-platform (global grid), memiliki suatu komponen grid middleware, misalnya broker, yang dapat menggunakan Cross-Platform Manager untuk mengeksekusi aplikasi-aplikasi lintas platform. Gambar 4 berikut menggambarkan suatu skenario untuk membuat lingkungan komputasi grid berbasis arsitektur layered yang menggunakan Alchemi dan Globus Toolkit.

Gambar 4. Arsitektur Layer di lingkungan Windows dan Unix untuk sumberdaya terintegrasi [2]

9

2.5 Desain dan Implementasi Alchemi Implementasi Alchemi dapat digambarkan menggunakan class diagram seperti pada gambar 5 berikut. Gambar 5 hanya memperlihatkan main classes tanpa atribut dan operasi.

Gambar 5. Main Classes Implementasi Alchemi Teknologi .NET framework yang dimiliki Alchemi menawarkan dua mekanisme eksekusi antar application domain yaitu Remoting dan Web Services. Kedua mekanisme ini memiliki tujuan yang sama yakni untuk komunikasi antar komponen Alchemi. Tabel 3 di bawah ini meringkas perbedaan antara mekanime Remoting dan Web Services. Tabel 3. Perbedaan Remoting dan Web Services pada Alchemi.NET No. Keterangan Remoting Web Serives 1. Message coding Binary encoding XML-encoded 2. Overhead low high Objects remoted pada Remoting meliputi : GManager, GExecutor, GApplication dan CrossPlatformManager. Obyek GManager, GExecutor, dan GApplication merupakan turunan dari GNode class yang menerapkan fungsi generik untuk remoting obyeknya sendiri dan menghubungkan remote Manager melalui interface IManager [1]. Awalan ’G’ pada object remote menotasikan grid node class dan awalan ‘I’ menyatakan interface [2]. Manager executable menginisialisasi instance pada GManager class yang selalu di-remote dan terbuka pada interface IManager. Hal penting yang perlu diperhatikan adalah interface IManager merupakan turunan dari IExecutor yang mengijinkan Manager untuk terhubung ke Manager lainnya dan bertindak sebagai Executor. Dengan demikian arsitektur tersebut mendukung bangunan hierarchical grids. Executor executable membuat sebuah instance dari kelas GExecutor. Untuk memungkinkan komunikasi dua arah, GExecutor diremote dan membuka interface IExecutor sehingga Manajer dapat berkomunikasi dengan eksekutor secara langsung. Instalasi Eksekutor menyediakan pilihan untuk menginstal screen saver, yang menginisiasi eksekusi non-dedicated pada saat diaktifkan dengan sistem operasi. 10

Komponen Owner – tempat dimana instance dari GApplication dibuat melalui Alchemi API – berkomunikasi dengan Manajer dengan cara yang sama dengan Gexecutor. Pada saat komunikasi dua arah tidak digunakan dalam implementasi, arsitektur memenuhi kebutuhan komunikasi ini dengan menggunakan interface IOwner. Mekanisme web service dilakukan oleh Cross-Platform Manajer. Cross-Platform Manager akan ’membungkus’ GManager dan menggunakan aplikasi dan thread secara internal untuk menyatakan task dan job melalui interface ICrossPlatformManajer. GJob diturunkan dari Gthread. Untuk membangun dan mengeksekusi aplikasi grid, pengembang membuat sebuah grid thread class yang diturunkan dari Gthread [1]. Sebuah instance dari GApplication dibuat dan dependencies yang dibutuhkan oleh aplikasi ditambahkan ke DependencyCollection. Sedangkan instance dari turunan GThread ditambahkan ke ThreadCollection dari GApplication. GApplication melakukan serialisasi dan mengirimkan data yang relevan ke Manager untuk ditempatkan pada disk sedangkan thread diatur untuk dijadwalkan. Aplikasi dan thread state di-maintain dalam SQL server / basisdata MSDE. Gambar 6 dan 7 dibawah ini mengilustrasikan lifecycle aplikasi grid.

Gambar 6. Interaksi antara Owner dan Manager [1]

11

Gambar 7. Interaksi antara Executor dan Manager [1]

12

BAB III ALCHEMI API : MODEL PEMROGRAMAN GRID THREAD 3.1 Grid Thread Model Alchemi menyederhanakan pengembangan aplikasi grid dengan menyediakan pemodelan pemrograman berorientasi objek dan meniru pemrograman tradisional multi-theading [1]. Unit terkecil dari eksekusi paralel adalah sebuah grid thread, dimana sebuah aplikasi grid berisi banyak grid thread. Alchemi .NET API memberikan kemudahan bagi developer untuk berkonsentrasi pada aplikasi tanpa harus memikirkan rincian “plumbing”. Hal ini dapat terjadi karena developer hanya perlu berhubungan dengan aplikasi, thread object dan obyek-obyek lainnya. Kemudahan lain yang ditawarkan adalah model pemprograman ini dapat diterapkan untuk aplikasi yang paralel secara keseluruhan atau pun hanya sebagian yang paralel. Selain itu aplikasi grid yang menggunakan Alchemi .NET API dapat ditulis pada berbagai bahasa yang mendukung .NET, misalnya C#, VB.NET, Managed C++, J#, JScipt.NET. [2] 3.2 Grid Job Model Implementasi grid tradisional menawarkan abstraksi level-tinggi dari virtual machine, dimana unit terkecil dari eksekusi paralel adalah sebuah proses yang biasa disebut job. Meskipun penulisan program untuk model grid job melibatkan proses, namun pendekatan ini bisa menjadi kompleks dan tidak fleksibel. Arsitektur Alchemi mendukung model grid job melalui antarmuka web service dengan beberapa alasan berikut : - Memungkinkan grid-enabling pada aplikasi yang ada - Interoperabilitas cross-platform dengan grid middleware yang dapat menerima Alchemi 3.3

Pengembangan Grid Application Menggunakan Alchemi.NET Dua kelas utama dalam Alchemi .NET adalah Gthread dan GApplication, masingmasing merepresentasikan grid thread dan grid application. Ada dua bagian utama pada grid application, masing-masing dipusatkan pada salah satu dari kelas-kelas ini : - kode untuk dieksekusi secara remote (grid thread dan dependensinya) - kode untuk dieksekusi secara lokal (aplikasi itu sendiri) Grid thread dapat dibuat dengan menurunkannya dari Gthread, dan meng-override metode void Start(), dan menandai kelas dengan atribut Serializable. Kode yang dieksekusi secara remote didefinisikan dalam implementasi metode Start. Turunan dari GThread dan beberapa dependencies harus di-compile dengan .NET Assemblies sebanyak satu kali atau lebih . Aplikasi grid terdiri dari beberapa tipe aplikasi .NET yang menciptakan instance pada thread grid, mengeksekusinya pada grid dan menggunakan hasil tiap threads. Gambar-gambar di bawah ini menunjukkan contoh aplikasi grid yang menggunakan grid thread.

13

Gambar 8. Contoh grid application untuk perkalian dua bilangan bulat

Gambar 9. Contoh grid application menggunakan MultiplierThread

14

BAB IV INSTALASI DAN KONFIGURASI ALCHEMI 4.1 Persyaratan Sistem Grid Berbasis Alchemi Persyaratan sistem yang harus tersedia untuk mengembangkan grid menggunakan Alchemi yaitu : - Windows NT/2000/XP/2003 - Microsoft .NET Framework 1.1/2.0 - SQL Server 2000 atau MSDE 2000 - Internet Information Services (IIS) - ASP.NET Alchemi dapat di-download dari http://sourceforge.net/projects/alchemi/

Gambar 10. Tampilan site untuk mendownload Alchemi Tabel 4 berikut menunjukkan analogi antara pemrograman multithread tradisional dan pemrograman grid menggunakan Alchemi. Tabel 4. Analogi antara pemrograman multithread tradisional dan pemrograman grid [2]

[.NET Grid Computing Framework] :

15

4.2 Tahapan Instalasi Proses instalasi dilakukan secara bertahap. Alur tahapan instalasi digambarkan dalam gambar 6 berikut.

Gambar 11. Skema Tahapan Instalasi Alchemi PC yang berfungsi sebagai Manager

Gambar 12. Skema Tahapan Instalasi Alchemi pada PC yang berfungsi sebagai Executor Catatan : Proses instalasi harus dilakukan secara berurutan, sesuai dengan tahapan diatas. Apabila dilakukan tidak berurutan, maka aplikasi tidak dapat berjalan dengan baik. Beberapa masalah yang akan muncul jika instalasi tidak berurutan antara lain: - Jika .Net Framework 1.1/2.0 diinstall terlebih dahulu sebelum installasi Internet Information Services (IIS), maka aplikasi XP Manager tidak akan berjalan, walaupun berhasil di install - Aplikasi Alchemi Manager tidak dapat berjalan jika tidak terdapat SQL Server 2000 atau MSDE 2000 - Aplikasi Alchemi Manager dan Executor tidak dapat di install jika tidak terdapat .Net Framework 1.1/2.0 16

4.2.1

Internet Information Services (IIS) Untuk menginstal IIS diperlukan CD instalasi Windows, karena secara default IIS tidak di install saat proses Instalasi Windows -

Cara Install : Start > Control Panel > Add or Remove Programs > Add/Remove Windows Components > Windows Components Wizard Cara Akses : Start > Control Panel > Administrative Tools > Internet Information Services atau Start > Run > inetmgr

Gambar 13. Windows Component Wizard dan Internet Information Services Catatan : Internet Information Services (IIS) tidak tersedia untuk di download dari internet (website Microsoft), untuk menginstallnya hanya dapat diperoleh dari CD installasi Windows 4.2.2

NET Framework 2.0 Paket Instalasi .NET Framework 2.0 dapat di download secara gratis di Website microsoft (http://www.microsoft.com/downloads/) dengan ukuran file sebesar 22,9 MB. Setelah didownload, paket installasi dapat langsung dijalankan untuk menginstall .NET Framework 2.0.

Gambar 14. Tampilan situs untuk mendownload .NET Framework 2.0

17

Gambar 15. Proses instalasi Microsoft .NET Framework 2.0 4.2.3

Ms SQL Server 2000 Desktop Engine (MSDE 2000) Paket Instalasi Ms SQL Server 2000 Desktop Engine (MSDE 2000) dapat di download secara gratis di Website microsoft (http://www.microsoft.com/downloads/), dengan ukuran File: 43,2 MB. Adapun cara untuk menginstal diuraikan sebagai berikut : - Extract terlebih dahulu paket instalasi ke C:\MSDERelA - Proses intalasi dilakukan melalui command prompt Start > Run > cmd, kemudian masuk ke Direktori MSDRelA, lalu ketikkan perintah setup SECURITYMODE=SQL SAPWD=“12345” (Username default adalah sa dengan password 12345, password dapat diubah sesuai dengan keinginan, username dan password akan digunakan nantinya pada instalasi Alchemi Manager pada tahap instalasi database). - Setelah MSDE 2000 diinstal akan terdapat modul yang akan berjalan secara otomatis bernama SQL Server Service Manager yang berguna untuk menjalankan dan mematikan MSDE 2000 (berada di system tray).

Gambar 16. Situs untuk mendownload MSDE 2000

18

Gambar 17. Proses instalasi pada command prompt (DOS)

Gambar 18. SQL Server Service Manager untuk menjalankan dan mematikan MSDE 2000 4.2.4

Instalasi Alchemi

4.2.4.1 Alchemi Manager Paket Alchemi dapat di download secara gratis di : http://downloads.sourceforge.net/alchemi/. Sebelum menginstall Alchemi Manager pastikan sudah terinstal : .NET Framework 2.0 dan MSDE 2000.

Gambar 19. Alchemi Grid

19

Terdapat 2 pilihan instalasi Alchemi Manager : - Alchemi.ManagerExecSetup.msi - Alchemi.ManagerService.msi Pilih Alchemi.ManagerExecSetup.msi untuk pilihan instalasi dengan User Interface. Adapun cara untuk mengakses Alchemi Manager sebagai berikut : Start > All Programs > Alchemi > Manager > Alchemi Manager

Gambar 20. Proses instalasi Alchemi Manager dengan User Interface Pada tahap Install Database, masukan setting sesuai dengan yang dibuat pada tahap instalasi MSDE 2000. Pilih tombol [Save Configuration File] terlebih dahulu kemudian tekan tombol [Install Database]

Gambar 21. Proses instalasi database pada instalasi Alchemi Manager Menjalankan Alchemi Manager dapat dilakukan melalui jendela Alchemi Manager. Langkah pertama, pilih tab [Advanced] kemudian pada bagian Storage Configuration pilih [Database], kemudian masukan setting sesuai intalasi MSDE 2000 sebelumnya. Untuk menjalankan Alchemi Manager tekan tombol [Start]

20

Gambar 22. Menjalankan Alchemi Manager 4.2.4.2 Alchemi Executor Sebelum menginstall Alchemi Executor pastikan sudah terinstal : .NET Framework 2.0. Terdapat dua pilihan instalasi Alchemi Executor : - Alchemi.ExecutorExecSetup.msi - Alchemi.Executor Service.msi. Pilih Alchemi.ExecutorExecSetup.msi untuk pilihan instalasi dengan User Interface. Untuk mengakses dilakukan dengan cara : Start > All Programs > Alchemi > Executor > Alchemi Executor . Alchemi Executor dijalankan melalui jendela Alchemi Executor dengan cara memilih tab [Setup Connection]. Kemudian memasukkan Host/ IP Adrees sesuai dengan IP dimana Manager berada dan gunakan Port 9000, memasukan Username dan Password “executor”, dan memasukan 9001 untuk port pada bagian Own Node. Untuk menjalankan Executor, tekan tombol [Connect]. Jalankan terlebih dahulu Manager, kemudian jalankan Executor

Gambar 23. Proses setting koneksi ke Alchemi Manager pada Alchemi Executor 21

4.2.4.3 XP Manager Sebelum menginstall Alchemi XP Manager pastikan sudah terinstal: .NET Framework 2.0 dan Internet Information Services (IIS). Trouble shooting : IIS harus diinstall terlebih dahulu sebelum menginstall .NET Framework 2.0, jika IIS diinstal setelah menginstall .NET Framework 2.0, maka integrasi .NET Framework 2.0 di IIS tidak akan berjalan dengan baik. Jika hal ini terjadi lakukan instalasi ulang IIS dan .NET Framework. Pada tahap instalasi ubah nama Virtual directory dari “XPManagerSetup” menjadi “Alchemi”, untuk memudahkan pengaksesan nantinya.

Gambar 24. Proses instalasi XP Manager Langkah-langkah untuk menjalankan XP Manager sebagai berikut : (i) Jalankan terlebih dahulu IIS : Start > Control Panel > Administrative Tools > Internet Information Services, atau Start > Run > inetmgr. (ii) Pastikan Default Web Site dalam status Run. Agar XP Manager dapat diakses dari komputer lain di LAN, maka folder Alchemi harus di publish, caranya adalah : - Pastikan folder Alchemi pada IIS berbentuk icon kontak terbuka, jika belum maka klik kanan pada Default Web Site kemudian pilih New > Virtual Directory, buat virtual directory bernama Alchemi Klik kanan pada Default Web Site, kemudian pilih [Propeties] pada tab [Web Site] masukan [IP Address] komputer dimana XP Manager terinstall - Pada komputer dimana XP Manager terinstall, matikan Firewall standar Windows - Kemudian jalankan brwoser Internet Explorer (Trouble shooting: browser harus Internet Explorer, karena ekstensi file yang akan dijalankan adalah .asmx, jika menggunakan Mozilla Firefox file .asmx tidak akan dapat berjalan) - Setting proxy diset sesuai dengan konfigurasi jaringan LAN - Masukkan URL XP Manager http://localhost/Alchemi/CrossPlatformManager.asmx Localhost dapat diganti dengan IP yang sesuai

22

Gambar 25. XP Manager yang telah terinstall pada Internet Information Services (IIS)

Gambar 26. XP Manager diakses melalui browser Internet Explorer

Gambar 27. Proses setting pada Internet Information Services (IIS)

23

4.2.4.4 Achemi Console Untuk mengatur (administrasi) User, Executors, dan Aplikasi terdapat modul bernama Alchemi Console, Alchemi Console berada pada paket Alchemi-1.0.4-sdk. Alchemi Console tidak perlu di instal dan dapat langsung dijalankan

Gambar 28. Alchemi Console

Gambar 29. Skema proses administrasi pada Alchemi

24

BAB V EKSPERIMEN 5.1 Landasan Teori PiCalculator Eksperimen yang dilakukan adalah menghitung nilai π (pi) dengan ketelitian yang bervariasi. Pada [10] telah dibuktikan bahwa digit ke-n dari π dapat dihitung secara langsung tanpa menghitung semua n digit pertamanya. Oleh karena itu, penghitungan nilai π dapat dilakukan secara paralel. Berikut adalah rumus menghitung π yang diberikan oleh David Bailey, Peter Borwein dan Simon Plouffe [10] : ∞

π=

∑ k =0

2 1 1 ⎞ 1 ⎛ 4 − − − ⎜ ⎟ k ⎝ 8k + 1 8k + 4 8k + 5 8k + 6 ⎠ 16

(1)

Metode ini menghasilkan running time selama O(n3 log3n) dan memori sebesar O(log n). Ide dasar dari metode ini adalah berdasarkan hasil berikut : “Bit ke-(N+n) dari suatu bilangan real α diperoleh dengan menghitung bit ke-n dari bagian pecahan 2Nα” Berdasarkan ide tersebut, diperoleh rumus (2) yang digunakan dalam proses komputasi penghitungannya. ∞

π+3=

∑(

k 2k

k =1

2k k

)

(2)

Selanjutnya Fabrice Bellard pada [9] melakukan modifikasi dari metode tersebut sehingga diperoleh perbaikan running time menjadi O(n2) dan memori sebesar O(1). Dengan menggunakan teorema sisa Chinese (Chinese remainder theorem) diperoleh digit ke-n dari bilangan SN dalam basis B adalah m

α i B n mod ai

i =1

ai

Dn = ∑

vi max

mod 1

vi max

(3)

dimana SN dituliskan dalam bentuk berikut ini: N

SN = ∑ k =1

bk Ak

dengan m

Ak = ∏ ai i =1

vi , k

, 0 ≤ vi,k ≤ vimax dan gcd(ai, aj) = 1 untuk i ≠ j

Dalam hal ini vi,k = v(ai, Ak) adalah kelipatan ai dalam Ak dan m adalah banyaknya faktor prima ai yang berbeda dalam Ak. Karena ai adalah bilangan prima, maka berlaku ⎢ log (2k ) ⎥ (4) v ai , 2k k ≤ ⎢ ⎥ ⎣ log (a i ) ⎦

( ( ))

( ( ))

Batas atas dari v ai , k2 k pada (4) inilah yang berperan sebagai nilai vimax pada algoritma penentuan digit ke-n dari bilangan π. Kemudian, parameter m ditentukan sebesar 2N dimana N = ⎣(n + ε ) log 2 (B )⎦ dengan ε adalah suatu bilangan bulat yang kecil untuk menjamin diperolehnya ketelitian yang diinginkan. Berdasarkan rumusan tersebut, maka nilai dari parameter m tergantung kepada nilai n (digit ke berapa yang akan dicari).

25

5.2 Penelitian Terdahulu Arsitektur komputasi grid memungkinkan untuk dimanipulasi agar dapat memfasilitasi penyimpanan data dalam suatu grid. Hipotesa ini telah diuji oleh Koszek dan Sandrasegaran [6] dengan menggunakan Alchemi.NET untuk membuat aplikasi Grid Architecture Storage (GAS). Proyek GAS ini dibangun menggunakan Microsoft Visual Studio 2003 terutama bahasa C#. Manager membutuhkan akses ke Microsoft SQL Server database. Gambar di bawah ini menggambarkan konfigurasi GAS grid sederhana yang menunjukkan hubungan antara bagianbagian GAS yaitu Owner, Manager, Executor dan Monitor.

Gambar 30. Konfigurasi GAS grid sederhana [6] Waclaw Kus telah membuat aplikasi algoritma parallel evolusioner untuk mengoptimisasi anvils pada two-stage forging dengan menggunakan grid berbasis Alchemi [7]. Implementasi algoritma tersebut menggunakan Alchemi framework API dalam bahasa C#. Diagram alir algoritma parallel evolusioner menggunakan grid Alchemi digambarkan pada Gambar 24 dan hasil pengukuran speedup ditunjukkan dalam Gambar 25.

Gambar 31. Algoritma Parallel Evolusioner

Gambar 32. Pengukuran Speedup Algoritma Parallel Evolusioner Menggunakan Alchemi 26

Laboratorium GRIDS University of Melbourne telah melakukan ujicoba untuk mengevaluasi kinerja Alchemi [2]. Cluster Alchemi yang diujikan terdiri dari 6 Executor yang masing-masing berupa PC dengan Pentium III 1.7 GHz, 512 MB memori, dan menggunakan Windows 2000 Professional. Salah satu PC ditentukan sebagai Manager. Aplikasi yang diujikan adalah penghitungan nilai π sampai n digit desimal. Algoritma yang digunakan dapat menghitung digit ke-p tanpa mengetahui digit sebelumnya. Aplikasi ini menggunakan Alchemi dengan 16 grid thread model. Uji coba dilakukan pada workload berupa jumlah digit yang bervariasi, yaitu 1000, 1200, 1400, 1600, 1800, 2000, dan 2200. Pada setiap workload, penghitungan dilakukan dengan menggunakan satu sampai enam Executor. Workload dibagi-bagi menjadi sejumlah thread dimana setiap thread menghitung 50 digit. Dengan demikian banyaknya thread akan bervariasi sesuai dengan banyaknya digit yang akan dihitung. Waktu eksekusi yang diukur adalah elapsed clock time pada program yang lengkap pada Owner node. Gambar 33 memperlihatkan diagram perbandingan antara ukuran thread dan total waktu eksekusi (dalam detik). Pada workload terkecil (1000 digit), total waktu eksekusi tidak terlalu jauh berbeda jika banyaknya Executor yang digunakan berbeda-beda. Hal ini disebabkan karena total overhead yang terjadi relatif lebih besar dibandingkan dengan total waktu komputasinya. Namun, dengan bertambahnya workload, contohnya pada 2200 digit, waktu eksekusi dengan 6 Executor (84 detik) hampir 1/5 dari waktu dengan menggunakan 1 Executor (428 detik). Ini menunjukkan bahwa untuk workload yang lebih besar, total overhead relatif lebih kecil dibandingkan dengan total waktu komputasinya.

Gambar 33. Perbandingan ukuran thread terhadap waktu eksekusi pada Alchemi cluster [2]. 5.3 Eksperimen PiCalculator Aplikasi grid computing menggunakan framework Alchemi untuk menghitung nilai π diimplementasikan dengan C# yang berjalan diatas platform .NET. Pada bagian eksperimen ini dijelaskan tentang: (i) algoritma PiCalculator serta (ii) implementasi dan eksekusi program. 5.3.1 Algoritma PiCalculator Algoritma penghitung π yang diimplementasikan diambil dari tulisan Plouffe Bellard [9] sebagai berikut :

27

Algoritma untuk menghitung bilangan π dengan ketelitian n digit dalam basis B : •

N ← ⎣(n + ε ) log 2 ( B)⎦ , dimana ε adalah bilangan bulat yang kecil untuk menjamin diperolehnya ketelitian yang dibutuhkan; Sum Å 0;

•

Untuk setiap bilangan prima a dengan 2 < a < 2N, lakukan: - v

max

max

←⎣log(2 N ) / log(a )⎦;m ←a v .

- a ← 0; v ← 0; b ← 1; A ← 1 - untuk k:1 sampai N lakukan :

•

k

b←

¾

if v > 0 do : a ← a + k .b. A −1 .a v

a

v ( a ,k )

b mod m; A ←

(2k − 1) A mod m; v ← v − v(a, k ) + v(a,2k − 1) a v ( a , 2 k −1)

¾

max

−v

mod m

a ← a.B n −1 mod m; sum ← sum + ma mod1 .

Jika dianggap bahwa diabaikan,

π = (d 0 d1 d 2 d 3 ...) B

diperoleh

maka apabila pembulatan error

sum = (0, d n d n +1 d n + 2 ..d n + q −1 ...) .

banyaknya digit yang benar tergantung pada

Nilai

q

yaitu

ε.

5.3.2 Implementasi dan Eksekusi Program PiCalculator 5.3.2.1 Tahapan Implementasi Implementasi aplikasi grid dengan framework Alchemi untuk menghitung π dilakukan pada tahap pengembangan aplikasi meliputi coding dan kompilasi program. Pada bagian ini dijelaskan pengimplementasian aplikasi PiCalculator. Ada tiga class utama dari aplikasi ini, yaitu class Plouffe_Bellard, class PiCalculatorMain dan class PhiCalcGridThread. Class Plouffe_Bellard mengimplementasikan fungsi untuk menghitung bilangan π hingga ketelitian n digit. Untuk menggunakan Alchemi API pada aplikasi, harus dideklarasikan secara eksplisit penggunaan library Alchemi API seperti berikut : using using using using

Alchemi.Core; Alchemi.Core.Owner; Alchemi.Core.Utility; log4net;

1. Class PiCalculatorMain Pada class ini berisi 5 fungsi yaitu fungsi Main, fungsi LogHandler, fungsi StartTiming, fungsi ThreadFinished, dan fungsi ApplicationFinished. Fungsi Main menangani prosesproses mulai dari inisialisasi, membuat aplikasi grid, melakukan koneksi ke Manager Alchemi melalui jaringan, mendefinisikan banyaknya thread dan membuat thread, menambahkan thread ke aplikasi grid, dan memulai aplikasi. Lebih jelasnya dapat dilihat pada potongan program di bawah ini.

28

static void Main() { Console.WriteLine("[Pi Calculator Grid Application]\n-----\n"); Console.WriteLine("Press <enter> to start ..."); Console.ReadLine(); Logger.LogHandler += new LogEventHandler(LogHandler); try { // get the number of digits from the user bool numberOfDigitsEntered = false; while (!numberOfDigitsEntered) { try { NumberOfDigits = Int32.Parse(Utils.ValueFromConsole("Digits to calculate", "100")); if (NumberOfDigits > 0) {numberOfDigitsEntered = true; } } catch (Exception) { Console.WriteLine("Invalid numeric value."); numberOfDigitsEntered = false; } } // get settings from user GConnection gc = GConnection.FromConsole("localhost", "9000", "user", "user"); StartTiming(); // create a new grid application App = new GApplication(gc); // add the module containing PiCalcGridThread to the application manifest App.Manifest.Add(new ModuleDependency(typeof(PiCalculator.PiCalcGridThread).Module)); double num2 = NumberOfDigits / DigitsPerThread; NumThreads = (Int32)Math.Floor(num2); if (DigitsPerThread * NumThreads < NumberOfDigits) { NumThreads++;} // create and add the required number of grid threads for (int i = 0; i < NumThreads; i++) { int StartDigitNum = 1 + (i*DigitsPerThread); // the number of digits for each thread // Each thread will get DigitsPerThread digits except the last one // which might get less int DigitsForThisThread = Math.Min(DigitsPerThread, NumberOfDigits – i * DigitsPerThread); Console.WriteLine("starting a thread to calculate the digits of pi from {0} to {1}", StartDigitNum,StartDigitNum + DigitsForThisThread - 1); PiCalcGridThread thread = new PiCalcGridThread(StartDigitNum, DigitsForThisThread ); App.Threads.Add(thread); }

// subcribe to events App.ThreadFinish += new GThreadFinish(ThreadFinished); App.ApplicationFinish += new GApplicationFinish(ApplicationFinished); // start the grid application App.Start(); logger.Debug("PiCalc started."); } catch (Exception e) { Console.WriteLine("ERROR: {0}", e.StackTrace); } Console.ReadLine(); }

29

Fungsi LogHandler menangani proses even handler pada aplikasi. Lebih jelasnya dapat dilihat pada potongan program di bawah ini. private static void LogHandler(object sender, LogEventArgs e) { switch (e.Level) { case LogLevel.Debug: string message = e.Source + ":" + e.Member + " - " + e.Message; logger.Debug(message,e.Exception); break; case LogLevel.Info: logger.Info(e.Message); break; case LogLevel.Error: logger.Error(e.Message,e.Exception); break; case LogLevel.Warn: logger.Warn(e.Message); break; } }

Fungsi StartTiming merupakan fungsi untuk mencatat mulainya waktu eksekusi. Lebih jelasnya dapat dilihat pada potongan program dibawah ini. static void StartTiming() { StartTime = DateTime.Now; }

Fungsi ThreadFinished merupakan fungsi untuk menampilkan informasi thread yang sudah selesai melakukan eksekusi perhitungan π. Lebih jelasnya dapat dilihat pada potongan program dibawah ini. static void ThreadFinished(GThread thread) { th++; Console.WriteLine("grid thread # {0} finished executing", thread.Id); }

Fungsi ApplicationFinished merupakan fungsi untuk menangani proses pencatatan hasil perhitungan π setiap thread, pencatatan hasil akhir perhitungan π, dan total waktu eksekusi. Lebih jelasnya dapat dilihat pada potongan program dibawah ini. static void ApplicationFinished() { StringBuilder result = new StringBuilder(); for (int i=0; i<App.Threads.Count; i++) { PiCalcGridThread pcgt = (PiCalcGridThread) App.Threads[i]; result.Append(pcgt.Result); } Console.WriteLine( "===\nThe value of Pi to {0} digits is:\n3.{1}\n===\nTotal time taken = {2}\n===",NumberOfDigits, result, DateTime.Now - StartTime); //Console.WriteLine("Thread finished fired: " + th + " times"); Console.WriteLine("Application Finished"); }

30

2. Class PhiCalcGridThread Pada class ini berisi sebuah fungsi pokok yaitu fungsi Start(). Saat pemanggilan konstruktor PiCalcGridThread()dilakukan pendefinisian awal digit bilangan π yang akan dihitung dan banyaknya digit yang dibuat pada saat sebuah thread dipanggil. Setiap thread ditetapkan untuk menghitung 10 digit. Misalnya untuk menghitung bilangan π hingga 100 digit, akan terbentuk 10 thread. Kemudian, pada fungsi start() dilakukan instantiasi obyek dari class Plouffe_Bellard. Setelah itu akan dilakukan penghitungan nilai π pada digit-digit yang ditentukan dengan pemanggilan fungsi CalculatePiDigits. Secara detail tampak pada list program berikut ini: public class PiCalcGridThread : GThread { private int _StartDigitNum; private int _NumDigits; private string _Result; public int StartDigitNum { get { return _StartDigitNum ; } } public int NumDigits {get { return _NumDigits; }} public string Result{get { return _Result; }} public PiCalcGridThread(int startDigitNum, int numDigits) { _StartDigitNum = startDigitNum; _NumDigits = numDigits; }

public override void Start() { StringBuilder temp = new StringBuilder(); Plouffe_Bellard pb = new Plouffe_Bellard(); for (int i = 0; i <= Math.Ceiling(_NumDigits / 9); i++) { temp.Append(pb.CalculatePiDigits(_StartDigitNum + (i * 9))); } _Result = temp.ToString().Substring(0, _NumDigits); for (int i = 0; i < int.MaxValue; i++); } }

3. Class Plouffe_Bellard Class Plouffe_Bellard dipanggil pada PiCalcGridThread. Class Plouffe_Bellard berisi fungsi untuk menghitung bilangan π hingga ketelitian n digit dan fungsi-fungsi pendukungnya. Fungsi CalculatePiDigits merupakan fungsi yang mengimplementasikan algoritma PiCalculator yang telas dijelaskan pada bagian sebelumnya. public String CalculatePiDigits(int n) { int av, vmax, num, den, s, t; //menghitung N dan inisiasi sum = 0 int N = (int) ((n + 20) * Math.Log(10) / Math.Log(2)); double sum = 0; // Untuk setiap bilangan prima a dengan 2 < a < 2N // lakukan itarasi berikut for (int a = 3; a <= (2 * N); a = next_prime(a)) { //menghitung vmax vmax = (int) (Math.Log(2 * N) / Math.Log(a)); av = 1;

31

for (int i = 0; i < vmax; i++) { av = av * a; } s = 0; num = 1; den = 1; int v = 0; int kq = 1; int kq2 = 1; //iterasi dari k = 1: N untuk menghitung for (int k = 1; k <= N; k++) { t = k; if (kq >= a) { do { t = t / a; v--;} while ((t % a) == 0); kq = 0; } kq++; num = mul_mod(num, t, av); t = 2 * k - 1; if (kq2 >= a) { if (kq2 == a) { do { t = t / a; v++; } while ((t % a) == 0); } kq2 -= a; } den = mul_mod(den, t, av); kq2 += 2; if (v > 0) { t = inv_mod(den, av); t = mul_mod(t, num, av); t = mul_mod(t, k, av); for (int i = v; i < vmax; i++) { t = mul_mod(t, a, av); } s += t; if (s >= av){s -= av;} } } t = pow_mod(10, n - 1, av); s = mul_mod(s, t, av); sum = (sum + (double) s / (double) av) % 1.0; } int Result = (int) (sum * 1e9); String StringResult = String.Format("{0:D9}", Result); return StringResult; }

Fungsi-fungsi pendukung Class Plouffe_Bellard adalah : a. fungsi untuk mendapatkan bilangan prima setelah bilangan n /* return the prime number immediatly after n */ private static int next_prime(int n) { do { n++; } while (!is_prime(n)); return n; }

32

b. fungsi untuk memeriksa apakah sebuah bilangan prima atau bukan /* return true if n is prime */ private static bool is_prime(int n) { if ((n % 2) == 0) { return false;} int r = (int) Math.Sqrt(n); for (int i = 3; i <= r; i += 2){ if ((n % i) == 0) {return false;} } return true; }

c. fungsi untuk menghitung modulus m dari hasil perkalian bilangan a dan b /* return (a^b) mod m */ private static int pow_mod(int a, int b, int m) { int r, aa; r=1; aa=a; while (true) { if ((b & 1) != 0) {r = mul_mod(r, aa, m);} b = b >> 1; if (b == 0) { break; } aa = mul_mod(aa, aa, m); } return r; }

d. fungsi untuk menghitung invers dari modulus y dari x /* return the inverse of x mod y */ private static int inv_mod(int x, int y) { int q,u,v,a,c,t; u=x; v=y; c=1; a=0; do { q=v/u; t=c; c=a-q*c; a=t; t=u; u=v-q*u; v=t; } while (u!=0); a=a%y; if (a<0) { a=y+a; } return a; }

Kompilasi program aplikasi dapat dilakukan dalam lingkungan .NET dengan syarat library Alchemi API telah dimasukkan ke dalam reference, seperti tampak pada Gambar 34. Setelah kompilasi sukses, proses selanjutnya adalah membuat executable file dari aplikasi yang dibuat.

33

5.3.2.2 Eksekusi Program Pada proses eksekusi program yang dilakukan secara remote, aplikasi yang akan dieksekusi dijalankan dari komputer owner. Komputer yang bertindak sebagai owner terhubung ke komputer Manager dan Executor melalui LAN. Sebelum digunakan untuk melakukan eksekusi program, Alchemi Manager dan Alchemi Executor harus diaktifkan terlebih dahulu dan dipastikan dalam keadaan ready. Spesifikasi komputer yang digunakan sebagai Manager dan Executor adalah Pentium IV 3GHz dengan RAM 512 MB. Konfigurasi sistem Alchemi yang dibuat menggunakan cluster (desktop grid). Hal lain yang perlu diperhatikan untuk mengeksekusi program adalah Firewall pada Manager dan Excecutor harus dimatikan.

Gambar 34. Penambahan Alchemi.Core ke dalam References

Gambar 35. Aplikasi PiCalculator Grid Untuk memulai program pada aplikasi PiCalculator, user harus mengaktifkan program dengan menekan tombol enter, kemudian user harus menspesifikasikan banyaknya digit bilangan pi yang akan di-generate. Selanjutnya user harus menspesifikasikan host dan port untuk komunikasi. Host diisi alamat IP dari Manager Alchemi, sedangkan port yang digunakan adalah port default, yaitu 9000. Lebih jelasnya tampilan aplikasi PiCalculator yang dijalankan untuk 34

n = 100 digit diperlihatkan pada Gambar 35. Selanjutnya user harus memasukkan username dan password. Setelah penghitungan π selesai dilakukan, hasil yang akan diberikan ke user berupa bilangan π dengan banyak digit di belakang koma seperti yang dispesifikasikan oleh user. 5.4 Hasil Eksperimen dan Analisis Hasil Eksperimen yang dilakukan untuk penghitungan nilai π menggunakan dua skenario. Skenario pertama adalah Manager tidak diberlakukan sebagai Executor dan skenario kedua adalah Manager diberlakukan sebagai Executor. Banyaknya Executor yang digunakan bervariasi dari satu sampai empat Executor. Selain itu, banyaknya digit yang dihitung juga bervariasi, yaitu 500, 1000, 1500, 2000, dan 2500. Hasil eksperimen dengan skenario pertama yaitu Manager tidak diberlakukan sebagai Executor dapat dilihat pada Tabel 5 dan secara visual diagram perbandingannya tampak pada Gambar 36. Untuk setiap nilai n yang diberikan, semakin banyak Executor yang digunakan maka waktu eksekusi untuk menghitung n digit π akan semakin singkat. Pada n = 500, perbedaan waktu eksekusi dengan banyaknya Executor yang bervariasi tidak terlalu signifikan. Namun, dengan bertambahnya nilai n, terlihat perbedaan yang signifikan pada waktu eksekusi dengan banyaknya Executor yang bervariasi. Contohnya pada n = 2500, dengan menggunakan 4 Executor, waktu eksekusinya (198,0938 detik) hampir ¼ kali lebih cepat dibandingkan dengan hanya menggunakan 1 Executor (808,7063 detik). Ini menunjukkan bahwa untuk n yang lebih besar, total overhead relatif lebih kecil dibandingkan dengan total waktu komputasinya. Tabel 5. Waktu eksekusi (dalam detik) PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager tidak sebagai Executor n

p 500 72,509375 31,20822978 23,471875 17,7875

1 2 3 4

1000 1500 145,234375 382,41563 87,0713778 151,70261 50,6125 94,909375 38,821875 78,0375

2000 2500 475,825 808,7063 263,2399595 406,975 159,89375 262,1594 144,39375 198,0938 1 executor 2 executor 3 executor 4 executor

time

Waktu Eksekusi PiCalculator 840 780 720 660 600 540 480 420 360 300 240 180 120 60 0 500

1000

1500

2000

2500

n

Gambar 36. Grafik waktu eksekusi PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager tidak sebagai Executor Speedup yang dicapai dari skenario pertama ditunjukkan oleh grafik pada Gambar 37. Secara umum, speedup akan menaik secara signifikan seiring dengan bertambahnya Executor yang digunakan. Speedup terbaik terjadi pada n = 1500, yang termasuk superlinier.

35

Speedup PiCalculator pada Alchemi 6,0

speedup

5,0 n = 500

4,0

n = 1000 n = 1500

3,0

n = 2000 n = 2500

2,0 1,0 0,0 2

3

p

4

Gambar 37. Grafik Speedup hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager tidak sebagai Executor Efisiensi program dengan skenario pertama tampak pada grafik yang ditunjukkan oleh Gambar 38. Untuk semua nilai n yang digunakan, terlihat bahwa efisiensi program tidak membentuk suatu pola tertentu. Namun, efisiensi terbaik terjadi pada n = 1500. Efisiensi PiCalculator pada Alchemi 1,6 1,4

efisiensi

1,2

n = 500 n = 1000

1,0 0,8

n =1500 n = 2000 n = 2500

0,6 0,4 0,2 0,0 2

3

4

p

Gambar 38. Grafik Efisiensi hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager tidak sebagai Executor Berikutnya adalah hasil eksekusi PiCalculator dengan skenario kedua, yaitu Manager diberlakukan sebagai Executor, berupa waktu eksekusi yang dapat dilihat pada Tabel 6. Diagram perbandingannya diberikan pada Gambar 39. Tabel 6. Waktu eksekusi (dalam detik) PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager sebagai Executor p 1 2 3 4

n 500 60,365625 31,5625 30,409375 17,203125

1000 1500 146,11875 296,1406 92,184375 143,2375 55,828125 94,734375 43,76875 76,228125

2000 2500 470,303125 795,394 368,43125 382,6406 165,496875 296,5188 142,071875 201,5375

36

1 executor 2 executor 3 executor 4 executor

time

Waktu Eksekusi PiCalculator 840 780 720 660 600 540 480 420 360 300 240 180 120 60 0 500

1000

1500

2000

2500

n

Gambar 39. Grafik waktu eksekusi PiCalculator dengan banyaknya Executor dan banyaknya digit yang berbeda pada skenario Manager sebagai Executor Sama halnya dengan hasil eksperimen pada skenario pertama, dengan skenario kedua juga diperoleh hasil yang menunjukkan bahwa semakin banyak Executor yang digunakan maka semakin cepat waktu eksekusinya pada semua nilai n. Perbedaan waktu eksekusi dengan banyaknya Executor yang berbeda juga menunjukkan pola yang sama. Pada n = 500 tidak terlalu signifikan perbedaannya, sedangkan pada n = 2500, waktu eksekusi dengan 4 Executor (201,5375 detik) lebih cepat ¼ kali dibandingkan dengan waktu eksekusi dengan hanya menggunakan 1 Executor (795,394 detik). Dari hasil eksperimen skenario kedua tersebut dapat dibuat grafik speedup pada Gambar 40 dan efisiensi perhitungan nilai π pada Gambar 41. Speedup hasil eksekusi PiCalculator yang paling tinggi terjadi pada n = 1500, dalam hal ini diperoleh speedup yang superlinier. Tetapi secara umum, untuk semua nilai n yang diberikan, speedup mengalami kenaikan secara signifikan seiring dengan bertambahnya Executor yang digunakan. Sedangkan grafik efisiensinya juga tidak menunjukkan suatu pola tertentu dan efisiensi tertinggi dicapai pada n = 1500. Speedup PiCalculator pada Alchemi 4,5 4,0 3,5 speedup

3,0

n = 500 n = 1000

2,5 2,0

n = 1500 n = 2000

1,5

n = 2500

1,0 0,5 0,0 2

3

4

p

Gambar 40. Grafik SpeedUp hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager sebagai Executor

37

Efisiensi PiCalculator pada Alchemi 1,2 1,0

efisiensi

0,8 0,6

n = 500 n = 1000 n = 1500

0,4

n = 2000 n = 2500

0,2 0,0 2

3

p

4

Gambar 41. Grafik Efisiensi hasil eksekusi PiCalculator berdasarkan banyaknya Executor pada skenario Manager sebagai Executor Berdasarkan hasil yang diperoleh dengan kedua skenario di atas, dapat disimpulkan bahwa dengan skenario pertama (Manager tidak diberlakukan sebagai Executor) secara umum waktu eksekusinya lebih cepat daripada skenario kedua (Manager diberlakukan sebagai Executor) meskipun perbedaannya tidak terlalu signifikan. Dengan demikian, speedup dan efisiensi pada skenario pertama juga lebih baik dibandingkan skenario kedua. Grafik perbandingan speedup dan efisiensi pada kedua skenario untuk nilai n = 1500 dapat dilihat pada Gambar 42. Perbandingan Efisiensi untuk n = 1500 1,4

4,5 4

1,2 1

3,5 3

efisiensi

speedup

Perbandingan Speedup untuk n = 1500 5

2,5 2 1,5 1

0,6 0,4

skenario 1

skenario 1

0,2

skenario 2

0,5 0

0,8

skenario 2

0

2

3

4

p

2

3

4

p

Gambar 42. Grafik Perbandingan Speedup dan Efisiensi hasil eksekusi PiCalculator pada kedua skenario untuk n = 1500 Dengan skenario kedua, PC yang bertindak sebagai Manager menggunakan sumber daya untuk dua pekerjaan, yaitu mendistribusikan thread dan juga mengeksekusi program. Sedangkan PC yang bertindak sebagai Manager dengan skenario pertama hanya bertugas untuk mendistribusikan thread. Oleh karena itu, waktu eksekusi yang diperoleh dengan skenario pertama lebih cepat daripada skenario kedua. Namun, waktu eksekusi pada keseluruhan eksperimen ini lebih lama jika dibandingkan dengan hasil eksperimen yang dilakukan oleh Laboratorium GRIDS University of Melbourne [2]. Hal ini disebabkan karena penentuan banyaknya digit yang dihitung dalam setiap thread berbeda. GRIDS menentukan sebanyak 50 digit yang dikerjakan dalam setiap thread, sedangkan eksperimen ini mengatur setiap thread untuk menghitung 10 digit. Berdasarkan perbedaan tersebut, dapat disimpulkan bahwa penentuan banyaknya digit yang dikerjakan dalam setiap thread mempengaruhi lamanya waktu eksekusi program. Semakin banyak digit yang dikerjakan berarti overhead yang terjadi lebih sedikit, sehingga waktu eksekusinya akan semakin cepat.

38

BAB VI KESIMPULAN

Pengujian kinerja Alchemi pada Laboratorium GHPC Fasilkom Universitas Indonesia dilakukan dengan menggunakan 5 buah PC Pentium IV 3 GHz 512 MB. Konfigurasi sistem yang diterapkan yaitu cluster (desktop grids). Aplikasi grid computing menggunakan framework Alchemi untuk menghitung nilai π diimplementasikan dengan C# yang berjalan diatas platform .NET dan menjalankan program PiCalculator. Eksperimen dilakukan dengan dua skenario, yang Manager tidak diberlakukan sebagai Executor dan Manager diberlakukan sebagai Executor. Banyaknya Executor yang digunakan bervariasi dari satu sampai empat Executor. Selain itu, banyaknya digit yang dihitung juga bervariasi, yaitu 500, 1000, 1500, 2000, dan 2500. Hasil eksperimen yang diperoleh baik dengan skenario pertama maupun kedua menunjukkan waktu eksekusi yang semakin cepat dan speedup yang menaik seiring dengan bertambahnya Executor yang digunakan. Pada ketelitian hingga 2500 digit, waktu eksekusi dengan 4 Executor ¼ kali lebih cepat dibandingkan dengan menggunakan 1 Executor. Sedangkan efisiensinya tidak menunjukkan suatu pola tertentu. Speedup dan efisiensi terbaik dicapai pada penghitungan π dengan ketelitian 1500 digit. Apabila hasil dari kedua skenario ini dibandingkan, waktu eksekusi, speed up, dan efisiensi dengan skenario pertama lebih baik daripada skenario kedua. Namun, waktu eksekusi pada keseluruhan eksperimen ini lebih lama jika dibandingkan dengan hasil eksperimen yang dilakukan oleh Laboratorium GRIDS University of Melbourne [2]. Hal ini disebabkan karena penentuan banyaknya digit yang dihitung dalam setiap thread berbeda. GRIDS menentukan sebanyak 50 digit yang dikerjakan dalam setiap thread, sedangkan eksperimen ini mengatur setiap thread untuk menghitung 10 digit. Berdasarkan perbedaan tersebut, dapat disimpulkan bahwa penentuan banyaknya digit yang dikerjakan dalam setiap thread mempengaruhi lamanya waktu eksekusi program. Proses instalasi Alchemi harus dilakukan secara berurutan sebagaimana yang telah digambarkan dalam skema tahapan instalasi. Hal ini perlu diperhatikan agar seluruh aplikasi yang diinstal dapat berjalan dengan baik.

39

REFERENSI

[1] [2] [3] [4] [5]

[6] [7] [8] [9]

Akshay Luther, Rajkumar Buyya, Rajiv Ranjan, and Srikumar Venugopal, Alchemi : A .NET-based Grid Computing Framework and its Integration into Global Grids, http://www.alchemi.net/files/alchemi_techreport.pdf (diakses 7 Mei 2007). Akshay Luther, Rajkumar Buyya, Rajiv Ranjan, and Srikumar Venugopal, Peer-to-Peer Grid Computing and a .NET-based Alchemi Framework, 2004, www.cs.utk.edu/~angskun/cns04/47-alchemi_chapter.pdf (diakses 7 Mei 2007). Krishna Nadiminti, Akshay Luther and Rajkumar Buyya, Alchemi : A.NET-based Enterprise Grid System and Framework, User Guide for Alchemi 1.0 , 2005. Krishna Nadiminti, Marcos Dias de Assunção, and Rajkumar Buyya, Distributed Systems and Recent Innovations: Challenges and Benefits, www.buyya.com/papers/InfoNetArticle06.pdf (diakses 7 Mei 2007). Md. Ahsan Arefin, Md. Shiblee Sadik, Serena Coetzee, Judith Bishop, Alchemi vs Globus: a performance comparison, Technical Report, Dept. of Computer Science and Software Engineering, 2006, http://polelo.cs.up.ac.za/papers/ICECE2006_AlchemiGlobus_9July.doc (diakses 7 Mei 2007). P. Koszek and K. Sandrasegaran, Grid Architecture Storage – Utilising Grid Computing for Dynamic Data Storage, Proceeding of the Third International Conference on Information Technology and Applications (ICITA’05), IEEE, 2005. Waclaw Kus, Evolutionary Optimization of Forging Anvils Using Grid Based on Alchemi Framework, Proceeding of the Second International Conference on e-Science and Grid Computing (e-Science’06), IEEE, 2006. www.globus.org

Fabrice Bellard, Computation of the n’th digit of pi in any base in O(n^2), http://fabrice.bellard.free.fr/pi/pi_n2/pi_n2.html (diakses 10 Mei 2007). [10] D.H., Bailey, P.B.borwein and S. Plouffe, On the Rapid Computation of Various Polylogarithmic Constants, Mathematics of Computation, vol. 66, p.903-913, 1997.

40

LAMPIRAN Lampiran 1. Rencana Kerja

Lampiran 2. Pembagian Tugas Kelompok No. 1.

Nama Wikan Pribadi

2.

Binti Solihah

3.

Chastine Fatichah

4.

Della Maulidiya

5.

Dhian Widya

6.

Widiyantono

-

Tugas Mengkoordinasikan anggota untuk mengerjakan tugas-tugas Bertanggungjawab untuk proses instalasi dan setting Alchemi Melakukan eksperimen Mengeksplorasi aplikasi PiCalculator Melakukan eksperimen Mengeksplorasi aplikasi PiCalculator Melakukan eksperimen Bertanggungjawab untuk penyelesaian laporan akhir Melakukan eksperimen Mengeksplorasi aplikasi PiCalculator Melakukan proses instalasi dan setting Alchemi

41