and Divide-and-Conquer Strategies Chapter 4 Partitioning and Divide-and-Conquer Strategies

Partitioning Partisi sebenarnya sederhana saja, yaitu membagi masalah menjadi beberapa bagian. Divide and Conquer Dikarakterisasikan dengan membagi masalah menjadi sub-masalah dengan bentuk yang sama dengan masalah yang lebih besar. Pembagian selanjutnya menjadi sub-masalah yang lebih kecil lagi biasanya dilakukan dengan rekursi. Recursive divide and conquer amenable to parallelization because separate processes can be used for divided parts. Also usually data is naturally localized. 4.1

Partitioning/Divide and Conquer Contoh Partitioning/Divide and Conquer Banyak kemungkinan. • Operasi pada deret bilangan seperti penjumlahan. • Beberapa algoritma sorting seringkali dapat dipartisi atau dibangun dengan cara rekursif. • Integrasi numerik • N-body problem 4.2

Partisi deret bilangan menjadi beberapa bagian dan menjumlahkan bagian-bagian tersebut 4.3

Tree construction (Membangun pohon) 4.4

Membagi list menjadi beberapa bagian 4.5

Penjumlahan Parsial 4.6

Quadtree 4.7

Membagi citra (image) 4.8

Bucket sort Satu “bucket” diisi bilangan yang berada dalam setiap bagian. Bilangan pada setiap bucket di-sortir dengan menggunakan algoritma sorting sekuensial. Kompleksitas waktu sorting: O(nlog(n/m). Cara ini berjalan dengan baik jika bilangan aslinya terdistribusi uniform pada interval yang diketahui, misalnya dari 0 sampai a - 1. 4.9

Versi paralel bucket sort Pendekatan sederhana Satu prosesor untuk satu bucket. 4.10

Paralelisasi selanjutnya Partisi deret menjadi m bagian, satu bagian untuk satu prosesor. Setiap prosesor menyimpan p bucket “kecil” dan membagi bilangan pada bagiannya me bucket-bucket kecilnya sendiri. Bucket-bucket kecil kemudian mengirimkan isinya ke p final bucket untuk sorting, yang membutuhkan setiap prosesor mengirim satu bucket kecil ke semua prosesor yang lain (bucket i ke prosesor i). 4.11

Versi paralel yang lain dari bucket sort Memperkenalkan operasi message-passing baru - all-to-all broadcast. 4.12

Rutin “all-to-all” broadcast Mengirim data dari setiap proses ke semua proses yang lain 4.13

Rutin “all-to-all” sebenarnya mentransfer baris array ke kolom: Transpose matriks. 4.14

Integrasi numerik menggunakan persegi empat Setiap bagian dihitung dengan menggunakan aproksimasi yang diberikan oleh segi empat: Align segi empat: 4.15

Integrasi numerik dengan menggunakan metode trapesium Mungkin tidak lebih baik! 4.16

Adaptive Quadrature Dipilih solusi: membentuk kurva. Gunakan tiga area, A, B, dan C. Komputasi berakhir ketika A and B yang paling besar cukup dekat dengan jumlah dua area yang tersisa. 4.17

Adaptive quadrature with false termination. Harus hati-hati dalam memilih waktu untuk berhenti. Bisa menyebabkan berhenti di awal, karena dua daerah tersebut sama (i.e., C = 0). 4.18

3.19

pi_calc.cpp calculates value of pi and compares with actual /********************************************************************************* pi_calc.cpp calculates value of pi and compares with actual value (to 25digits) of pi to give error. Integrates function f(x)=4/(1+x^2). July 6, 2001 K. Spry CSCI3145 **********************************************************************************/ #include <math.h> //include files #include <iostream.h> #include "mpi.h“ void printit(); //function prototypes int main(int argc, char *argv[]) { double actual_pi = 3.141592653589793238462643; //for comparison later int n, rank, num_proc, i; double temp_pi, calc_pi, int_size, part_sum, x; char response = 'y', resp1 = 'y'; MPI::Init(argc, argv); //initiate MPI 4.20

num_proc = MPI::COMM_WORLD.Get_size(); rank = MPI::COMM_WORLD.Get_rank(); if (rank == 0) printit(); /* I am root node, print out welcome */ while (response == 'y') { if (resp1 == 'y') { if (rank == 0) { /*I am root node*/ cout <<"__________________________________" <<endl; cout <<"\nEnter the number of intervals: (0 will exit)" << endl; cin >> n;} } else n = 0; MPI::COMM_WORLD.Bcast(&n, 1, MPI::INT, 0); //broadcast n if (n==0) break; //check for quit condition 4.21

int_size = 1.0 / (double) n; //calcs interval size part_sum = 0.0; else { int_size = 1.0 / (double) n; //calcs interval size part_sum = 0.0; for (i = rank + 1; i <= n; i += num_proc) { //calcs partial sums x = int_size * ((double)i - 0.5); part_sum += (4.0 / (1.0 + x*x)); } temp_pi = int_size * part_sum; //collects all partial sums computes pi MPI::COMM_WORLD.Reduce(&temp_pi,&calc_pi, 1, MPI::DOUBLE, MPI::SUM, 0); 4.22

if (rank == 0) { /*I am server*/ cout << "pi is approximately " << calc_pi << ". Error is " << fabs(calc_pi - actual_pi) << endl <<"_______________________________________" << endl; } } //end else if (rank == 0) { /*I am root node*/ cout << "\nCompute with new intervals? (y/n)" << endl; cin >> resp1; }//end while MPI::Finalize(); //terminate MPI return 0; } //end main 4.23

cout << "\n*********************************" << endl //functions void printit() { cout << "\n*********************************" << endl << "Welcome to the pi calculator!" << endl << "Programmer: K. Spry" << endl << "You set the number of divisions \nfor estimating the integral: \n\tf(x)=4/(1+x^2)" << endl << "*********************************" << endl; } //end printit 4.24

Gravitational N-Body Problem Untuk menemukan posisi dan pergerakan benda luar angkasa di bawah pengaruh gravitasi dari benda lainnya, dengan menggunakan hukum fisika Newton. 4.25

Gravitational N-Body Problem Equations Gaya gravitasi antara dua benda dengan massa ma and mb: G adalah konstanta gravitasi dan r adalah jarak antar kedua benda tersebut. Dengan adanya gaya, benda dipercepat sesuai dengan hukum ke-dua Newton: F = ma m adalah massa benda, F adalah gaya yang dialaminya, dan a adalah percepatan yang dihasilkan. 4.26

Detail Jika interval waktu adalah t, untuk benda dengan massa m, gaya adalah: New velocity is: where vt+1 is the velocity at time t + 1 and vt is the velocity at time t. Over time interval t, position changes by where xt is its position at time t. Once bodies move to new positions, forces change. Computation has to be repeated. 4.27

Overall gravitational N-body computation can be described by: Sequential Code Overall gravitational N-body computation can be described by: for (t = 0; t < tmax; t++) /* for each time period */ for (i = 0; i < N; i++) { /* for each body */ F = Force_routine(i); /* compute force on ith body */ v[i]new = v[i] + F * dt / m; /* compute new velocity */ x[i]new = x[i] + v[i]new * dt; /* and new position */ } for (i = 0; i < nmax; i++) { /* for each body */ x[i] = x[i]new; /* update velocity & position*/ v[i] = v[i]new; 3.28

Parallel Code Algoritma sekuensial merupakan algoritma O(N2) (untuk satu iterasi) karena setiap N benda saling mempengaruhi dengan N - 1 benda lainnya. Algoritma langsung seperti ini tidak layak digunakan untuk sebagian besar N-body problems ketika nilai N sangat besar. 4.29

Kompleksitas waktu dapat diperkecil dengan aproksimasi cluster benda-benda jauh sebagai satu benda dengan massa yang terpusat di pusat massa cluster: 4.30

Algoritma Barnes-Hut Mulai dengan seluruh luar angkasa sebagai satu kotak yang berisi benda (atau partikel). • Pertama, bagi kotak ini menjadi 8 subkotak. • Jika suatu subkotak tidak memiliki partikel, subkotak ini dihapus. • Jika suatu subkotak berisi satu benda, subkotak tersebut dipertahankan. • Jika satu subkotak berisi lebih dari satu benda, subkotak tersebut dibagi secara rekursif sampai setiap subkotak hanya berisi satu benda. 4.31

Buat octtree – satu pohon dengan sisi edge sampai 8 dari setiap node. Setiap daun merepresentasikan sel yang berisi 1 benda. Setelah pohon selesai dibangun, massa total dan pusat massa subkotak disimpan pada setiap node. 4.32

Dengan adalah konstanta bernilai 1.0 atau kurang. Gaya pada setiap benda didapat dengan melakukan tree traversal yang dimulai dari root, berhenti di node jika aproksimasi cluster dapat digunakan, misalnya ketika: Dengan adalah konstanta bernilai 1.0 atau kurang. Membangun pohon membutuhkan waktu O(nlogn), demikian juga untuk mengitung semua gaya, sehingga kompleksitas waktu seluruhnya adalah O(nlogn). 4.33

Pembagian Rekursif dari ruang 2-dimensi 4.34

Orthogonal Recursive Bisection (Untuk area 2-dimensi) Pertama, buat garis vertikal yang membagi area tersebut menjadi dua dengan jumlah benda yang sama. Untuk setiap area, buat garis horizontal yang membagi area tersebut menjadi dua dengan jumlah benda yang sama. Ulangi jika masih diperlukan. 4.35

Astrophysical N-body simulation By Scott Linssen (UNCC student, 1997) using O(N2) algorithm. 4.36

Astrophysical N-body simulation By David Messager (UNCC student 1998) using Barnes-Hut algorithm. 4.37