# Linked List Ranking Parallel Algorithms 1. Work Analysis – Pointer Jumping Number of Steps: Tp = O(Log N) Number of Processors: N Work = O(N log N) T1.

## Presentation on theme: "Linked List Ranking Parallel Algorithms 1. Work Analysis – Pointer Jumping Number of Steps: Tp = O(Log N) Number of Processors: N Work = O(N log N) T1."— Presentation transcript:

Linked List Ranking Parallel Algorithms 1

Work Analysis – Pointer Jumping Number of Steps: Tp = O(Log N) Number of Processors: N Work = O(N log N) T1 = O(N) Work Optimal?? 2

Common List Ranking Strategy Reduce Rank Expand Strategy Similar to Odd-Even Prefix Sums Algorithms vary in how items are selected for deletion in the Reduce Step Some variation in the Expand Step. 3

Reduce Rank Expand Reduction Step - Delete non-adjacent elements in parallel until the list is of size O(p) (algorithms vary is this step) Rank Step – Pointer jumping to rank the p remaining elements Expand Step – Reinsert elements (in the reverse order), computing the rank as it is inserted 4

Asynchronous PRAM – APRAM Variant of the PRAM model Features of CRCW PRAM – Plus Processors may have different clock speeds and work asynchronously Each processor has own random number generator 5

Randomized Algorithm Some portion of the algorithms outcome is non-deterministic Performance stated in terms of expected order of time complexity – EO(f(n)) EO(f(n)) – with high probability the results are within order f(n) 6

APRAM List Ranking by Martel & Subramonian 1.Select m=EO(n/log n) elements at random 1.Each generates a random number between 1-N, selects those with values 1 to N / log N 2.Perform log log n iterations of pointer jumping 1.Each points to selected, nil, or pointer length log n 3.Pack selected elements to smaller array 4.Scan: each selected points to next selected or nil 5.Compute ranks of selected list-pointer jumping 6.Copy back to original list; scan to complete ranks *EO(n log log n) using p = O(n/log n) 7

List 0368512411071014121513 Rank 1111111111111111 Step1 R# 3810391316112157186412 Sel ***** Step2 List 08111015 Rank 35332 Step3 Rank 1613852 Step4 Rank 16151413121110987654321 Demo: APRAM Randomized Algorithm 8

Modifications for EREW Model APRAM Each PU operates asynchronously Must synchronize each at step Steps 2, 4, 6 allow for Concurrent Reads EREW Default execution is synchronous Partition the array to eliminate Concurrent Reads 9

Randomized EREW Algorithm (4.1) Select O(p) elements at random Each generates a random number between 1-N, selects those with values 1 to N / log N Pack selected items into smaller array Scan from selected item to next to set rank Rank selected elements by pointer jumping Write ranks back to original array Scan from selected items to set remaining ranks 10

List 0368512411071014121513 Rank 1111111111111111 Step1 R# 3810391316112157186412 Sel ***** Stp2 List 08111015 Rank 35332 Stp3 Rank 1613852 Stp4 Rank 16151413121110987654321 Demo: EREW Randomized Algorithm 11

Complexity Analysis Selection - EO(n/p) Compaction - prefix sums EO(n/p + log p) Form LL - EO(n/p) Pointer Jumping - EO ( n/p + log p) Sequential Scan - EO(n/p) OVERALL - EO ( n/p + log p) Optimal speedup for p <= O (n / log n) Which gives EO ( log n) time See paper for proof. 12

What next?? Can we accomplish an O(log n) deterministic algorithm? What was randomized in other algorithms? Can it be made deterministic? 13

Answer! Yes & No, Can Reduce deterministically! Near Optimal 2-Ruling Set (Cole & Vishkin) A subset of the list such that no 2 elements are adjacent & there are exactly 1 or 2 non-ruling set elements between each ruling set element & its nearest successor 14

Deterministic EREW LLR Step 1 Select a Ruling Set of O(p) elements, O(n/p) distance apart Keep track of actual distance (for ranking) Repeatedly apply 2-Ruling Set Algorithm to increase the distance between the elements Remaining steps are same 15

Complexity Analysis 1.Select O(p) elements O(n/p) distance apart – O(n/p * log (n/p)) 2.Compact – O(n/p + log p) 3.Rank – O(n/p + log p) 4.Write back then Scan – O(n/p) O((log p) + (n/p) * log(n/p)) = O(n/p * log (n/p) ) for n>= p log p = O(log n log log n) for p =O(n/log n) Work O(n log log n) 16

17

Advantages of New Algorithms Simple, use basic strategies Small constants Small space requirements Optimal & Near Optimal 18

Similar presentations