1. 1 Parallel Parentheses Matching Plus Some Applications

2. 2 Parentheses Matching Problem Definition: Given a well-formed sequence of parentheses stored in an array, determine the index of the mate of each parentheses stored in the array

3. 3 Example 12345678 ((())()) 85432761

4. 4 Sequential Solution Traditional solution uses a stack Push left parentheses, pop for a right parenthesis; these are a pair Can this method be implemented in parallel? Why or why not?

5. 5 Parallel Solution: Divide & Conquer Lemma 1: The mate of a parenthesis at an odd position in a balanced string lies in an even position (and vice versa). Lemma 2: If a balanced string has no left parenthesis at an even location (or, equivalently, a right at an odd location), then the mate of each left parenthesis in the string lies immediately to its right.

6. 6 Lemma 2 Any string that satisfies Lemma 2 is of form ( ) ( ) ( ) ( )….( ) and is referred to as form F.

7. 7 Algorithm Overview Each left position at an odd position and each right position are marked with a 0. All others are marked with a 1. These 2 disjoint sets are copied (packed) into a new array. Repeat for the 2 sets. Stop when each new substring is of form F.

8. 8 Algorithm Match For i = 1 to log n – 1 do if “(“ & index is odd then mark 0 else mark 1 Use segmented prefix sums to compute new index for each parenthesis Move parentheses to new location Determine if string is now in form F; if not, terminate – unbalanced string Match parentheses and store in original array

9. 9 Example 12345678 ((())()) 01001110 (())()() 0110 ()()()()

10. 10 Example – Keep Index 12345678 1 (2 (3 (4 )5 )6 (7 )8 ) 01001110 1 (3 (4 )8 )2 (5 )6 (7 ) 0110 1 (8 )3 (4 )2 (5 )6 (7 )

11. 11 Segmented Prefix Sum Problem Definition Given an array containing elements, some marked 0 and some marked 1. Compute the prefix sum of each subset. (For this application the sums will be on values of 1, to number the items.)

12. 12 Segmented Prefix Sum - Example 12345678 ((())()) 01001110 11232344 How can this be accomplished with one prefix sums operation?

13. 13 Parentheses Matching on Hypercube Use the Divide & Conquer strategy Consider 2 processors Each PC – assign 0/1 P0 send 1’s to P1; P1 send 0’s to P0 Each solve the sub-problem Does the problem split evenly? Consider Large problem – P0 & P2 take 0 items, P1 & P3 take 1 items

14. 14 PPM - Hypercube Overview of Algorithm 2-Cube: Special case of 2 pc hypercube 4-Cube: Used to partition large sub-problems consisting of 4 pc cubes Match: The Driving Algorithm

15. 15 Data Distribution INPUT array is divided into P equal partitions of size n/p First n/p items are given to P0, next n/p items to P1, etc. Final MATCH information for each item is stored in the original PC

16. 16 Data Distribution Array consists of elements INPUT which holds the parentheses & MATCH which will hold the final matching information Local Match: if the match is determined by the pc in which the match information is to be stored Non-local: otherwise

17. 17 Algorithm 2-Cube Mark left and right parentheses with 0/1 as previously discussed P0 & P1 exchange entries – P0 contains 0 and P1 contains 1 Each PC use stack to sequentially match parentheses Send non-local match operation to appropriate processor

18. 18 Algorithm 2-Cube – Step 1 12345678 (()(())) 01110010 Mark 0/1 P0 P1

19. 19 Algorithm 2-Cube – Step 2 & 3 15682347 (())()() 00001111 86513274 Exchange & Match P0 P1

20. 20 Algorithm 2-Cube – Step 4 12345678 (()(())) 01110010 83276541 Send non-local match information P0 P1

21. 21 Algorithm 4-Cube Basis of Algorithm Match Insures near-equal data distribution Overview Phase 1: local matches determined sequentially & communicated Phase 2: Unmatched parentheses marked, redistributed; P0 & P1 have 0’s, P2 & P3 have 1’s (half each)

22. 22 Algorithm 4- Cube Phase 1: Sequential Processing 1. Each PC use stack to match 2. Send non-local Match to other PC 3. Count unmatched parentheses; prefix sum to reindex

23. 23 Algorithm 4-Cube Phase 2 1. Mark parentheses with 1/0 2. P0 & P2 exchange: P0=0 & P2=1 Likewise, P1=0 and P3=1 3. P0 & P1 exchange number information; likewise for P2 & P3 4. P0 & P1 exchange entries; P0 obtains 1 st half: likewise for P2 & P3

24. 24 Algorithm 4-Cube Distribution of Data – 64 entries P0 Init.1-16 P1 Init.17-32 1-21-16,33-48 (0)1-217-32, 49-64(0) 3-41-32 (0)3-433-64 (0) P2 Init.33-48 P3 Init.49-64 1-21-16,33-48 (1)1-217-32, 49-64(1) 3-41-32 (1)3-433-64 (1)

25. 25 Algorithm Hypercube Match 1. Each subcube of size 4 executes 4-Cube // Logically P/2 subcubes with independent subproblems 2. Each subcube (p/2) prefix sums to determine new index 3. Each subcube from Step 1 recursively repeat 1, 2, 3 until each subcube is of size 2 4. Execute 2-Cube to complete the solution

26. 26 Algorithm Hypercube Match Complexity Analysis O (log 2 p + n/p log p) For p=n/log n simplifies to O(log 2 n) Is the Algorithm Optimal?