- 117 Views
- Uploaded on
- Presentation posted in: General

CS 584

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

- 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
- adjacent
- 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

- 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