1 / 17

# CS 584 - PowerPoint PPT Presentation

CS 584. Project Write up Due on day of final HTML format Email a tar zipped file to me I will post Poster session for final 4 page poster. Graphs. A graph G is a pair (V, E) V is a set of vertices E is a set of edges Graphs can be directed or undirected Terms path adjacent incident.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' CS 584' - lilly

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

• Project Write up

• Due on day of final

• HTML format

• Email a tar zipped file to me

• I will post

• Poster session for final

• 4 page poster

• A graph G is a pair (V, E)

• V is a set of vertices

• E is a set of edges

• Graphs can be directed or undirected

• Terms

• path

• incident

• We will consider the following algorithms

• Minimum Spanning Tree

• Single Source Shortest Paths

• All pairs shortest paths

• Transitive closure

• A spanning tree is a subgraph of G that is a tree containing all the nodes of G.

• A minimal spanning tree is a spanning tree of minimal weight

• If the graph G is not connected, it does not have a spanning tree. It has a spanning forest.

Procedure PRIM_MST(V, E, w, r)

VT = {r};

d[r] = 0;

for all v in (V - VT) do

if E[r,v] exists

set d[v] = w[r, v]

else

set d[v] = infinite

end for

while VT != V

find a vertex u such that d[u] = min(d[v] | v in (V - VT))

VT = VT union {u}

for all v in (V - VT) do

d[v] = min(d[v], w[u, v])

end while

end Procedure

• Since the value of d[v] for a vertex v may change every time a vertex is added, it is impossible to select more than one vertex at a time.

• So the iterations of the while loop cannot be done in parallel.

• What about parallelizing a single iteration?

• Consider the calculation of the next node to add to the set.

• Calculates the min distance from any of the nodes already in the tree.

• Have all processors calculate a min of their nodes and then do a global min.

| n/p |

d[1..n]

n

• Computation ---> O(n2/p)

• Communication per iteration

• Global min ---> log2p

• Bcast min ---> log2p

• Find the shortest paths from a vertex to all other vertices.

• A shortest path is a minimum cost path

• Similar to Prim’s algorithm

• Note: Instead of storing distances, we store the min cost to a vertex from the vertices in the set.

Procedure DIJKSTRA_SSP(V, E, w, s)

VT = {s};

for all v in (V - VT) do

if E[s,v] exists

set L[v] = w[r, v]

else

set L[v] = infinite

end for

while VT != V

find a vertex u such that L[u] = min(L[v] | v in (V - VT))

VT = VT union {u}

for all v in (V - VT) do

L[v] = min(L[v], L[u] + w[u, v])

end while

end Procedure

• Parallelized exactly the same way as Prim’s algorithm

• Exact same cost as Prim’s algorithm

• Find the shortest paths between all pairs of vertices.

• Three algorithms presented.

• Matrix Multiplication

• Dijkstra’s

• Floyd’s

• We will consider Dijkstra’s

• Two ways to parallelize

• source partitioned

• Partition the nodes

• Each processor computes Dijkstra’s sequential algorithm

• source parallel

• Run the parallel single source shortest path algorithm for all nodes

• Can subdivide the processors into sets and also divide the nodes into sets.

• Source Partitioned

• No communication

• Each vertex requires O(n2)

• The algorithm can use at most n processors

• Source Parallel

• Communication is O(n log2 n)

• Each vertex requires O(n2/p)

• Can efficiently use more processors

• Determine if any two vertices are connected

• Computed by first computing all pairs shortest path

• if there is a shortest path, there is a path

• Parallelize the all pairs shortest path