CSL-342: Parallel Programming lab

Semester BSIT – 06
Student Name: Muhammad Faisal
Registration: 43865

Lab 08: Performing Parallel Rank with MPI

Exercises

Exercise 1

write a program that implements two primary function (discussed above), and
put them all together into TMPI_Rank function.

Code

#include <stdio.h> comm_rank_number_b->number.i) {

#include <stdlib.h> return -1; } else if
#include <mpi.h> (comm_rank_number_a->number.i>
#include "tmpi_rank.h" #include <time.h> comm_rank_number_b->number.i) {
int main(int argc, char** argv) { return 1; } else { return 0; } }
MPI_Init(NULL, NULL); int *get_ranks(void *gathered_numbers,
int world_rank; int gathered_number_count, MPI_Datatype
MPI_Comm_rank(MPI_COMM_WORLD, datatype) { int datatype_size;
&world_rank); int world_size; MPI_Type_size(datatype, &datatype_size);
MPI_Comm_size(MPI_COMM_WORLD,
&world_size); CommRankNumber *comm_rank_numbers =
// Seed the random number generator to malloc(gathered_number_count *
get different results each time sizeof(CommRankNumber)); int i; for
srand(time(NULL) * world_rank); (i = 0; i < gathered_number_count; i++) {
float rand_num = rand() / comm_rank_numbers[i].comm_rank = i;
(float)RAND_MAX; int rank; memcpy(&(comm_rank_numbers[i].number),
TMPI_Rank(&rand_num, &rank, MPI_FLOAT, gathered_numbers + (i * datatype_size),
MPI_COMM_WORLD); printf("Rank for %f on datatype_size); }
process %d - %d\n", rand_num, world_rank, if (datatype == MPI_FLOAT) {
rank); qsort(comm_rank_numbers,
MPI_Barrier(MPI_COMM_WORLD); gathered_number_count,
MPI_Finalize(); } sizeof(CommRankNumber),
&compare_float_comm_rank_number); }
#include <stdlib.h> else { qsort(comm_rank_numbers,
#include <mpi.h> gathered_number_count,
#include <string.h> sizeof(CommRankNumber),
typedef struct { int comm_rank; union &compare_int_comm_rank_number); }
{ float f; int i; } number; }
CommRankNumber;
int *ranks = (int *)malloc(sizeof(int) *
gathered_number_count); for (i = 0; i <
void *gather_numbers_to_root(void
gathered_number_count; i++) {
*number, MPI_Datatype datatype, MPI_Comm
ranks[comm_rank_numbers[i].comm_rank] =
comm)
i; }
{ int comm_rank, comm_size;
// Clean up and return the rank array
MPI_Comm_rank(comm, &comm_rank);
free(comm_rank_numbers); return ranks;
MPI_Comm_size(comm, &comm_size);
}
int datatype_size;
MPI_Type_size(datatype, &datatype_size);
void *gathered_numbers; if (comm_rank
== 0) { gathered_numbers = int TMPI_Rank(void *send_data, void
malloc(datatype_size * comm_size); } *recv_data, MPI_Datatype datatype,
int compare_float_comm_rank_number(const MPI_Comm comm) { // Check base cases
void *a, const void *b) { first - Only support MPI_INT and
CommRankNumber *comm_rank_number_a = MPI_FLOAT for this function. if
(CommRankNumber *)a; CommRankNumber (datatype != MPI_INT && datatype !=
*comm_rank_number_b = (CommRankNumber MPI_FLOAT) { return MPI_ERR_TYPE; }
*)b; if (comm_rank_number_a->number.f < int comm_size, comm_rank;
comm_rank_number_b->number.f) { MPI_Comm_size(comm, &comm_size);
return -1; } else if MPI_Comm_rank(comm, &comm_rank);
(comm_rank_number_a->number.f > void *gathered_numbers =
comm_rank_number_b->number.f) { gather_numbers_to_root(send_data,
return 1; } else { return 0; } } datatype, comm);
int compare_int_comm_rank_number(const int *ranks = NULL; if (comm_rank == 0)
void *a, const void *b) { { ranks = get_ranks(gathered_numbers,
CommRankNumber *comm_rank_number_a = comm_size, datatype); }
(CommRankNumber *)a; CommRankNumber MPI_Scatter(ranks, 1, MPI_INT, recv_data,
*comm_rank_number_b = (CommRankNumber 1, MPI_INT, 0, comm);
*)b; if (comm_rank_number_a->number.i < if (comm_rank == 0) {
free(gathered_numbers); free(ranks);
} }

Output: