├── GraphGeneratorExternal.cpp
├── PBFSWithGraphGeneration.c
├── ParallelBFS_usingMPI_Parallel_IO.c
├── README.md
└── SequentialBFS.c


/GraphGeneratorExternal.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <random>
 3 | #include <fstream>
 4 | #include <boost/graph/adjacency_list.hpp>
 5 | #include <boost/graph/erdos_renyi_generator.hpp>
 6 | 
 7 | 
 8 | int main(int argc, char* argv[]) {
 9 |     typedef boost::adjacency_list<boost::vecS,boost::vecS,boost::undirectedS> Graph;
10 |     typedef boost::erdos_renyi_iterator<std::mt19937, Graph> erg;
11 | 
12 |     if (argc < 3) return -1;
13 | 
14 |     long int n = std::atoi(argv[1]);
15 |     double eps = std::atof(argv[2]);
16 | 
17 |     std::random_device rd;
18 |     int seed = -1;
19 | 
20 |     long int s = 0 ;
21 |     if (argc > 3) seed = std::atoi(argv[3]);
22 |     if (argc == 5) s = std::atol(argv[4]);
23 | 
24 |     if (seed == -1) seed = rd();
25 |     double p = (eps / n);
26 |     std::ofstream myfile;
27 |     myfile.open(argv[5],std::ios::binary);
28 | 
29 |     std::mt19937 rng(seed);
30 |     Graph G(erg(rng, n, p), erg(), n);
31 | 
32 |     boost::graph_traits<Graph>::vertex_iterator e, end;
33 |     std::tie(e, end) = boost::vertices(G);
34 | 
35 |     boost::graph_traits<Graph>::in_edge_iterator inEdge, inEdgeEnd;
36 | 
37 |     boost::graph_traits<Graph>::edge_iterator temp, temp_end;
38 |     std::tie(temp, temp_end) = boost::edges(G);
39 |     int *buf= new int[n];
40 |     int k= 0, pos=0;
41 |     std::vector<char> buffer(32 * 1024 * 1024*50);
42 |     char one[1], zero[1];
43 |     one[0] = '\x1';
44 |     zero[0] = '\x0';
45 |     long long int edgeCount =0;
46 |     for (; e != end; ++e) {
47 | 	std::fill_n(buf,n,0);
48 | 	std::tie(inEdge, inEdgeEnd) = boost::in_edges(*e, G);                     
49 | 	for(;inEdge != inEdgeEnd; ++inEdge) {
50 |     	   int index_of_source = boost::source(*inEdge, G);
51 | 	   buf[index_of_source] = 1;
52 | 	}
53 |  	for(k=0;k<n;k++) {                      
54 |             if(buf[k]==0){
55 |                 memcpy ( &buffer[pos], zero, 1 );
56 |             }
57 |             else{
58 |                 memcpy ( &buffer[pos], one, 1 );
59 |                 edgeCount++;
60 |             }
61 |             pos += 1;                             
62 |             if (pos >= buffer.size()-8) {
63 |        	        myfile.write(buffer.data(), pos * sizeof(char));
64 |                 pos = 0;
65 |             } 
66 |         }
67 |     }
68 |     myfile.write(reinterpret_cast<char*>(buffer.data()), pos * sizeof(char));
69 |     myfile.close();
70 |     std::cout<<edgeCount<<std::endl;
71 |     return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/PBFSWithGraphGeneration.c:
--------------------------------------------------------------------------------
  1 | #include "mpi.h"
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include "math.h"
  5 | #include <stdbool.h>
  6 | bool isClear(int[], long int, long int,long int );
  7 | long long int getIndex(long long int i,long long int j ,long long int rowSize);
  8 | 
  9 | int main (int argc, char *argv[])
 10 | {
 11 |     unsigned long long int rowNo, columnNo; // rowNo and columnNo of processor in the 2-D partition.
 12 |     unsigned long long int noofPRows;       // Number of processor rows in the 2-D partition.
 13 |     unsigned long long int noofVertices;    // Given input vertices count of the graph.
 14 |     unsigned long long int noofVerticesPerProcessor; // Number of vertices a processor own after 2-D patitioning.(size of distributed frontier vector)
 15 |     unsigned long long int NVertices; // Normalized vertices count for distributing input matrix uniformly across processors
 16 |     int rank, numtasks;              // rank of the processor in MPI_COMM_WORLD.
 17 |     
 18 |     MPI_Init(&argc, &argv);          // Start of parallel execution
 19 |     double t1, t2;                   // used to track execution time 
 20 |     t1 = MPI_Wtime();                // start of data setup phase
 21 |     MPI_Status status;
 22 |     MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
 23 |     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 24 |     noofPRows = (int) sqrt(numtasks);        // calcuting no of processor rows in 2-D partition, this is also equal to processor columns.
 25 |     noofVertices = atoll(argv[1]);           // Size of the input graph (count of vertices)
 26 |     NVertices = ceil(noofVertices*1.0/numtasks)* numtasks; // normalizing the input vertices count for equal adjacency matrix distribution across processors.
 27 |       
 28 |     int dens = atoi(argv[3]);   // desired density of the graph to be generated
 29 |     noofVerticesPerProcessor = (int) ceil(NVertices/(noofPRows*noofPRows));// no of vertices in sub adjacency matrix stored at each processor.
 30 |     
 31 |     /* Intializing all variables for graph traversal */
 32 |     unsigned long long int i,j,k;
 33 |     int* F;                    //Global Frontier Vector.
 34 |     F = (int *) malloc(sizeof(int)*NVertices);
 35 |     for(i=0; i<NVertices; i++){
 36 | 	F[i] = 0;
 37 |     }
 38 |     F[atoi(argv[2])] = 1;
 39 |     int* Fij;                 // Current Local frontier Vector.
 40 |     Fij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 41 |     int* Pij;
 42 |     Pij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 43 |     
 44 |     int* Tij;               // Next Local frontier Vector.
 45 |     Tij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 46 |     for( i =0; i<noofVerticesPerProcessor; i++){
 47 | 	Pij[i] = 0;
 48 | 	Fij[i] = 0;
 49 | 	Tij[i] = 0;
 50 |     }
 51 |       
 52 |     int* Ti;                // Next frontier of a row of processors
 53 |     Ti = (int *) malloc(sizeof(int)*noofVerticesPerProcessor*noofPRows);
 54 |     for(i=0; i < noofVerticesPerProcessor*noofPRows ; i++){
 55 |         Ti[i] = 0;
 56 |     }
 57 |       
 58 |     unsigned long long int noofVerticesinRowofProcessor = noofVerticesPerProcessor*noofPRows;
 59 |     char* Aij;              // Adjacency matrix stored at each processor.
 60 |     Aij = (char *) malloc(sizeof(char)*noofVerticesinRowofProcessor*noofVerticesinRowofProcessor);
 61 |       
 62 |     for(i=0; i < noofVerticesinRowofProcessor*noofVerticesinRowofProcessor ; i++){
 63 |         Aij[i] = 0;
 64 |     }
 65 |       
 66 |     if(rank==1){
 67 | 	printf("noofVertices=%lld,nVertices=%lld, noofVerticesPerProcessor=%lld,Ti_size=%lld \n ",noofVertices,NVertices, noofVerticesPerProcessor,noofVerticesPerProcessor*noofPRows);
 68 |     }
 69 | 
 70 |     MPI_Comm rowComm, colComm;        // row communication world and column communication world
 71 |     rowNo = (rank)/noofPRows + 1;
 72 |     columnNo = rank%noofPRows +1;
 73 |     i = rank/noofPRows;
 74 |     j = rank%noofPRows;
 75 |       
 76 |     /* Random Graph generation with given Density as input.  */
 77 |     srand(100*rank);
 78 |     long long int noofOnes=0;
 79 |     double density=0;
 80 | 
 81 |     long long int i2,j2,k2;
 82 |     if(columnNo >= rowNo){
 83 |         for(i2=0; i2< noofVerticesinRowofProcessor*noofVerticesinRowofProcessor; i2++){
 84 |             int rand1 = rand()%100;
 85 |             if(rand1<dens){
 86 |                 Aij[i2] = 1;
 87 |                 noofOnes++;
 88 |             }
 89 |          }
 90 |       }
 91 |     density = 2*noofOnes*1.0/(noofVerticesinRowofProcessor*noofVerticesinRowofProcessor);
 92 |     if(rowNo != columnNo)
 93 |         noofOnes *= 2;
 94 |     int recv_ddata;  
 95 |     MPI_Reduce(&noofOnes, &recv_ddata,1,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD);
 96 |     if(rank==0){
 97 |         printf("sum=%d, density=%f\n",recv_ddata,recv_ddata*1.0/(noofVertices*noofVertices));
 98 |     }
 99 |     
100 |     /* Sending matrix data to processor below the diagonal, and also recieving data if a processor is below diagonal */
101 |     char temp;
102 |     long long int chunkSize = 214748364;
103 |     long int  noofChunkstoSend = ceil(((noofVerticesinRowofProcessor*noofVerticesinRowofProcessor)*1.0)/(chunkSize*1.0));
104 |     char* Aijtemp = Aij;
105 |     int r;
106 |     if(rowNo < columnNo) {
107 |         for(r=0;r<noofChunkstoSend;r++){
108 |             long long int size = chunkSize;
109 |             if(r==noofChunkstoSend-1){
110 |                 size = noofVerticesinRowofProcessor*noofVerticesinRowofProcessor - r*chunkSize;
111 |             }
112 |             printf("sending %lld bytes in round %d \n",size,r+1);
113 |             MPI_Send(Aijtemp, size, MPI_CHAR, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD);
114 |             Aijtemp += size;
115 |         }
116 |     } else if(rowNo > columnNo) {
117 |         for(r=0;r<noofChunkstoSend;r++){
118 |             long long int size = chunkSize;
119 |             if(r==noofChunkstoSend-1){
120 |                 size = noofVerticesinRowofProcessor*noofVerticesinRowofProcessor - r*chunkSize;
121 |             }
122 |         MPI_Recv(Aijtemp, size, MPI_CHAR, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD, &status);
123 |         Aijtemp +=size;
124 |     }
125 |     for(i2=0;i2<noofVerticesinRowofProcessor;i2++) {
126 |         for(j2=0;j2<noofVerticesinRowofProcessor;j2++){
127 |             if(i2<j2){
128 |                 temp = Aij[getIndex(i2,j2,noofVerticesinRowofProcessor)];
129 |                 Aij[getIndex(i2,j2,noofVerticesinRowofProcessor)] = Aij[getIndex(j2,i2,noofVerticesinRowofProcessor)];
130 |                 Aij[getIndex(j2,i2,noofVerticesinRowofProcessor)] = temp;
131 |              }
132 |          }
133 |      }
134 |        }
135 |     // Padding zero to normalize, if input vertices count makes non-uniform distribution.
136 |     if(j==noofPRows-1){
137 |         for (i=0;i<noofVerticesinRowofProcessor;i++) {
138 |             for (j=(noofVerticesinRowofProcessor -(NVertices-noofVertices));j<noofVerticesinRowofProcessor;j++){
139 |                Aij[i*noofVerticesinRowofProcessor+j] = 0;
140 |             }
141 |         }
142 |     }       
143 | 
144 |     if(i==noofPRows-1){
145 |         for (j=0;j<noofVerticesinRowofProcessor;j++) {
146 |             for (i=(noofVerticesinRowofProcessor -(NVertices-noofVertices));i<noofVerticesinRowofProcessor;i++){
147 |                 Aij[i*noofVerticesinRowofProcessor+j] = 0;
148 |             }
149 |         }
150 |      }   
151 |       /* Initializing row and column communicators to facilitate communications for processors in 2-D Distribution */
152 |      MPI_Comm_split(MPI_COMM_WORLD, columnNo, rank, &colComm); 
153 |      MPI_Comm_split(MPI_COMM_WORLD, rowNo, rank, &rowComm);
154 | 
155 |     for(i=0; i< noofVerticesPerProcessor; i++){
156 |         Fij[i] = F[(rowNo-1)*noofVerticesPerProcessor*noofPRows+(columnNo-1)*noofVerticesPerProcessor +i];
157 |         Pij[i] = Fij[i];
158 |     }
159 |    
160 |     int* rec_buffer = (int*)malloc(sizeof(int)*noofVerticesinRowofProcessor);
161 |     int* send_buffer = (int*)malloc(sizeof(int)*noofVerticesPerProcessor);      
162 | 
163 |     t2 = MPI_Wtime();  // Marks the end of data set up phase
164 |     if(rank==0)
165 |         printf( "Elapsed time for data reading and initialization %f\n", t2 - t1 ); 
166 | 
167 |     /* Main Algorithm execution starts here */
168 |     int roundNo=1;
169 |     while(isClear(F,rowNo, columnNo, noofVertices)) {
170 |         if(rank==0){
171 | 	     printf("Round No : %d \n", roundNo);
172 | 	     roundNo++;
173 |              for(i=0;i<noofVertices;i++){
174 |                  if(F[i]==1)
175 | 	             printf("%lld\n",i+1);
176 |              }
177 | 	 }
178 |          
179 |          //Updating local view from global frontier
180 |          for(i=0; i<noofVerticesPerProcessor; i++){
181 |             send_buffer[i] = Fij[i];
182 |          }
183 | 
184 | 	 if(rowNo != columnNo) {
185 | 	    if(rowNo > columnNo) {
186 |                  MPI_Send(send_buffer, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD);
187 | 	         MPI_Recv(Fij, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD, &status);
188 | 	    } else {
189 |     		MPI_Recv(Fij, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD, &status);
190 | 		MPI_Send(send_buffer, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD); 
191 | 	    }
192 |    	}
193 |         MPI_Allgather(Fij,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT,colComm);
194 | 
195 |         // computing next frontier, and following algorithm details explained in detail in the descrition and report.
196 |         int val=0;
197 |         for(i=0; i<noofVerticesinRowofProcessor; i++){
198 |             val=0;
199 |             for(j=0;j<noofVerticesinRowofProcessor; j++){
200 |                 val += Aij[i*noofVerticesinRowofProcessor + j]*rec_buffer[j];
201 | 	    }
202 |             Ti[i] = val;
203 |         }  
204 | 
205 |         MPI_Alltoall(Ti,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT, rowComm);
206 | 
207 |         for(i=0; i<noofPRows; i++){
208 |             for(j=0; j<noofVerticesPerProcessor;j++){
209 |                 if(rec_buffer[i*noofVerticesPerProcessor+j] > 0){
210 |                     Tij[j]=1;
211 |                 }
212 |             }
213 |         }
214 |         
215 |         for(i=0; i<noofVerticesPerProcessor; i++){
216 |              if(Pij[i] == 1 && Tij[i]==1){
217 |                 Tij[i]=0;
218 |             }
219 |         }
220 |         for(i=0; i<noofVerticesPerProcessor; i++){
221 |             if(Pij[i] == 0 && Tij[i]==1){
222 |                 Pij[i]=1;  
223 |             }
224 |         }
225 |         for(i=0; i<noofVerticesPerProcessor; i++){
226 |             Fij[i] = Tij[i];
227 |         }
228 |   
229 |         MPI_Allgather(Fij,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT,rowComm);         
230 |         MPI_Allgather(rec_buffer,noofVerticesinRowofProcessor,MPI_INT,F,noofVerticesinRowofProcessor,MPI_INT,colComm);
231 |     }// End of an iteration.
232 |       
233 |     t1 = MPI_Wtime();  // Marks end of the BFS.
234 |     t1 = t1-t2; 
235 |     MPI_Reduce(&t1, &t2,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD); // Computing maximum time elapsed among all processors
236 |     if(rank==0){	
237 |         printf( "Elapsed time for parallel bfs to traverse %lld in %f\n",noofVertices, t2 ); 
238 |         fflush(stdout);
239 |     }
240 |     MPI_Finalize(); // End of execution.
241 | }
242 | 
243 | long long int getIndex(long long int i, long long int j ,long long int rowSize){
244 |     return i*rowSize+j;
245 | }
246 | 
247 | bool isClear(int F[],long int rowNo,long int columnNo,long int size) {
248 |     int temp;
249 |     for(temp = 0;temp<size;temp++) {
250 |         if(F[temp]==1) {
251 |             return true;
252 |         }
253 |     }
254 |     return false;
255 | }
256 | 


--------------------------------------------------------------------------------
/ParallelBFS_usingMPI_Parallel_IO.c:
--------------------------------------------------------------------------------
  1 | #include "mpi.h"
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include "math.h"
  5 | #include <stdbool.h>
  6 | 
  7 | /*
  8 |  * This method checks the frontier vector F for all 0's to indicate entire graph has traversed.
  9 | */
 10 | bool isClear(int[], long int, long int,long int );
 11 | 
 12 | /*
 13 |  * Main start of the program
 14 |  * Denotions used in the below code:
 15 |  *	F -> Frontier vector to identify nodes to be traversed in next level.
 16 |  * 	T -> Temporary vector to hold the next level nodes.
 17 |  * 	P -> Parent vector used to hold the nodes already visited.
 18 |  *	Aij -> Adjacency matrix local to each processor.
 19 | */
 20 | int main (int argc, char *argv[])
 21 | {
 22 |     unsigned long long int rowNo, columnNo;
 23 |     unsigned long long int noofPRows, noofVertices, noofVerticesPerProcessor;
 24 |     double t1, t2;
 25 |     int rank, numtasks, size;
 26 |     MPI_Init(&argc, &argv);
 27 |     t1 = MPI_Wtime(); 
 28 | 	
 29 |       MPI_Status status;
 30 |       MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
 31 |       MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 32 |       noofPRows = (int) sqrt(numtasks);
 33 |       noofVertices = atoll(argv[2]);
 34 |       noofVerticesPerProcessor = (int) ceil(atoi(argv[2])/(noofPRows*noofPRows));
 35 | 	
 36 |       unsigned long long int i,j,k;
 37 |       int* F;
 38 |       F = (int *) malloc(sizeof(int)*noofVertices);
 39 |       for(i=0; i<noofVertices; i++){
 40 | 		F[i] = 0;
 41 |       }
 42 |       F[atoi(argv[4])] = 1;
 43 |       int* Fij;
 44 |       Fij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 45 |       int* Pij;
 46 |       Pij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 47 |       
 48 |       int* Tij;
 49 |       Tij = (int *) malloc(sizeof(int)*noofVerticesPerProcessor);
 50 |       for( i =0; i<noofVerticesPerProcessor; i++){
 51 | 		Pij[i] = 0;
 52 | 		Fij[i] = 0;
 53 | 		Tij[i] = 0;
 54 |       }
 55 |       
 56 |       int* Ti;
 57 |       Ti = (int *) malloc(sizeof(int)*noofVerticesPerProcessor*noofPRows);
 58 |       for(i=0; i < noofVerticesPerProcessor*noofPRows ; i++){
 59 | 		Ti[i] = 0;
 60 |       }
 61 |       
 62 |       unsigned long long int noofVerticesinRowofProcessor = noofVerticesPerProcessor*noofPRows;
 63 |       
 64 |       char* Aij;
 65 |       Aij = (char *) malloc(sizeof(char)*noofVerticesinRowofProcessor*noofVerticesinRowofProcessor);
 66 |       
 67 |       for(i=0; i < noofVerticesinRowofProcessor*noofVerticesinRowofProcessor ; i++){
 68 | 		Aij[i] = 0;
 69 |       }
 70 |           
 71 |     //Reading File.
 72 |       MPI_Comm rowComm, colComm;
 73 |       rowNo = (rank)/noofPRows + 1;
 74 |       columnNo = rank%noofPRows +1;
 75 |       
 76 |       int i1,j1; 
 77 |       
 78 |       i = rank/noofPRows;
 79 |       j = rank%noofPRows;
 80 | 
 81 |       MPI_Status stat;
 82 |       MPI_Datatype MPI_CHUNK;
 83 |       MPI_Type_vector(noofVerticesinRowofProcessor,noofVerticesinRowofProcessor,noofVertices,MPI_CHAR,&MPI_CHUNK);
 84 |       MPI_Type_commit(&MPI_CHUNK);
 85 |       MPI_File fh;
 86 |       MPI_File_open(MPI_COMM_WORLD, argv[1], MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);
 87 |       MPI_Offset offset = (i*noofVertices*noofVerticesinRowofProcessor+j*noofVerticesinRowofProcessor) * sizeof(char) ;
 88 |       MPI_File_set_view(fh, offset, MPI_CHAR, MPI_CHUNK, "native", MPI_INFO_NULL);
 89 |        
 90 |       MPI_File_read(fh, Aij,1ULL*noofVerticesinRowofProcessor*noofVerticesinRowofProcessor, MPI_CHAR, &stat);
 91 |       MPI_Type_free(&MPI_CHUNK);
 92 |       MPI_File_close(&fh);
 93 | 	        
 94 |       MPI_Comm_split(MPI_COMM_WORLD, columnNo, rank, &colComm); 
 95 |       MPI_Comm_split(MPI_COMM_WORLD, rowNo, rank, &rowComm);
 96 | 
 97 |       
 98 | 	for(i=0; i< noofVerticesPerProcessor; i++){
 99 | 		Fij[i] = F[(rowNo-1)*noofVerticesPerProcessor*noofPRows+(columnNo-1)*noofVerticesPerProcessor +i];
100 |         Pij[i] = Fij[i];
101 |     }
102 |       int* rec_buffer = (int*)malloc(sizeof(int)*noofVerticesinRowofProcessor);
103 |       int* send_buffer = (int*)malloc(sizeof(int)*noofVerticesPerProcessor);      
104 | 
105 |       t2 = MPI_Wtime(); 
106 |       if(rank==0)
107 |       	printf( "Elapsed time for data reading and initialization %f\n", t2 - t1 ); 
108 |         int roundNo=1;
109 |         int noofvertices=0;
110 |     while(isClear(F,rowNo, columnNo, noofVertices)) {
111 | 		for(i=0; i<noofVerticesPerProcessor; i++){
112 |              send_buffer[i] = Fij[i];
113 |           }
114 |          
115 | 		if(rowNo != columnNo) {
116 | 			if(rowNo > columnNo) {
117 | 				MPI_Send(send_buffer, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD);
118 | 				MPI_Recv(Fij, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD, &status);
119 | 			} else {
120 | 				MPI_Recv(Fij, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD, &status);
121 | 				MPI_Send(send_buffer, noofVerticesPerProcessor, MPI_INT, (columnNo-1)*noofPRows+rowNo-1, 123, MPI_COMM_WORLD); 
122 | 			}
123 | 		}
124 |          MPI_Allgather(Fij,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT,colComm);
125 |            
126 |          int val=0;
127 |          
128 |          for(i=0; i<noofVerticesinRowofProcessor; i++){
129 |              val=0;
130 |              for(j=0;j<noofVerticesinRowofProcessor; j++){
131 |                 val += Aij[i*noofVerticesinRowofProcessor + j]*rec_buffer[j];
132 | 	     }
133 |              Ti[i] = val;
134 |          }
135 | 
136 |          MPI_Alltoall(Ti,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT, rowComm);
137 | 		 for(i=0; i<noofPRows; i++){
138 |            for(j=0; j<noofVerticesPerProcessor;j++){
139 |              if(rec_buffer[i*noofVerticesPerProcessor+j] > 0){
140 |                 Tij[j]=1;
141 |              }
142 |            }
143 |          }
144 |         
145 |          for(i=0; i<noofVerticesPerProcessor; i++){
146 |              if(Pij[i] == 1 && Tij[i]==1){
147 |                 Tij[i]=0;
148 |              }
149 |          }
150 |          for(i=0; i<noofVerticesPerProcessor; i++){
151 |              if(Pij[i] == 0 && Tij[i]==1){
152 |                 Pij[i]=1;  
153 |              }
154 |          }
155 |          for(i=0; i<noofVerticesPerProcessor; i++){
156 |              Fij[i] = Tij[i];
157 |          }
158 |   
159 |          MPI_Allgather(Fij,noofVerticesPerProcessor,MPI_INT,rec_buffer,noofVerticesPerProcessor,MPI_INT,rowComm);
160 |          
161 |          MPI_Allgather(rec_buffer,noofVerticesinRowofProcessor,MPI_INT,F,noofVerticesinRowofProcessor,MPI_INT,colComm);
162 |          
163 |        }
164 |       
165 |     t1 = MPI_Wtime(); 
166 |    fflush(stdout);
167 |     MPI_Finalize();
168 | }
169 | 
170 | /*
171 |  * This method checks the frontier vector F for all 0's to indicate entire graph has traversed.
172 |  * If any un-traversed node has been found i.e if any value in F vector equals 1, then this function returns true.
173 |  * Else, function returns false.
174 | */
175 | bool isClear(int F[],long int rowNo,long int columnNo,long int size) {
176 |   int temp,i;
177 |   for(temp = 0;temp<size;temp++) {
178 |     if(F[temp]==1) {
179 |        return true;
180 |     }
181 |   }
182 |   return false;
183 | }
184 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Overview:
 2 | 
 3 | In this project, we have implemented a distributed parallel algorithm for Breadth-First Search (BFS), a key subroutine in several graph algorithms. The general structure of the level-synchronous approach holds in case of distributed memory implementations as well, but fine-grained "visited" checks are replaced by edge aggregation-based strategies. With a distributed graph and a distributed d array, a processor cannot tell whether a non-local vertex has been previously visited or not. So the common approach taken is to just accumulate all edges corresponding to non-local vertices, and send them to the owner processor at the end of a local traversal. There is thus an additional all-to-all communication step at the end of each frontier expansion.
 4 | We have implemented a parallel BFS approach with 2D partitioning technique that works well on a dense graph. Let A denote the adjacency matrix of the graph, represented in a dense boolean format, Xk denotes the kth frontier, represented as a vector with integer variables. It is easy to see that the exploration of level k in BFS is algebraically equivalent to Xk+1 = AT x Xk.
 5 | Our dense matrix approach uses the alternative 2D decomposition of the adjacency matrix of the graph. Consider the simple checkerboard partitioning, where processors are logically organized on a square p = pr x pc mesh, indexed by their row and column indices so that the (i,j)th processor is denoted by P(i, j). Edges and vertices (sub-matrices) are assigned to processors according to 2D block decomposition. Each node stores a sub-matrix of dimensions (n/pr)x(n/pc) in its local memory. 
 6 | 
 7 | Assumptions:
 8 | 
 9 | We implemented this parallel BFS which is taken from the paper [1] by Kamesh Madduri et al. The following are few assumption and modifications we made:
10 | 1)	Input graph for parallel traversing is assumed to be dense, and hence we use adjacency matrix representation for input graph.
11 | 2)	Number of processor used to solve this problem in parallel is always a perfect square. This constraint is attributed to the fact that there is transpose communication between processor as explained in implementation details below.
12 | 3)	We have worked only on undirected graphs, we are confident of extending the same implementation to directed graphs too.
13 | We have ignored input data generation time while analyzing our algorithm.
14 | 
15 | Data set generation and Processing:
16 | 
17 | We have implemented two different versions of our algorithm to generate input graph to our parallel BFS algorithm. They are briefly listed below:
18 | 1.	We have generated the input graph separately using the Erdos-Renyi model. This model takes the input seed, probability and the source vertex to generate the adjacency matrix of the graph. In this data generation approach, our BFS algorithm uses the MPI File Read to read data into local memory in parallel.
19 | 2.	In the second version, we have generated the adjacency matrix for each processor locally. All the processors generate a part of the graph by randomly assigning 1’s and 0’s depending on the density parameter. We also made sure that the undirected input graph/ adjacency matrix as a whole is symmetric by communications between processors above the diagonal to the processors below the diagonal in the grid. Hence, the right& above half of the adjacency matrix is perfect mirror to left & below half of the matrix.
20 | Also, if the input adjacency matrix is not sufficient to get distributed across all the processors equally, we appended 0’s in the last few rows/ last few columns of the matrix. This ensures that each processor gets equal number of vertices in the partitioning and the length for the distributed frontier vector in our algorithm remains same for each processor.
21 | 
22 | Implementation Details:
23 | 
24 | 	A brief idea of our algorithm can be depicted as below:
25 | 		f(s)  s
26 | 		For all processors P(i, j) in parallel do
27 | 			While F != NULL do
28 | 			TransposeVector(fij)
29 | 			fi Allgatherv(fij, P(:,j))
30 | 			ti  Aij X fi
31 | 			tij  Alltoallv(ti, P(i,:))
32 | 			tij  tij X Pij
33 | 			Pij  Pij + tij
34 | 			fij  tij
35 | This algorithm computes the "breadth-first spanning tree" by returning a dense parents array. "s" denotes the source vertex which is an input to the algorithm. "f" denotes the complete frontier vector while fij denotes the frontier vector of each individual processor P(i,j). "fi" denotes the frontier vector of an entire column of processors 'pc'. "tij" and "ti" are intermediate vectors owned by the individual and an entire column of processors. TransposeVector redistributes the vector so that the subvector owned by the ith processor row is now owned by the ith processor column. In the case of pr = pc = √p, the operation is simply a pair-wise exchange between P(i,j) and P(j,i). Allgather(fij , P(:, j)) syntax denotes that subvectors fij for j = 1,..,pr is accumulated at all the processors on the jth processor column. Similarly, Alltoallv(ti, P(i, :)) denotes that each processor scatters the corresponding piece of its intermediate vector "ti" to its owner, along the ith processor row.
36 | 
37 | How to run:
38 | 
39 | Compile the source code using MPICC command.
40 | ex: mpicc PBFSWithGraphGeneration.c -o base-bfs -lm
41 | 
42 | Now run the output file base-bfs using MPIRUN command.
43 | ex: mpirun -np 16 base-bfs 131072 1
44 | 
45 | Also, a SLURM job can be submitted using the SRUN command.
46 | srun --n_procs base-bfs 131072 1
47 | 
48 | 
49 | References:
50 | 
51 | [1] http://gauss.cs.ucsb.edu/~aydin/sc11_bfs.pdf.
52 | [2] http://www.mpich.org/static/docs/v3.1/www3/
53 | [3] http://gauss.cs.ucsb.edu/~aydin/sc11_bfs.pdf
54 | [4] http://www.cc.gatech.edu/fac/bader/papers/TaskBFS-HiPC2012.pdf
55 | [5] http://www.boost.org/doc/libs/1_58_0/libs/graph/doc/erdos_renyi_generator.html
56 | [6] http://mpi.deino.net/mpi_functions/MPI_Comm_split.html
57 | 


