int main(void) {
int p, my_rank;
MPI_Comm comm;
int my_contrib;
int sum;
MPI_Init(NULL, NULL);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &p);
MPI_Comm_rank(comm, &my_rank);
/* Generate a random int */
srandom(my_rank);
my_contrib = random() % MAX_CONTRIB;
Print_results("Process Values", my_contrib, my_rank, p, comm);
sum = Global_sum(my_contrib, my_rank, p, comm);
Print_results("Process Totals", sum, my_rank, p, comm);
MPI_Finalize();
return 0;
}
int main(void) {
float* local_x;
float* local_y;
int n;
int local_n; /* = n/p */
float dot;
int p;
int my_rank;
MPI_Comm comm;
MPI_Init(NULL, NULL);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &p);
MPI_Comm_rank(comm, &my_rank);
if (my_rank == 0) {
printf("Enter the order of the vectors\n");
scanf("%d", &n);
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
local_n = n/p;
local_x = malloc(local_n*sizeof(float));
local_y = malloc(local_n*sizeof(float));
Read_vector("the first vector", local_x, local_n, n, my_rank, comm);
Read_vector("the second vector", local_y, local_n, n, my_rank, comm);
dot = Parallel_dot(local_x, local_y, local_n, comm);
Print_results(dot, p, my_rank, comm);
free(local_x);
free(local_y);
MPI_Finalize();
return 0;
} /* main */
main(int argc, char* argv[]) {
int test_count = 2; /* Number of tests */
int max_size = 1000; /* Max msg. length */
int min_size = 1000; /* Min msg. length */
int size_incr = 1000; /* Increment for */
/* msg. sizes */
float* x; /* Message buffer */
double* times; /* Elapsed times */
double* max_times; /* Max times */
double* min_times; /* Min times */
int time_array_order; /* Size of timing */
/* arrays. */
double start; /* Start time */
double elapsed; /* Elapsed time */
int i, test, size; /* Loop variables */
int p, my_rank, source, dest;
MPI_Comm io_comm;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &p);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_dup(MPI_COMM_WORLD, &io_comm);
Cache_io_rank(MPI_COMM_WORLD, io_comm);
Initialize(max_size, min_size, size_incr, my_rank,
&x, ×, &max_times, &min_times,
&time_array_order);
source = (my_rank - 1) % p;
dest = (my_rank + 1) % p;
/* For each message size, find average circuit time */
/* Loop var size = message size */
/* Loop var i = index into arrays for timings */
for (size = min_size, i = 0; size <= max_size;
size = size + size_incr, i++) {
times[i] =0.0;
max_times[i] = 0.0;
min_times[i] = 1000000.0;
for (test = 0; test < test_count; test++) {
start = MPI_Wtime();
MPI_Recv(x, size, MPI_FLOAT, source, 0,
MPI_COMM_WORLD, &status);
MPI_Send(x, size, MPI_FLOAT, dest, 0,
MPI_COMM_WORLD);
elapsed = MPI_Wtime() - start;
times[i] = times[i] + elapsed;
if (elapsed > max_times[i])
max_times[i] = elapsed;
if (elapsed < min_times[i])
min_times[i] = elapsed;
}
} /* for size . . . */
Print_results(io_comm, my_rank, min_size, max_size,
size_incr, time_array_order, test_count, times,
max_times, min_times);
MPI_Finalize();
} /* main */
