Parallel Graph Partioning Using Simulated Annealing Parallel and Distributed Computing I Sadik Gokhan Caglar

Graph Partitioning Problem Given a Graph G = (N,E) and a integer p Find subsets N 1,N 2,…,N p such that  p i=1 N i = N and N i  N j = 0 for i  j 2.W(i)  W / p, i = 1,2,…,p, where W(i) and W are the sums of node weights in N i and N respectively 3.The cut size is minimized

A Partitioned Graph A partitioned graph with edge-cut of seven

Solutions To The Problem Geometric Algorithms: Use the geometric coordinates –Recursive coordinate (or orthogonal) bisection –Recursive circle bisection Structural Algorithms: –Graph-Walking Algorithms –Spectral Algorithms Refinement Algorithms: –Kernighan-Lin Algorithm –Simulated Annealing Algorithm

Solutions To The Problem Multilevel technique: Coarsen Partition Refinement

Simulated Annealing

Implementation of SA Cost: The number of edges that has vertices in different sets Acceptation: The new cost is less than the old Rejection: The new cost is more than the old, a probabilistic calculation can change a rejection into an acceptation (e  cost/Temp ) Equilibrium: Number of rejections < (10 * vertexsize of the graph * number of sets)

Implementation of SA Frozen state: The temperature starts from 1, the cooling constant is 0.95, it is considered frozen at temperature 0.2 currentcost = cost(graph); printf ("The cost of the graph1 is %f \n", currentcost); while (temp > 0.2) { while (reject < (10 * graph.vertexsize * graph.setsize)) { makenewgraph (graph, &newgraph); tempcost = cost(newgraph); if (tempcost < currentcost) { currentcost = tempcost; graphfree(&graph); graph = newgraph; }

Implementation of SA else { reject++; if (tempcost == currentcost) prob = e(1, temp); else prob = e((tempcost - currentcost), temp); prob2 = drand48(); if (prob > prob2) { currentcost = tempcost; graphfree(&graph); graph = newgraph; } else graphfree(&newgraph); }//1st else }//reject temp = temp * coolconst; reject = 0; printf("cooled!!! temp = %f \n", temp); printf ("currentcost %f\n", currentcost); } printf ("The cost of the graph2 is %f \n", currentcost);

Input File Format

Data Structures typedef struct Edge { int v1; int v2; } Edge; typedef struct Set { int size; int* vertex; } Set; typedef struct Graph { int vertexsize; int edgesize; int setsize; struct Edge* edgelist; struct Set* setlist; } Graph;

Parallelization Approach 1 Problem independent tried to implement a general parallel simulated annealing Every process will generate a new graph and calculate the new cost The results will be sent to the root process The root process will choose the best result and broadcast it.

Parallelization Approach 1 The array that root process gathers: 0 – Acceptation ( 0 no, 1 yes, 2 probability) 1 – Cost 2 – The set number of the first vertex 3 – The set number of the second vertex 4 – The first vertex 5 – The second vertex

Parallelization Approach 1 The array that root process broadcasts: 0 - Temperature update 1 – Change done 2 – The set number of the first vertex 3 – The set number of the second vertex 4 – The first vertex 5 – The second vertex 6 – The cost of the new graph

Parallelization Approach 1 The equilibrium function has changed. From Number of rejections < (10 * vertexsize of the graph * number of sets) to Number of rejections < (10 * vertexsize of the graph * number of sets / number of processes) The rest of the program is the same the data is not distributed

Parallelization Approach 2 Problem dependent, works for only graph partition problem. Most of the work in graph partitioning problem is to calculate the cost of the graph. This is dependent on the number of edges that the graph has, the edges array can be scattered to the processes The processes only needs the edges it has to calculate the partial sum. It is perfectly parallelizable.

Parallelization Approach 2 After each process calculates its partial sum and MPI_Reduce with add operation is done to calculate the total sum. All the simulated annealing operation is done on the root process the others only calculate their partial sums.

ParSA1 16 Nodes

ParSA1 100 Nodes

ParSA1 300 Nodes

ParSA1 500 Nodes

ParSA Nodes

ParSA2 16 Nodes

ParSA2 100 Nodes

ParSA2 300 Nodes

ParSA2 500 Nodes

ParSA Nodes

ParSA Nodes Edges

ParSA Nodes Edges