Download CSS314 Parallel Computing

Lecture 12
CSS314 Parallel Computing
Book:
“An Introduction to Parallel Programming”
by Peter Pacheco
http://instructor.sdu.edu.kz/~andrey
PhD. Bogdanchikov Andrey, Suleyman Demirel University
Content (Chapter 6)
Tree Search
Recursive depth-first search
Nonrecursive depth-first search
Data structures for the serial
implementations
Performance of the serial implementations
Tree Search
 Many problems can be solved using a tree search.
As a simple example, consider the traveling
salesperson problem, or TSP. In TSP, a salesperson
is given a list of cities she needs to visit and a cost
for traveling between each pair of cities.
 Her problem is to visit each city once, returning to
her hometown, and she must do this with the least
possible cost.
 A route that starts in her hometown, visits each city
once and returns to her hometown is called a tour;
thus, the TSP is to find a minimum-cost tour.
NP-complete problem
 Unfortunately, TSP is what’s known as an NPcomplete problem.
 Exhaustive search means examining all possible
solutions to the problem and choosing the best.
 The number of possible solutions to TSP grows
exponentially as the number of cities is increased.
 For example, if we add one additional city to an n-city
problem, we’ll increase the number of possible
solutions by a factor of n-1. Thus, although there are
only six possible solutions to a four-city problem, there
are 4*6 = 24 to a five-city problem.
 In fact, a 100-city problem has far more possible
solutions than the number of atoms in the universe!
Possible algorithm
 So how can we solve TSP? There are a number of
clever solutions.
 However, let’s take a look at an especially simple
one. It’s a very simple form of tree search.
 The idea is that in searching for solutions, we build
a tree. The leaves of the tree correspond to tours,
and the other tree nodes correspond to “partial”
tours—routes that have visited some, but not all, of
the cities.
 Each node of the tree has an associated cost, that
is, the cost of the partial tour. We can use this to
eliminate some nodes of the tree.
A four-city TSP
Search tree for four-city TSP
DFS
 Now, to find a least-cost tour, we should search the
tree.
 There are many ways to do this, but one of the most
commonly used is called depth-first search.
 In depth-first search, we probe as deeply as we can
into the tree.
 After we’ve either reached a leaf or found a tree node
that can’t possibly lead to a least-cost tour, we back
up to the deepest “ancestor” tree node with unvisited
children, and probe one of its children as deeply as
possible.
How it works
 In our example, we’ll start at the root, and branch left
until we reach the leaf labeled
 Then we back up to the tree node labeled 0 → 1, then
 Continuing, we’ll back up to the root and branch down
to the node labeled 0 → 2. When we visit its child,
labeled
we’ll stop because we
already have tour less than 21.
 Continuing in this fashion, we eventually find the leastcost tour
Recursive depth-first search
 Using depth-first search we can systematically visit
each node of the tree that could possibly lead to a
least-cost solution. The simplest formulation of depthfirst search uses recursion.
 The algorithm makes use of several global variables:
n: the total number of cities in the problem
digraph: a data structure representing the input digraph
hometown: a data structure representing vertex or city 0, the
salesperson’s hometown
best tour: a data structure representing the best tour so far
Pseudocode for a recursive solution
to TSP
Nonrecursive depth-first search
 Since function calls are expensive, recursion can be
slow. It also has the disadvantage that at any given
instant of time only the current tree node is accessible.
 This could be a problem when we try to parallelize tree
search by dividing tree nodes among the threads or
processes.
 It is possible to write a nonrecursive depth-first search.
The basic idea is modeled on recursive
implementation.
 Recall that recursive function calls can be
implemented by pushing the current state of the
recursive function onto the run-time stack.
Pseudocode for an implementation of DFS
without recursion
Alternative
 An alternative to this iterative version uses partial
tours as stack records. This gives code that is closer
to the recursive function. However, it also results in
a slower version, since it’s necessary for the
function that pushes onto the stack to create a copy
of the tour before actually pushing it on to the stack.
 To emphasize this point, we’ve called the function
Push copy. (What happens if we simply push a
pointer to the current tour onto the stack?)
 The extra memory required will probably not be a
problem. However, allocating storage for a new tour
and copying the existing tour is time-consuming.
Pseudocode for a second solution to
TSP without recursion
On the other hand
 On the other hand, this version has the virtue that the
stack is more or less independent of the other data
structures.
 Since entire tours are stored, multiple threads or
processes can “help themselves” to tours, and, if this
is done reasonably carefully it won’t destroy the
correctness of the program.
 With the original iterative version, a stack record is just
a city and it doesn’t provide enough information by
itself to show where we are in the tree.
Data structures for the serial
implementations
 Our principal data structures are the tour, the
digraph, and, in the iterative implementations, the
stack.
 The tour and the stack are essentially list structures.
In problems that we’re likely to be able to tackle, the
number of cities is going to be small— certainly less
than 100—so there’s no great advantage to using a
linked list to represent the tours and we’ve used an
array that can store n-1 cities.
 We repeatedly need both the number of cities in the
partial tour and the cost of the partial tour.
Structs
 Tours can be stored as array of cities
 Stack can be implements also by array, and
implemented functions to push and pop.
 Digraph better to represent as adjacency matrix,
so it is two-dimensional array nxn.
 Greater explanation Self-Study Chapter 6.2.3
Performance of the serial
implementations
 The run-times of the three serial implementations
are shown in Table. The input digraph contained
15 vertices (including the hometown), and all
three algorithms visited approximately 95,000,000
tree nodes.
Homework
1. Exercise 6.17
2. Find and explain what is difference
between DFS and BFS
3. Provide your own suggestion how to
parallelize TSP problem.
4. Write short implementation of functions
pop and push for stack data structure.
THE END
THANK YOU