//#define Debug
int main(int argc, char **argv)
{
	if(argc != 3)
	{
		printf("Usage: test {N}\n");
		exit(-1);
	}
	size_t N = atoi(argv[1]);
	size_t npro = atoi(argv[2]);
	omp_set_num_threads(npro);
	 int iam = 0, np = 1;
	 #pragma omp parallel private(iam, np)
          {
                  np = omp_get_num_threads();
                  iam = omp_get_thread_num();
#ifdef Debug
                  printf("Hello from thread %d out of %d\n", iam, np);
#endif
          }
	struct timeval tv1,tv2;
	// generate a random matrix.
	printf("Size is %d,numP is %d\n",N,npro);
	int *mat = (int*)malloc(sizeof(int)*N*N);
	GenMatrix(mat, N);

	// compute the reference result.
	int *ref = (int*)malloc(sizeof(int)*N*N);
	memcpy(ref, mat, sizeof(int)*N*N);
	gettimeofday(&tv1,NULL);
	ST_APSP(ref, N);
	gettimeofday(&tv2,NULL);
	printf("Sequential time = %ld usecs\n",
                          (tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);


	// compute your results
	int *result = (int*)malloc(sizeof(int)*N*N);
	memcpy(result, mat, sizeof(int)*N*N);
//	ST_APSP(result, N);

	gettimeofday(&tv1,NULL);
        OMP_APSP(result,N);
        gettimeofday(&tv2,NULL);
        printf("OpenMp time = %ld usecs\n",
                          (tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);

	// compare your result with reference result
	if(CmpArray(result, ref, N*N))
		printf("Your result is correct.\n");
	else
		printf("Your result is wrong.\n");
}
Esempio n. 2
0
int main(int argc, char **argv)
{
	if(argc != 2)
	{
		printf("Usage: test {N}\n");
		exit(-1);
	}

	size_t N = atoi(argv[1]);
	// matrix related variables
	int *mat, *ref, *result, *part, *k_row;
	int rows, k, root;
	int i, j, vij, vik, vkj;
	int npes, rank;
	struct timeval tv1, tv2;
	MPI_Init(&argc, &argv);
	MPI_Comm_size(MPI_COMM_WORLD, &npes);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	if(rank == 0){
		// generate matrix and compute sequential
		mat = (int*)malloc(sizeof(int)*N*N);
		ref = (int*)malloc(sizeof(int)*N*N);
		result = (int*)malloc(sizeof(int)*N*N);
		GenMatrix(mat, N);
		memcpy(ref, mat, sizeof(int)*N*N);
		gettimeofday(&tv1, NULL);
		ST_APSP(ref, N);
		gettimeofday(&tv2, NULL);
		printf("Sequential: %ld usecs\n",(tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);
		gettimeofday(&tv1, NULL);
	}

	// scatter the matrix
	rows = N/npes;
	part = (int*)malloc(sizeof(int)*N*rows);
	MPI_Scatter(mat, N*rows, MPI_INT, part, N*rows, MPI_INT, 0, MPI_COMM_WORLD);

	// parallel computing
	k_row = (int*)malloc(sizeof(int)*N);
	for(k = 0; k < N; k++){
		root = k/rows;
		if(rank == root){
			for(i = 0; i < N; i ++){
				*(k_row+i) = *(part + N*(k-rows*root) + i);
			}
		}
		MPI_Bcast(k_row, N, MPI_INT, root, MPI_COMM_WORLD);
		for(i = 0; i < rows; i++){
			for(j = 0; j < N; j++){
				vij = *(part + N*i + j);
				vik = *(part + N*i + k);
				vkj = *(k_row + j);
				if(vik != -1 && vkj != -1){
					if(vij == -1 || vij > vik+vkj)
					*(part + N*i + j) = vik + vkj;	
				}
			}
		}
	}
	
	// gather the matrix
	MPI_Gather(part, N*rows, MPI_INT, result, N*rows, MPI_INT, 0, MPI_COMM_WORLD);

	//compare your result with reference result
	if(rank == 0){
		gettimeofday(&tv2, NULL);
		printf("Parallel: %ld usecs\n",(tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);
//		printmat(mat, N);
//		printmat(ref, N);
//		printmat(result, N);
		if(CmpArray(result, ref, N*N))
			printf("Your result is correct.\n");
		else
			printf("Your result is wrong.\n");
	}

	// free memory
	if(rank == 0){
		free(mat);
		free(ref);
		free(result);
	}
	free(part);
	free(k_row);
	MPI_Finalize();
}
int main(int argc, char **argv) {
	MPI_Init(NULL, NULL);

	MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
	MPI_Comm_size(MPI_COMM_WORLD, &total_rank);

	if(argc != 2) {
		printf("Usage: test {mat_size}\n");
		exit(-1);
	}
	size_t mat_size = atoi(argv[1]);

	if (mat_size % total_rank) {
		for (int i = 0; i < 20; i++)
			printf("~");
		printf("\n");
		printf("Using MPT_*, only support divisible number of vertex...\n");
		for (int i = 0; i < 20; i++)
			printf("~");
		printf("\n");
		exit(-1);
	}
	
	int* mat;
	int* ref;
	int* result;
	if (my_rank == 0) {
		for (int i = 0; i < 20; i++)
			printf("~");
		printf("\n");
		printf("Using MPT_*, only support divisible number of vertex...\n");
		printf("Input size: %ld\n", mat_size);
		printf("Total process: %d\n", total_rank);

		prepare_data(&mat, &ref, &result, mat_size);

		// start the timer
		gettimeofday(&timer_parallel, NULL);
	}

	MPI_Barrier(MPI_COMM_WORLD);

	// know the set of rows I am working on according to my_rank 
	int rows_in_charge = mat_size / total_rank;

	// should this be included in the timer?
	int* my_rows = (int*)malloc(sizeof(int) * mat_size * rows_in_charge); //rows the current process have
	int* k_to_j = (int*)malloc(sizeof(int) * mat_size); // the vertical (column)

	if (my_rank == 0)
		gettimeofday(&timer_comm, NULL);
	// divide the matrix for each process
	// send rows to each process using scatter, sendbuf:*result, recvbuf:*my_rows
	int sendrecvcount = mat_size * rows_in_charge;
	MPI_Scatter(
		result, 
		sendrecvcount, 
		MPI_INT, 
		my_rows, 
		sendrecvcount, 
		MPI_INT, 
		0, 
		MPI_COMM_WORLD);
	if (my_rank == 0)
		time_comm += get_time_and_replace(&timer_comm);

	// preprocess_graph(my_rows, rows_in_charge, mat_size);

	for (int k = 0; k < mat_size; k++) {
		if (my_rank == 0)
			gettimeofday(&timer_comm, NULL);
		// broadcast k-th row to other process if I am the owner
		int owner_of_k_row = k / rows_in_charge;
		if (my_rank == owner_of_k_row)
			memcpy(k_to_j, my_rows + mat_size * (k % rows_in_charge), sizeof(int) * mat_size);
		MPI_Bcast(k_to_j, mat_size, MPI_INT, owner_of_k_row, MPI_COMM_WORLD);
		if (my_rank == 0)
			time_comm += get_time_and_replace(&timer_comm);

		for (int i = 0; i < rows_in_charge; i++) {
			for (int j = 0; j < mat_size; j++) {
				int ij = i * mat_size + j;
				int ik = i * mat_size + k;
				// if (my_rows[ij] > ikj)
				// 	my_rows[ij] = ikj;
				if (my_rows[ik] != -1 && k_to_j[j] != -1) {
					int ikj = my_rows[ik] + k_to_j[j];
					if (my_rows[ij] == -1 || my_rows[ij] > ikj)
						my_rows[ij] = ikj;
				}
			}
		}
	}

	if (my_rank == 0)
		gettimeofday(&timer_comm, NULL);
	// collect result to process 0
	MPI_Gather(
		my_rows,
		sendrecvcount,
		MPI_INT,
		result,
		sendrecvcount,
		MPI_INT,
		0,
		MPI_COMM_WORLD);
	if (my_rank == 0)
		time_comm += get_time_and_replace(&timer_comm);

	if (my_rank == 0) {
		//stop the timer
		time_used_parallel = get_time_and_replace(&timer_parallel);
		printf("Time used (parallel  ): %8ld usecs\n", time_used_parallel);
		printf("Time used (parallel  ) comm : %6ld usecs (%2.3lf%%) \n", time_comm, time_comm / (double)time_used_parallel * 100);
		printf("Speed up (sequential / parallel): %.3lf\n", time_used_sequential / (double)time_used_parallel);

		//compare your result with reference result
		if(CmpArray(result, ref, mat_size * mat_size))
			printf("Your result is correct.\n");
		else
			printf("Your result is wrong.\n");
		for (int i = 0; i < 20; i++)
			printf("~");
		printf("\n");
	}

    // Finalize the MPI environment.
    MPI_Finalize();
}
int main(int argc, char *argv[]) {
	if(argc != 2)
	{
		printf("Missing Argument\n");
		exit(-1);
	}
	
	int i, j;
	int *mat, *ref;
	int P, myrank;
	size_t N = atoi(argv[1]); //matrix size
	struct timeval tv1,tv2;
	MPI_Init(&argc, &argv);
	MPI_Comm_size(MPI_COMM_WORLD, &P);
	MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
	
	
	if(myrank == 0) {
		// generate a random matrix.
		printf("input Size is %d; number of process is %d \n",N,P);
		mat = (int*)malloc(sizeof(int)*N*N);
		GenMatrix(mat, N);

		// compute the reference result.
		ref = (int*)malloc(sizeof(int)*N*N);
		memcpy(ref, mat, sizeof(int)*N*N);
		
		gettimeofday(&tv1, NULL);
		ST_APSP(ref, N);
		gettimeofday(&tv2, NULL);
		printf("Sequential time = %ld usecs\n", 
				(tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);  
		
		// compute your results
		
	}
		int strip = N/P;
		int *part = (int*)malloc(sizeof(int)*N*strip); /*array holding the part for this processor*/
	// Scatter data to all processors
	MPI_Barrier(MPI_COMM_WORLD);
	    if (myrank == 0) {
                gettimeofday(&tv1,NULL);
        }
	MPI_Scatter(mat, N*strip, MPI_INT, part, N*strip, MPI_INT, 0, MPI_COMM_WORLD);

	// Compute matrix in parallel
	MT_APSP (part, MPI_COMM_WORLD, myrank, N, P);
	
	//Gather the results
	MPI_Gather(part, N*strip, MPI_INT, mat, N*strip, MPI_INT, 0, MPI_COMM_WORLD);
	MPI_Barrier(MPI_COMM_WORLD);
	if(myrank == 0) {
		gettimeofday(&tv2, NULL);
		printf("Parallel time = %ld usecs\n\n",
				(tv2.tv_sec-tv1.tv_sec)*1000000+tv2.tv_usec-tv1.tv_usec);
#ifdef test	
		// compare your result with reference result
		if(CmpArray(mat, ref, N*N))
			printf("Your result is correct.\n");
		else
			printf("Your result is wrong.\n");
#endif			
		free(mat);
		free(ref);
		
	}
	free(part);
	MPI_Finalize();
	return 0;
}