MIPRO 2012, May 21-25,2012, Opatija, Croatia

Dijkstra's shortest path algorithm serial and

parallel execution performance analysis
Nadira Jasika, Naida Alispahic, Arslanagic Elma, Kurtovic Ilvana, Lagumdzija Elma, Novica Nosovic

Department for Computing and Informatics, Faculty of Electrical Engineering, University of Sarajevo

anaidana@gmail.com, elmaars@gmail.com, nadira.j90@gmail.com, ilvana89@hotmail.com,

elma.lagumdzija@gmail.com, novica.nosovic@etf.unsa.ba

Abstract - This article introduces the problem of In this article, firstly you can find a definition of the
parallelization of Dijkstra's algorithm, a well known Dijkstra's algorithm for computing single-source shortest
algorithm for computing single-source shortest path in a path in a graph, and then there is a parallel algorithm
graph. Dijkstra's algorithm can be applied to graphs with a
given to solve the shortest path problem of the single
various number of vertices and edges. Dijkstra's shortest path
algorithm is implemented and presented, and the
source graphs, where one implementation of single
performances of its parallel and serial execution are source shortest path algorithm executed on dual-core and
compared. The algorithm implementation was parallelized i5 processor with OpenMP, and one with OpenCL.
using OpenMP (Open Multi-Processing) and OpenCL (Open Finally we can find through experiments that parallel
Computing Language) standards. Its performances were algorithm used in this article is has better performance
measured on 4 different configurations, based on dual core than the serial one.
and i5 processors. The experimental results prove that the
parallel execution of the algorithm has good performances in
II. DIJKSTRA'S ALGORITHM
terms of speed-up ratio, when compared to its serial
execution. Finally, the results show that, because of Dijkstra's
algorithm in itself is sequential, and difficult to parallelize, Dijkstra's algorithm finds the length of an shortest path
average speed-up ratio achieved by parallelization is only between two vertices in a graph.
10%. This proves to be a huge disadvantage of this algorithm, The algorithm works as follows:
because its use is widespread, and enhancing its performance 1. Choose the source vertex
would have great effects in its many uses. 2. Define a set S of vertices, and initialise it to
emptyset. As the algorithm progresses, the set S
Keywords - Dijkstra algorithm; single source shortest path; will store those vertices to which a shortest path
parallel algorithm; OpenMP, OpenCL
has been found.
3. Label the source vertex with 0, and insert it into
S.
I. INTRODUCTION
4. Consider each vertex not in S connected by an
edge from the newly inserted vertex. Label the
With the development of computer and information
vertex not in S with the label of the newly
technology, the research about graph theory get a wide
inserted vertex + the length of the edge.
range of attention, and a variety of graph structures and
But if the vertex not in S was already labeled, its new
algorithms have been proposed [2].
label will be min(label of newly inserted vertex + length
The shortest path algorithm is always a research hotspot
of edge, old label)
in graph theory and it is the most basic algorithm. For
5. Pick a vertex not in S with the smallest label,
example, shortest path algorithm is used to implement
and add it to S.
traffic engineering in IP networks and to improve
6. Repeat from step 4, until the destination vertex
Intelligent and Transportation Systems. But for that kind
is in S or there are no labeled vertices not in S.
of algorithm it is very difficult to improve its
If the destination is labeled, its label is the distance from
performance.
source to destination. If it is not labeled, there is no path
Currently the algorithms for the serial shortest path
from the source to the destination.[6]
optimization have reached the time limitation. Therefore
the parallel computation is an efficient way to improve
the performance. By putting some constraints on the data
and taking the advantage of the hardware, the
performance of the algorithms can be significantly
improved.

1811
 paths between nodes and vid.size() is size of vector with
all nodes in graph

Figure 1. Example of Dijkstra's algorithm in steps

III. EXPLANATION OF SERIAL DIJKSTRA