--------------------------------------------------------------------------------
/SequentialBFS.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #include<time.h>
 4 | #define MAX 262144
 5 |  
 6 | typedef enum boolean{false, true} bool;
 7 | char** adj;
 8 | bool visited[ MAX ];
 9 | 
10 | void create_graph();
11 | void bfs(int source);
12 | void display();
13 | 
14 | int main(){
15 |     int i, source=1;
16 |     create_graph();
17 |     for ( i = 0;i < MAX;i++ )
18 | 	visited[ i ] = false;
19 |     clock_t start = clock(), diff;
20 |     bfs(source);
21 |     diff = clock() - start;
22 |     int msec = diff * 1000 / CLOCKS_PER_SEC;
23 |     printf("Time taken %d seconds %d milliseconds", msec/1000, msec%1000);
24 |     return 0; 
25 | } /*End of main()*/
26 |  
27 | void create_graph(){
28 |     adj = (char **) malloc(sizeof(char*)*MAX);
29 |     int ind=0; 
30 |     for(;ind<MAX;ind++)
31 |         adj[ind] = (char *) malloc(MAX*sizeof(char));
32 |     srand(100);
33 |     int dens = 60;
34 |     long long int noofOnes=0;
35 |     long long int i2,j2,k2;
36 |     printf("2\n");
37 |     for(i2=0; i2< MAX; i2++){
38 |         for(j2=i2; j2< MAX; j2++){
39 |             int rand1 = rand()%100;
40 |             if(rand1>=dens){
41 |                 adj[i2][j2] = 1;
42 | 		adj[j2][i2] = 1;
43 |                 noofOnes++;
44 |             }else{
45 | 		adj[i2][j2] = 0;
46 | 		adj[j2][i2] = 0;
47 | 	    }
48 | 	}
49 |     }
50 | } /*End of create_graph()*/
51 |  
52 | void display()
53 | {
54 |     int i, j;
55 |    printf("inside display\n");
56 |     for ( i = 0;i < MAX;i++ )
57 |         {
58 |             for ( j = 0;j < MAX;j++ )
59 |                 printf( "%4d", adj[ i ][ j ] );
60 |  
61 |             printf( "\n" );
62 |         }
63 | } /*End of display()*/
64 | 
65 |  
66 | void bfs( int v )
67 | {
68 |     long long int i, front, rear;
69 |     int* que = (int*) malloc(sizeof(int)*MAX);
70 |     front = rear = -1;
71 |     printf( "%d ", v );
72 |     visited[ v ] = true;
73 |     rear++;
74 |     front++;
75 |     que[ rear ] = v;
76 |     while ( front <= rear ){
77 |         v = que[ front ]; /* delete from queue */
78 |         front++;
79 |         for ( i = 0;i < MAX;i++ ){
80 |             /* Check for adjacent unvisited nodes */
81 |             if ( adj[ v ][ i ] == 1 && visited[ i ] == false ){
82 |                 visited[ i ] = true;
83 |                 rear++;
84 |                 que[ rear ] = i;
85 |              }   
86 |         }
87 |     }
88 | } /*End of bfs()*/
89 |  
90 |  
91 | 


--------------------------------------------------------------------------------