List Ranking on GPUs
Sathish Vadhiyar
List Ranking on GPUs
• Linked list prefix computations –
computations of prefix sum on the elements
contained in a linked list
• Irregular memory accesses – successor of each
node of a linked list can be contained
anywhere
• List ranking – special case of list prefix
computations in which all the values are
identity, i.e., 1.
List ranking
• L is a singly linked list
• Each node contains two fields – a data field,
and a pointer to the successor
• Prefix sums – updating data field with
summation of values of its predecessors and
itself
• L represented by an array X with fields
X[i].prefix and X[i].succ
Sequential Algorithm
• Simple and effective
• Two passes
– Pass 1: To identify the head node
– Pass 2: Traverses starting from the head, follow
the successor nodes accumulating the prefix sums
in the traversal order
• Works well in practice
Parallel Algorithm: Prefix
computations on arrays
• Array X partitioned into subarrays
• Local prefix sums of each subarray calculated in
parallel
• Prefix sums of last elements of each subarray
written to a separate array Y
• Prefix sums of elements in Y are calculated.
• Each prefix sum of Y is added to corresponding
block of X
• Divide and conquer strategy
Example
123456789
123 456
1,3,6
789
4,9,15
6,15,24
6,21,45
1,3,6,10,15,21,…
7,15,24
Prefix computation on list
• The previous strategy cannot be applied here
• Division of array X that represents list will lead
to subarrays each of which can have many
submits fragments
• Head nodes will have to be calculated for each
of them
Parallel List Ranking (Wyllie’s
algorithm)
• Involved repeated pointer jumping
• Successor pointer of each element is
repeatedly updated so that it jumps over its
successor until it reaches the end of the list
• As each processor traverses and updates the
successor, the ranks are updated
• A process or thread is assigned to each
element of the list
Parallel List Ranking (Wyllie’s
algorithm)
• Will lead to high synchronizations among
CUDA threads, many kernel invocations
Parallel List Ranking (Helman and JaJa)
• Randomly select s nodes or splitters. The head node is
also a splitter
• Form s sublists. In each sublist, start from a splitter as
the head node, and traverse till another splitter is
reached.
• Form prefix sums in each sublist
• Form another list, L’, consisting of only these splitters in
the order they are traversed. The values in each entry
of this list will be the prefix sum calculated in the
respective sublists
• Calculate prefix sums for this list
• Add these sums to the values of the sublists
Parallel List Ranking on GPUs: Steps
• Step 1: Compute the location of the head of
the list
• Each of the indices between 0 and n-1, except
head node, occur exactly only once in the
successors.
• Hence head node = n(n-1)/2 – SUM_SUCC
• SUM_SUCC = sum of the successor values
• Can be done on GPUs using parallel reduction
Parallel List Ranking on GPUs: Steps
• Step 2: Select s random nodes to split list into
s random sublists
• For every subarray of X of size X/s, select
random location as a splitter.
• Highly data parallel, can be done independent
of each other
Parallel List Ranking on GPUs: Steps
• Step 3: Using standard sequential algorithm,
compute prefix sums of each sublist separately
• The most computationally demanding step
• s sublists allocated equally among CUDA blocks,
and then allocated equally among threads in a
block
• Each thread computes prefix sums of each of its
sublists, and copy prefix value of last element of
sublist i to Sublist[i]
Parallel List Ranking on GPUs: Steps
• Step 4: Compute prefix sum of splitters, where
the successor of a splitter is the next splitter
encountered when traversing the list
• This list is small
• Hence can be done on CPU
Parallel List Ranking on GPUs: Steps
• Step 5: Update values of prefix sums
computed in step 3 using splitter prefix sums
of step 4
• This can be done using coalesced memory
access
Choosing s
• Large values of s increase the chance of
threads dealing with equal number of nodes
• However, too large values result in overhead
of sublist creation and aggregation
References
• Fast and Scalable List Ranking on the GPU.
ICS 2009.
• Optimization of Linked List Prefix
Computations on Multithreaded GPUs Using
CUDA. IPDPS 2010.