# 1 5.1 Pipelined Computations. 2 Problem divided into a series of tasks that have to be completed one after the other (the basis of sequential programming).

## Presentation on theme: "1 5.1 Pipelined Computations. 2 Problem divided into a series of tasks that have to be completed one after the other (the basis of sequential programming)."— Presentation transcript:

1 5.1 Pipelined Computations

2 Problem divided into a series of tasks that have to be completed one after the other (the basis of sequential programming). Each task executed by a separate process or processor

TRADITIONAL PIPELINE CONCEPT Laundry Example Ann, Brian, Cathy, Dave each have one load of clothes to wash, dry, and fold Washer takes 30 minutes Dryer takes 40 minutes “Folder” takes 20 minutes ABCD

TRADITIONAL PIPELINE CONCEPT Sequential laundry takes 6 hours for 4 loads If they learned pipelining, how long would laundry take? ABCD 304020304020304020304020 6 PM 789 10 11 Midnight Time

TRADITIONAL PIPELINE CONCEPT Pipelined laundry takes 3.5 hours for 4 loads ABCD 6 PM 789 10 11 Midnight TaskOrderTaskOrder Time 3040 20

TRADITIONAL PIPELINE CONCEPT Pipelining doesn’t help latency of single task, it helps throughput of entire workload Pipeline rate limited by slowest pipeline stage Multiple tasks operating simultaneously using different resources Potential speedup = Number pipe stages Unbalanced lengths of pipe stages reduces speedup ABCD 6 PM 789 TaskOrderTaskOrder Time 3040 20

7 Example Add all the elements of array a to an accumulating sum: for (i = 0; i < n; i++) sum = sum + a[i]; The loop could be “unfolded” to yield sum = sum + a[0]; sum = sum + a[1]; sum = sum + a[2]; sum = sum + a[3]; sum = sum + a[4];.

8 Pipeline for an unfolded loop

9 Where pipelining can be used to good effect Assuming problem can be divided into a series of sequential tasks, pipelined approach can provide increased execution speed under the following three types of computations: 1. If more than one instance of the complete problem is to be Executed 2. If a series of data items must be processed, each requiring multiple operations 3. If information to start next process can be passed forward before process has completed all its internal operations

SIX STAGE INSTRUCTION PIPELINE 10

TIMING DIAGRAM FOR INSTRUCTION PIPELINE OPERATION 11

12 “Type 1” Pipeline Space-Time Diagram

13 Alternative space-time diagram

14 “Type 2” Pipeline Space-Time Diagram

15 “Type 3” Pipeline Space-Time Diagram Pipeline processing where information passes to next stage before previous state completed.

16 If the number of stages is larger than the number of processors in any pipeline, a group of stages can be assigned to each processor:

17 Computing Platform for Pipelined Applications Multiprocessor system with a line configuration

18 Example Pipelined Solutions (Examples of each type of computation)

19 Pipeline Program Examples Adding Numbers Type 1 pipeline computation

20 Basic code for process Pi : recv(&accumulation, P i-1 ); accumulation = accumulation + number; send(&accumulation, P i+1 ); except for the first process, P 0, which is send(&number, P 1 ); and the last process, P n-1, which is recv(&number, P n-2 ); accumulation = accumulation + number;

21 SPMD program if (process > 0) { recv(&accumulation, P i-1 ); accumulation = accumulation + number; } if (process < n-1) send(&accumulation, P i+1 ); The final result is in the last process. Instead of addition, other arithmetic operations could be done.

22 Pipelined addition numbers Master process and ring configuration

SORTING NUMBERS INSERTION SORT ALGORITHM For each array element from the second to the last (nextPos = 1)  Insert the element at nextPos where it belongs in the array, increasing the length of the sorted subarray by 1 23

24 Sorting Numbers A parallel version of insertion sort.

25 Pipeline for sorting using insertion sort Type 2 pipeline computation

26 The basic algorithm for process P i is recv(&number, P i-1 ); if (number > x) { send(&x, P i+1 ); x = number; } else send(&number, P i+1 ); With n numbers, number ith process is to accept = n - i. Number of passes onward = n - i - 1 Hence, a simple loop could be used.

27 Insertion sort with results returned to master process using bidirectional line configuration

28 Insertion sort with results returned

PRIME NUMBER GENERATION SIEVE OF ERATOSTHENES 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 29 Next_Prime = 2 ====> Mark multiples of 2 as non-prime. 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 Next_Prime = 3 ====> Mark multiples of 3 as non-prime.

30 Prime Number Generation Sieve of Eratosthenes Series of all integers generated from 2. First number, 2, is prime and kept. All multiples of this number deleted as they cannot be prime. Process repeated with each remaining number. The algorithm removes non-primes, leaving only primes. Type 2 pipeline computation

31 The code for a process, P i, could be based upon recv(&x, P i-1 ); /* repeat following for each number */ recv(&number, P i-1 ); if ((number % x) != 0) send(&number, P i+1 ); Each process will not receive the same number of numbers and is not known beforehand. Use a “terminator” message, which is sent at the end of the sequence: 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 ); }

32 GAUSSIAN ELIMINATION (GE) FOR SOLVING AX=B … for each column i … zero it out below the diagonal by adding multiples of row i to later rows for i = 1 to n-1 … for each row j below row i for j = i+1 to n … add a multiple of row i to row j tmp = A(j,i); for k = i to n A(j,k) = A(j,k) - (tmp/A(i,i)) * A(i,k) 0...00...0 0...00...0 0.00.0 0 0000 0...00...0 0...00...0 0.00.0 0...00...0 0...00...0 0...00...0 After i=1After i=2After i=3After i=n-1 …

33 Solving a System of Linear Equations Upper-triangular form where a’s and b’s are constants and x’s are unknowns to be found.

34 Back Substitution First, unknown x 0 is found from last equation; i.e., Value obtained for x 0 substituted into next equation to obtain x 1 ; i.e., Values obtained for x 1 and x 0 substituted into next equation to obtain x 2 : and so on until all the unknowns are found.

35 Pipeline Solution First pipeline stage computes x 0 and passes x 0 onto the second stage, which computes x 1 from x 0 and passes both x 0 and x 1 onto the next stage, which computes x 2 from x 0 and x 1, and so on. Type 3 pipeline computation

36 The ith process (0 < i < n) receives the values x 0, x 1, x 2, …, x i-1 and computes x i from the equation:

37 Sequential Code Given constants a i,j and b k stored in arrays a[ ][ ] and b[ ], respectively, and values for unknowns to be stored in array, x[ ], sequential code could be x[0] = b[0]/a[0][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]; }

38 Parallel Code Pseudo-code of process P i (1 < i < n) of could be 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 ); Now have additional computations to do after receiving and resending values.

39 Pipeline processing using back substitution

Download ppt "1 5.1 Pipelined Computations. 2 Problem divided into a series of tasks that have to be completed one after the other (the basis of sequential programming)."

Similar presentations