Pipelined Computations

Problem/ masalah terbagi menjadi serangkaian tugas yang harus diselesaikan satu demi satu
(dasar pemrograman sekuensial). Setiap tugas dijalankan oleh proses atau prosesor yang terpisah.

Contoh:
Tambahkan semua elemen dari array A ke jumlah akumulasi:

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

sum = sum + a[i];
Loop bisa "dilipat" untuk menghasilkan :

sum = sum + a[0];

sum = sum + a[1];
sum = sum + a[2];
sum = sum + a[3];
sum = sum + a[4];

Dimana pipelining bisa digunakan untuk efek yang baik?

Dengan asumsi masalah dapat dibagi menjadi serangkaian tugas sekuensial, pendekatan
pipelined dapat memberikan peningkatan kecepatan eksekusi berdasarkan tiga jenis perhitungan
berikut:
1. Jika lebih dari satu contoh masalah lengkap harus dijalankan
2. Jika serangkaian item data harus diproses, masing-masing memerlukan beberapa operasi
3. Jika informasi untuk memulai proses selanjutnya dapat diteruskan sebelum proses
menyelesaikan semua operasi internalnya

Type 1 Pipeline Space-Time Diagram

Alternative space-time diagram

Type 2 Pipeline Space-Time Diagram

Type 3 Pipeline Space-Time Diagram

Jika jumlah tahapan lebih besar dari jumlah prosesor dalam setiap pipa, sekelompok tahap dapat
ditugaskan ke setiap prosesor:
Platform Komputasi untuk Aplikasi Pipelined
Sistem multiprosesor dengan konfigurasi garis.

Pipa sebenarnya mungkin bukan merupakan struktur terbaik untuk pengelompokkan bagaimanpun
pengelompokkan dengan koneksi langsung yang diaktifkan, dapat mendukung pengiriman pesan
secara simultan.

Example Pipelined Solutions

(Contoh dari setiap jenis komputasi)

1. Penambahan Angka

Kode dasar untuk proses Pi:

recv(&accumulation, Pi-1);
accumulation = accumulation + number;
send(&accumulation, Pi+1);

Kecuali untuk proses pertama, P0 :

send(&number, P1);

dan proses terakhir, Pn-1, yaitu :

recv(&number, Pn-2);
accumulation = accumulation + number;

Penjumlahan angka pipeline dengan proses master dan konfigurasi cincin :

SPMD program

if (process > 0) {
recv(&accumulation, Pi-1);
accumulation = accumulation + number;
}
if (process < n-1)
 send(&accumulation, P i+1);

2. Sorting Numbers

Implementasi Pipeline untuk insertion-sort :

Algortima dasar untuk proses Pi adalah

recv(&number, P i-1 );
if (number > x) {
send(&x, P i+1 );
x = number;
} else send(&number, P i+1 );
Dengan n angka, berapa banyak proses ke-i yang akan diterima diketahui, diberikan oleh n -
i. Berapa banyak yang di pass kedepan juga diketahui; diberikan oleh n - i - 1 karena satu dari
jumlah yang diterima tidak di pass kedepan. Maka loop sederhana dapat digunakan.

Insertion sort dengan hasil kembali ke proses master menggunakan konfigurasi baris dua
arah :
3. Pembangkit Bilangan Prima
Deretan integer dibangkitkan dari 2. Bilangan pertama, 2, adalah prima dan disimpan.
Seluruh kelipatan bilangan ini dihilangkan karena bukan merupakan bilangan prima. Proses
dilakukan secara berulang untuk bilangan berikutnya. Algoritma membuang nonprima, dan
meninggalkan hanya bilangan prima

Komputasi Pipeline

Kode untuk proses, Pi, dapat didasarkan pada

recv(&x, P i-1 );
/* repeat following for each number */
recv(&number, P i-1 );
if ((number % x) != 0) send(&number, P i+1 );
Setiap proses tidak akan menerima jumlah angka yang sama dan jumlahnya tidak diketahui
sebelumnya. Gunakan pesan "terminator", yang dikirim pada akhir urutan:

recv(&x, P i-1 );
for (i = 0; i < n; i++) {
recv(&number, P i-1 );
if (number == terminator) break;
if (number % x) != 0) send(&number, P i+1 );
}
4. Menyelesaikan Sistem Persamaan Linier Kasus Khusus
Contoh tipe 3 proses dapat melanjutkan pekerjaan lain setelah mem-passing informasi
Untuk menyelesaikan persamaan linier dalam bentuk upper triangular:

Dimana a dan b adalah konstanta dan x adalah yang akan dicari.

Pertama, x0 dapat dilihat dari persamaan terakhir

Nilai untuk x0 disubtitusi ke persamaan berikutnya untuk mendapatkan x1

Nilai x0 dan x1 disubtitusi ke persamaan berikutnya untuk mendapatkan x2:

Begitu seterusnya sampai seluruhnya diketahui.

Solusi Pipeline
Pipeline tahap pertama menghitung x0 dan di pass ke tahap kedua, yang menghitung
x1 dari x0 dan mem-pass kedua x0 dan x1 ke tahap berikutnya, untuk menghitung x2 from x0
and x1 , dan seterusnya

Proses ke i (0 < i < n) menerima nilai x0 , x1 , x2 , , x I-1 dan menghitung xi dari persamaan :
 Kode Konsekuensial
Konstanta a i,j dan b k disimpan dalam array a[] dan b[], dan nilai untuk yang dicari disimpan
dalam array, x[], kode sekuensialnya:
x[0] = b[0]/a[0][0]; /* x[0] computed separately */
for (i = 1; i < n; i++) { /* for remaining unknowns */
sum = 0;
for (j = 0; j < i; j++
sum = sum + a[i][j]*x[j];
x[i] = (b[i] - sum)/a[i][i];
}

Kode Paralel
Pseudocode proses P i (1 < i < n) dari satu versi pipeline adalah:
for (j = 0; j < i; j++) {
recv(&x[j], P i-1 );
send(&x[j], P i+1 );
}
sum = 0;
for (j = 0; j < i; j++)
sum = sum + a[i][j]*x[j];
x[i] = (b[i] - sum)/a[i][i];
send(&x[i], P i+1 );
Ada komputasi tambahan yang dilakukan setelah menerima dan mengirim ulang nilai.

Pipeline processing using back substitution