Lecture 5 prepared by Dragos Brad 222839 Mariam

Lecture 5 prepared by: Dragos Brad (#222839) Mariam Abdi

Work-Time Framework chapter 1 (Jaja’s book) Two levels: Upper (software) - describes the algorithm in terms of a sequence of time units, where each time unit may include any number of concurrent operations. Note: no need to mention processors the numnber of operations is easy to compute Lower (hardware) - this level will not be addressed in the course.

WT Scheduling Principle Let the Wi(n) be the number of operations performed in step i (1 i T(n)). Wi(n) Simulate each set of Wi(n) operations in parallel p steps by a p-processor PRAM. P-Processor PRAM: Wi(n) p i=1 T(n) W 1(n) p W 2(n) + +. . . p Wi(n) 1+ p i=1 T(n) W(n) T(n) + p

Summary of Chapter 1 • Know what’s meant by the Upper level • Work of an algorithm equals the total sum of all operations • T(n) = time it takes a processor to complete work • Speed-up = Sequential_time / T(n) • Cost(n) = T(n) P(n) • PRam Model and other models were discussed

Techniques - Part 1 chapter 2 (Jaja’s book) 1) Balanced Trees: Builds a balanced tree on the input elements and traverses the tree forward and backward to and from the root. Example: The Prefix-Sum Problem There is a sequence of n-elements {x 1, x 2, …, xn} drawn from a set S with the binary associative operation *. The prefix sums of this sequence are the n partial sums defined by: si = x 1 * x 2 * … * x i , 1 i n A balanced binary tree will be used to derive a fast parallel algorithm to compute the prefix sums.

Balanced trees continuation + x 1 + x 2 +…+ x 8 x 1 + x 2 + x 3 + x 4 x 5 + x 6 + x 7 + x 8 + + x 1 + x 2 x 3 + x 4 + x x 5 + x 6 + x 2 x 3 x 7 + x 8 + x 4 x 5 + x 6 x 7 x 8 Illustration of balanced trees for the ‘prefix-sums’ problem. (Each internal node represents the application of the operation ‘+’ to its children during a forward traversal of the tree. Hence, each node v holds the sum of the elements stored in the leaves of the subtree rooted at v. During a backward traversal of the tree, the prefix sums of the data stored in the nodes at a given height are computed)

Techniques - Part 2 a chapter 2 (Jaja’s book) 2) Pointer Jumping: This technique allows the fast processing of data stored in the form of a set of rooted directed trees. Example 1: Finding the Roots of a Forest Problem Let F be a forest consisting of a set of rooted directed trees. The forest F is specified by an array P of length n such that P(i) = j if j is the parent of i in a tree of F. The problem is to determine the root S(j) of the tree containing the node j, for each j between 1 and n.

Pointer Jumping continuation x 9 x 4 x 12 x 6 x 3 x 2 x Step 1 - 1 st iteration Step 2 - 2 nd iteration Step 3 - 3 rd iteration 5 The technique of pointer jumping consists of updating the successor of each node by that successor’s successor. As the technique is applied repeatedly, the successor of a node is an ancestor that becomes closer and closer to the root of the tree containing that node. After k iterations, the distance between i and S(i) as they appear in the directed tree of F is 2 k unless S(i) is a root. Illustration of pointer jumping for the ‘finding the roots of a forest’ problem.

Pointer Jumping continuation Algorithm - Finding the roots of a forest Input: A forest of rooted trees, each with a self-loop at its root. Output: For each vertex i, the root S(i) of the tree containing i. for i =1 to n do S[i] = P[i]; while S[i] S[S[i]] do S[i] = S[S[i]]; Analysis: Time Work O(log h) time O(n*log h) operations Note: h is the maximum height of any tree in the forest, n is the total number of vertices in the forest

Pointer Jumping continuation Techniques - Part 2 b chapter 2 (Jaja’s book) Example 2: Parallel Prefix Problem Here it’s assumed that each node i in the forest has a weight W(i). The pointer jumping technique it’s used, in this case, to compute for each node i, the sum of the weights stored in the nodes on the path from the node i to the root of i’s tree. This amounts to generating the prefix sums of several sequences of elements such that each sequence is given by the order of nodes as they appear on each path. Please think of an algorithm for this, that runs in O(log n) time and O(n*log n) work.

Pointer Jumping continuation 0 10 11 2 7 0 0 2 7 3 4 0 X 20 0 5 6 Illustration of pointer jumping for the ‘parallel-prefix’ problem. (Above, the weight of element x 20 is 17 since it’s the sum of all the weights of the nodes between x 20 and the root of its tree)