ALGORITHM
Figure 3. Example of iterations during execution of
In this algorithm, two sets are maintained: D for all parallelized Dijkstra's algorithm on four processors using
discovered nodes and U for undiscovered nodes. At first, OpenMP
D contains only the starting node s, use d(v) to denote the
current estimated best distance from s to v, which is his V. EXPLANATION OF IMPLEMENTATION
neighbor. Initially all v except s has d(v)=infinity. Set D OF DIJSKTRA'S ALGORITHM
grows by adding the node with minimal estimated
distance from U into D, and update the current distance The first step in running Dijkstra’s algorithm on GPU
of the neighbor nodes of the newly added node, and (Graphics Processing Unit) is to create a graph data
repeat this procedure until all nodes are in D. structure that is efficiently accessible by the GPU. The
graph is composed of vertices and edges that connect
IV. EXPLANATION OF PARALLEL vertices together. Each edge has a weight value
DIJKSTRA ALGORITHM associated with it that typically measures some cost in
traveling across that edge. In this case, the edge weights
There are two parallelization strategies - execute each of were determined by the curvature function as curvature
the n shortest path problems on a different processor values were minimalized in traveling across the mesh.
(source partitioned), or use a parallel formulation of the Each execution of Dijkstra will output an array the size of
shortest path problem to increase concurrency (source the number of vertices in the graph with the total cost of
parallel). Using n processors, each processor Pi finds the the shortest distance from the source vertex to each
shortest paths from vertex Vi to all other vertices by vertex in the graph.
executing Dijkstra's sequential single-source shortest The first kernel (functions that execute on OpenCL
paths algorithm. devices) that is queued to OpenCL for each source vertex
It requires no interprocess communication (provided that is simply responsible for initialization of buffers. This
the adjacency matrix is replicated at all processes). In this was done using a kernel rather than on the CPU to reduce
article it is used formulation of Dijkstra’s algorithm using the amount of data transferred between the CPU and
OpenMP. An OpenMP application begins with a single GPU.
thread, the master thread. As the program executes, the The algorithm itself is broken into two phases. This is
application may encounter parallel regions in which the necessary because synchronization isn’t possible outside
master thread creates thread teams (which include the of local work-groups in OpenCL, and this would be
master thread). At the end of a parallel region, the thread required to execute the kernel algorithm in a single phase.
teams are stopped and the master thread continues The first phase of the algorithm visits all vertices that
execution. Since OpenMP is primarily a pragma or have been marked and determines the cost to each
directive based standard,it can be easily combine serial & neighbor. If the current cost plus the new edge weight is
parallel code in a single source. By simply compiling less than what is currently stored in function, then that
with or without the /OpenMP compiler, it can turn new cost is stored for the vertex. The second phase of the
OpenMP on or off. Code compiled without the /OpenMP algorithm checks to see if a smaller cost has been found
simply ignores the OpenMP pragmas which allows for each vertex and, if so, marks it as needing visitation
original serial execution. and updates the costArray.
In order to leverage multiple compute devices, the
Figure 2. Part of code where OpenMP pragmas was used, workload needs to be partitioned. The approach taken in
wg represents weighted graph which contains weights of this implementation is to partition the number of searches

1812
across the available compute hardware. The application
detects the number of GPU and CPU devices and splits
the workload across the devices.
Each of the kernels is written to process one vertex at a
time and it was implemented by workload portioning.
In the case CPU device is selected from the initial menu
when execution starts, the OpenCL implementation will
multithread the implementation across the available
cores.

VI. EXPERIMENTAL RESULTS AND

ANALYSIS 4.b

The experimental environments for analyzing the

performance of algorithms in this article were as follows:

Configuration 1:
Processor: Intel(R) Core(TM) i5 CPUM460 @ 2.53GHz
2.53GHz
GPU: AMD Radeon HD 6500M/5600/5700 series

Configuration 2: 4.c
Processor: Intel(R) Pentium(R) Dual CPU T2390@
1.86GHz 1.87GHz
GPU: Intel® GMA X3100

Configuration 3:
Processor: Intel Celeron Dual Core CPU T1500 @
1.86GHz 1.86GHz
GPU: Intel GMA X3100

Configuration 4:
Processor: Intel(R) Core(TM)2 Duo CPU T5760 @ 4.d
1.80GHz
GPU: Mobile Intel(R) 965 Express Chipset Family

Execution speed was compared for those algorithms: 4.e

