Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n...
-
date post
22-Dec-2015 -
Category
Documents
-
view
217 -
download
0
Transcript of Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n...
![Page 1: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/1.jpg)
Advanced Topics in Algorithms and Data Structures
1
Two parallel list ranking algorithms
• An O(log n) time and O(n log n) work list ranking algorithm.
• An O(log n loglog n) time and O(n) work list ranking algorithm.
![Page 2: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/2.jpg)
Advanced Topics in Algorithms and Data Structures
2
List ranking
Input: A linked list L of n elements.L is given in an array S such that the entry S(i) contains the index of the node which is the successor of the node i in L.Output: The distance of each node i from the end of the list.
![Page 3: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/3.jpg)
Advanced Topics in Algorithms and Data Structures
3
List ranking
List ranking can be solved in O(n) time sequentially for a list of length n.
Exercise : Design an algorithm.
•Hence, a work-optimal parallel algorithm should do only O(n) work.
![Page 4: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/4.jpg)
Advanced Topics in Algorithms and Data Structures
4
A simple list ranking algorithm
Output: For each 1 i n, the distance R(i) of node i from the end of the list.begin
for 1 i n do in parallelif S(i) 0 then R(i) := 1
else R(i) := 0endfor
while S(i) 0 and S(S(i)) 0 doSet R(i) := R(i) + R(S(i))Set S(i) := S(S(i))
end
![Page 5: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/5.jpg)
Advanced Topics in Algorithms and Data Structures
5
A simple list ranking algorithm
• At the start of an iteration of the while loop, R(i) counts the nodes in a sublist starting at i (a subset of nodes which are adjacent in the list).
![Page 6: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/6.jpg)
Advanced Topics in Algorithms and Data Structures
6
A simple list ranking algorithm
• After the iteration, R(i) counts the nodes in a sublist of double the size.
• When the while loop terminates, R(i) counts all the nodes starting from i and until the end of the list
![Page 7: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/7.jpg)
Advanced Topics in Algorithms and Data Structures
7
Complexity and model
•The algorithm terminates after O(log n) iterations of the while loop.
•The work complexity is O(n log n) since we allocate one processor for each node.
•We need the CREW PRAM model since several nodes may try to read the same successor (S) values.
![Page 8: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/8.jpg)
Advanced Topics in Algorithms and Data Structures
8
Complexity and model
Exercise : Modify the algorithm to run on the EREW PRAM with the same time and processor complexities.
![Page 9: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/9.jpg)
Advanced Topics in Algorithms and Data Structures
9
The strategy for an optimal algorithm
• Our aim is to modify the simple algorithm so that it does optimal O(n) work.
• The best algorithm would be the one which does O(n) work and takes O(log n) time.
• There is an algorithm meeting these criteria, however the algorithm and its analysis are very involved.
![Page 10: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/10.jpg)
Advanced Topics in Algorithms and Data Structures
10
The strategy for an optimal algorithm
• We will study an algorithm which does O(n) work and takes O(log n loglog n) time.
• However, in future we will use the optimal algorithm for designing other algorithms.
![Page 11: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/11.jpg)
Advanced Topics in Algorithms and Data Structures
11
The strategy for an optimal algorithm
1. Shrink the initial list L by removing some of the nodes.The modified list should have O(n / log n) nodes.
2. Apply the pointer jumping technique (the suboptimal algorithm) on the list with O(n / log n) nodes.
![Page 12: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/12.jpg)
Advanced Topics in Algorithms and Data Structures
12
The strategy for an optimal algorithm
3. Restore the original list and rank all the nodes removed in Step 1.
The important step is Step1. We need to choose a subset I of nodes for removal.
![Page 13: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/13.jpg)
Advanced Topics in Algorithms and Data Structures
13
Independent setsDefinitionA set I of nodes is independent if whenever i I , S(i) I.
The blue nodes form an independent set in this list
![Page 14: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/14.jpg)
Advanced Topics in Algorithms and Data Structures
14
Independent sets
• The main task is to pick an independent set correctly.
• We pick an independent set by first coloring the nodes of the list by two colors.
![Page 15: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/15.jpg)
Advanced Topics in Algorithms and Data Structures
15
2-coloring the nodes of a list
Definition: A k-coloring of a graph G is a mapping: c : V 0,1,…,k - 1 such thatc(i) c(j) if i, j E.
• It is very easy to design an O(n) time sequential algorithm for 2-coloring the nodes of a linked list.
![Page 16: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/16.jpg)
Advanced Topics in Algorithms and Data Structures
16
2-coloring the nodes of a list
• We will assume the following result:
Theorem: A linked list with n nodes can be 2-colored in O(log n) time and O(n) work.
![Page 17: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/17.jpg)
Advanced Topics in Algorithms and Data Structures
17
Independent sets• When we 2-color the nodes of a list,
alternate nodes get the same color.• Hence, we can remove the nodes of
the same color to reduce the size of the original list from n to n/2.
![Page 18: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/18.jpg)
Advanced Topics in Algorithms and Data Structures
18
Independent sets
• However, we need a list of size to run our pointer jumping algorithm for list ranking.
• If we repeat the process loglog n time, we will reduce the size of the list toi.e., to .
log log2 n
n
log
n
n
log
n
n
![Page 19: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/19.jpg)
Advanced Topics in Algorithms and Data Structures
19
Preserving the information
• When we reduce the size of the list to , we have lost a lot of information because the removed nodes are no longer present in the list.
• Hence, we have to put back the removed nodes in their original positions to correctly compute the ranks of all the nodes in the list.
log
n
n
![Page 20: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/20.jpg)
Advanced Topics in Algorithms and Data Structures
20
Preserving the information
• Note that we have removed the nodes in O(log log n) iterations.
• So, we have to replace the nodes also in O(log log n) iterations.
![Page 21: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/21.jpg)
Advanced Topics in Algorithms and Data Structures
21
Preserving the information
• The magenta nodes are removed through 2-coloring. The number of a node is shown in black.
• The initial rank of each node is shown below the node in the figure.
![Page 22: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/22.jpg)
Advanced Topics in Algorithms and Data Structures
22
Preserving the information
• The modified rank of an existing yellow node is shown in the second figure.
• The modified rank is with respect to the next existing node in the list.
![Page 23: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/23.jpg)
Advanced Topics in Algorithms and Data Structures
23
Preserving the information
For our list:• P is the array which holds the
predecessor indices.• S is the array which holds the successor
indices.• i is the number of the removed node.• U is the array where we store
information for the removed nodes. This information is used later to restore the removed nodes.
![Page 24: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/24.jpg)
Advanced Topics in Algorithms and Data Structures
24
Preserving the information
![Page 25: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/25.jpg)
Advanced Topics in Algorithms and Data Structures
25
Preserving the information
The code executed for removing the nodes in the independent set I :for all i I pardo
Set U(i) := (i, S(i), P(i))Set R(P(i)) := R(P(i)) + R(i)Set S(P(i)) := S(i)Set P(S(i)) := P(i)
![Page 26: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/26.jpg)
Advanced Topics in Algorithms and Data Structures
26
Preserving the information
• The predecessor and successor pointers are updated
• The ranks of nodes which are immediately before a removed node are updated.
![Page 27: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/27.jpg)
Advanced Topics in Algorithms and Data Structures
27
Preserving the information• The array P and S can be compacted in
O(n) work and O(log n) time after each phase of removal of nodes. This is done through a parallel prefix computation.
• Recall that we have to do the removal of nodes for loglog n phases to reduce the number of nodes to .
• We can keep a separate U array for each phase.
log
n
n
![Page 28: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/28.jpg)
Advanced Topics in Algorithms and Data Structures
28
Putting back a node
• A removed node can be reinserted in O(1) time
![Page 29: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/29.jpg)
Advanced Topics in Algorithms and Data Structures
29
Complexity
• 2-coloring in each stage can be done in O(log n) time and O(n) work.
• The compaction of the P and S arrays is done through a parallel prefix computation in O(log n) time and O(n) work.
• There are in all O(log log n) stages in which we have to remove nodes. Each stage takes O(log n) time due to the 2-coloring and parallel prefix computations.
![Page 30: Advanced Topics in Algorithms and Data Structures 1 Two parallel list ranking algorithms An O (log n ) time and O ( n log n ) work list ranking algorithm.](https://reader030.fdocuments.us/reader030/viewer/2022032704/56649d795503460f94a5cdd9/html5/thumbnails/30.jpg)
Advanced Topics in Algorithms and Data Structures
30
Complexity
• At the end, we do one list ranking for a list of size O(n/log n). This takes O(n) work and O(log n) time.
• So, the overall complexity is O(n) work and O(log n loglog n) time.