sequential one, the parallel one, and the parallel one made
for OpenCL. Figure 4. The comparison of execution time in algorithms
They are all implemented and tasted on processors (dual (parallel and sequential) running on a different machines:
core and i5). As it can be seen from the graphs on Figure 4.a: Configuration 1, 4.b: Configuration 2, 4.c:
4., parallel version seems to perform better than the Configuration 3, 4.d: Confituration 4, 4.e: Legend
sequential one when the number of nodes becomes larger
than 3000. As can be seen from Figure 4, for weighted graphs,
parallel algorithm has better performance than the
sequential one, but these performance also depends on
which machines was this tested, where the best
performance were on i5 processor.

4.a

1813
 5.a VII. CONCLUSION

Parallel programming is a very intricate, yet increasingly

important task as we have entered the multicore era and
more cores are made available to theprogrammer. Al-
though separate applications or independent tasks within
a single application can be easily mapped on multicore pl
atforms, the sameis not true for applications that do not e
xpose parallelism in a straightforward way. Dijkstra’s al-
gorithm is a challenging example of such an algo-
rithmthat is difficult to accelerate when executed in a mul
tithreaded fashion. It is very important to have in mind th
e two major issues inherent to Dijkstra’salgorithm: limit-
5.b
ed explicit parallelism and excessive synchronization. Dij
kstra’s algorithm does not readily lend itself to paral-
lelization mainly because itrelies on priority queue. Be-
cause evaluating the vertex at the head of the priority que
ue may change the order of elements remaining within th
e priorityqueue, it is not necessarily correct or efficient to
evaluate more than the head of the priority queue on each
iteration.

There are several possible reasons why the more

advanced parallel execution of Dijkstra's algorithm wasn't
as fast as expected. One of the reasons could be that the
5.c code used may be inefficient. Another possibility is
that, for a small amount of nodes, more time could be
spent on parallelization and synchronization then it is
spent on execution of code as sequential.

There are several areas in which this article could be ex-

tended with further work. Overcoming issues such as uti-
lizing shared memory, avoiding branches, choosing ap-
propriate data structures and designing algorithms cor-
rectly are the key to success with parallelization of Dijk-
stra’s algorithm.

Some problems appear to be inherently sequential, and

5.d are difficult, if not impossible, to implement in parallel.
Unfortunately, one of these problems is Dijkstra's algo-
rithm. This is actually the main problem for the imple-
mentation of its parallelization.
5.e
VIII. REFERENCES
Figure 5. The comparison of execution time in algorithms [1] Han Cao,Fei Wang, Xin Fang, Hong-lei Tu and Jun
(parallel one made for OpenCL and sequential one) on Shi, „OpenMP Parallel Optimal Path Algorithm and Its
Configuration 1; 5.a: 5 edges per node, 5.b: 10 edges per Performance Analysis“, World Congress on Software
node, 5.c: 20 edges per node, 5.d: 50 edges per node, 5.e: Engineering, 2006.
Legend [2] Qiang Peng, Yulian Yu and Wenhong Wei, „The
Shortest Path Parallel Algorithm on Single Source
As can be seen from the collected performance data, the Weighted Multi-level Graph“, 2009 Second International
number of edges per node affect the performance. On Workshop on Computer Science and Engineering, 2009.
figure 5. It can be seen that the performance on GPU are [3] Nikos Anastopoulos, Konstantinos Nikas, Georgios
better than the one on CPU, but when the number of Goumas and Nectarios Koziris, „Employing
edges per node is bigger than 10, as shown on figure 7. Transactional Memory and Helper Threads to Speedup
and 8. the performances are almost the same. That means Dijkstra’s Algorithm“ ,2009.
that for the different values of vertices the speed-up ratio [4] Fang Zhou Lin, Nan Zhao, „Parallel Implementation
of Dijkstra's Algorithm“ , pp COP5570, 1999.
of our parallel algorithm keep basically unchanged.

1814
[5] Kevin Kelley, Tao B. Schardl, „Parallel Single-Source
Shortest Paths“, 2007.
[6]
http://www.cs.bham.ac.uk/~mdr/teaching/modules0
4/java2/DijkstraAlgo.html, last modified on 29th
October 2004.

1815