double ReduceStreams(DGraph *dg,DGNode *nd){
double csum=0.0;
int i=0,len=0,tag=0;
DGArc *ar=NULL;
DGNode *tail=NULL;
Arr *feat=NULL;
double retv=0.0;
TRACE_smpi_set_category ("ReduceStreams");
for(i=0;i<nd->inDegree;i++){
ar=nd->inArc[i];
if(ar->head!=nd) continue;
tail=ar->tail;
if(tail->address!=nd->address){
MPI_Status status;
len=0;
tag=ar->id;
MPI_Recv(&len,1,MPI_INT,tail->address,tag,MPI_COMM_WORLD,&status);
feat=newArr(len);
MPI_Recv(feat->val,feat->len,MPI_DOUBLE,tail->address,tag,MPI_COMM_WORLD,&status);
csum+=Reduce(feat,(nd->id+1));
SMPI_SHARED_FREE(feat);
}else{
csum+=Reduce(tail->feat,(nd->id+1));
}
}
if(nd->inDegree>0)csum=(((long long int)csum)/nd->inDegree);
retv=(nd->id+1)*csum;
return retv;
}
int ProcessNodes(DGraph *dg,int me){
double chksum=0.0;
Arr *feat=NULL;
int i=0,verified=0,tag;
DGNode *nd=NULL;
double rchksum=0.0;
MPI_Status status;
TRACE_smpi_set_category ("ProcessNodes");
for(i=0;i<dg->numNodes;i++){
nd=dg->node[i];
if(nd->address!=me) continue;
if(strstr(nd->name,"Source")){
nd->feat=RandomFeatures(dg->name,fielddim,nd->id);
SendResults(dg,nd,nd->feat);
}else if(strstr(nd->name,"Sink")){
chksum=ReduceStreams(dg,nd);
tag=dg->numArcs+nd->id; /* make these to avoid clash with arc tags */
MPI_Send(&chksum,1,MPI_DOUBLE,0,tag,MPI_COMM_WORLD);
}else{
feat=CombineStreams(dg,nd);
SendResults(dg,nd,feat);
}
}
TRACE_smpi_set_category ("ProcessNodes");
if(me==0){ /* Report node */
rchksum=0.0;
chksum=0.0;
for(i=0;i<dg->numNodes;i++){
nd=dg->node[i];
if(!strstr(nd->name,"Sink")) continue;
tag=dg->numArcs+nd->id; /* make these to avoid clash with arc tags */
MPI_Recv(&rchksum,1,MPI_DOUBLE,nd->address,tag,MPI_COMM_WORLD,&status);
chksum+=rchksum;
}
verified=verify(dg->name,chksum);
}
return verified;
}
int SendResults(DGraph *dg,DGNode *nd,Arr *feat){
int i=0,tag=0;
DGArc *ar=NULL;
DGNode *head=NULL;
if(!feat) return 0;
TRACE_smpi_set_category ("SendResults");
for(i=0;i<nd->outDegree;i++){
ar=nd->outArc[i];
if(ar->tail!=nd) continue;
head=ar->head;
tag=ar->id;
if(head->address!=nd->address){
MPI_Send(&feat->len,1,MPI_INT,head->address,tag,MPI_COMM_WORLD);
MPI_Send(feat->val,feat->len,MPI_DOUBLE,head->address,tag,MPI_COMM_WORLD);
}
}
TRACE_smpi_set_category (NULL);
return 1;
}
int main(int argc,char **argv ){
int my_rank,comm_size;
int i;
DGraph *dg=NULL;
int verified=0, featnum=0;
double bytes_sent=2.0,tot_time=0.0;
MPI_Init( &argc, &argv );
MPI_Comm_rank( MPI_COMM_WORLD, &my_rank );
MPI_Comm_size( MPI_COMM_WORLD, &comm_size );
TRACE_smpi_set_category ("begin");
if(argc!=2||
( strncmp(argv[1],"BH",2)!=0
&&strncmp(argv[1],"WH",2)!=0
&&strncmp(argv[1],"SH",2)!=0
)
){
if(my_rank==0){
fprintf(stderr,"** Usage: mpirun -np N ../bin/dt.S GraphName\n");
fprintf(stderr,"** Where \n - N is integer number of MPI processes\n");
fprintf(stderr," - S is the class S, W, or A \n");
fprintf(stderr," - GraphName is the communication graph name BH, WH, or SH.\n");
fprintf(stderr," - the number of MPI processes N should not be be less than \n");
fprintf(stderr," the number of nodes in the graph\n");
}
MPI_Finalize();
exit(0);
}
if(strncmp(argv[1],"BH",2)==0){
dg=buildBH(CLASS);
}else if(strncmp(argv[1],"WH",2)==0){
dg=buildWH(CLASS);
}else if(strncmp(argv[1],"SH",2)==0){
dg=buildSH(CLASS);
}
if(timer_on&&dg->numNodes+1>timers_tot){
timer_on=0;
if(my_rank==0)
fprintf(stderr,"Not enough timers. Node timeing is off. \n");
}
if(dg->numNodes>comm_size){
if(my_rank==0){
fprintf(stderr,"** The number of MPI processes should not be less than \n");
fprintf(stderr,"** the number of nodes in the graph\n");
fprintf(stderr,"** Number of MPI processes = %d\n",comm_size);
fprintf(stderr,"** Number nodes in the graph = %d\n",dg->numNodes);
}
MPI_Finalize();
exit(0);
}
for(i=0;i<dg->numNodes;i++){
dg->node[i]->address=i;
}
if( my_rank == 0 ){
printf( "\n\n NAS Parallel Benchmarks 3.3 -- DT Benchmark\n\n" );
graphShow(dg,0);
timer_clear(0);
timer_start(0);
}
verified=ProcessNodes(dg,my_rank);
TRACE_smpi_set_category ("end");
featnum=NUM_SAMPLES*fielddim;
bytes_sent=featnum*dg->numArcs;
bytes_sent/=1048576;
if(my_rank==0){
timer_stop(0);
tot_time=timer_read(0);
c_print_results( dg->name,
CLASS,
featnum,
0,
0,
dg->numNodes,
0,
comm_size,
tot_time,
bytes_sent/tot_time,
"bytes transmitted",
verified,
NPBVERSION,
COMPILETIME,
MPICC,
CLINK,
CMPI_LIB,
CMPI_INC,
CFLAGS,
CLINKFLAGS );
}
MPI_Finalize();
return 1;
}
int main(int argc, char *argv[])
{
int rank, numprocs, i;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/** Tests:
* A: 0(isend -> wait) with 1(recv)
* B: 0(send) with 1(irecv -> wait)
* C: 0(N * isend -> N * wait) with 1(N * recv)
* D: 0(N * isend -> N * waitany) with 1(N * recv)
* E: 0(N*send) with 1(N*irecv, N*wait)
* F: 0(N*send) with 1(N*irecv, N*waitany)
* G: 0(N* isend -> waitall) with 1(N*recv)
* H: 0(N*send) with 1(N*irecv, waitall)
* I: 0(2*N*send, 2*N*Irecv, Waitall) with
* 1(N*irecv, waitall, N*isend, N*waitany) with
* 2(N*irecv, N*waitany, N*isend, waitall)
* J: 0(N*isend, N*test, N*wait) with (N*irecv, N*test, N*wait)
s*/
int N = 13;
int tag = 12345;
/////////////////////////////////////////
////////////////// RANK 0
///////////////////////////////////
if (rank == 0) {
MPI_Request request;
MPI_Status status;
MPI_Request req[2 * N];
MPI_Status sta[2 * N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
/** Test A */
TRACE_smpi_set_category("A");
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &request);
MPI_Wait(&request, &status);
MPI_Barrier(MPI_COMM_WORLD);
/** Test B */
TRACE_smpi_set_category("B");
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
/** Test C */
TRACE_smpi_set_category("C");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("D");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("E");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("F");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("G");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("H");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("I");
for (i = 0; i < 2 * N; i++) {
if (i < N) {
MPI_Send(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD);
} else {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < 2 * N; i++) {
if (i < N) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
} else {
MPI_Irecv(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD, &req[i]);
}
}
MPI_Waitall(2 * N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("J");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int flag;
MPI_Test(&req[i], &flag, &sta[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
free(r);
/////////////////////////////////////////
////////////////// RANK 1
///////////////////////////////////
} else if (rank == 1) {
MPI_Request request;
MPI_Status status;
MPI_Request req[N];
MPI_Status sta[N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
TRACE_smpi_set_category("A");
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("B");
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &request);
MPI_Wait(&request, &status);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("C");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("D");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("E");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("F");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("G");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("H");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("I");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("J");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int flag;
MPI_Test(&req[i], &flag, &sta[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
free(r);
/////////////////////////////////////////
////////////////// RANK 2
///////////////////////////////////
} else if (rank == 2) {
MPI_Request req[N];
MPI_Status sta[N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
TRACE_smpi_set_category("I");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
free(r);
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int rank, numprocs, i;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
//Tests:
//A: 0(isend -> wait) with 1(recv)
int A = 1;
//B: 0(send) with 1(irecv -> wait)
int B = 1;
//C: 0(N * isend -> N * wait) with 1(N * recv)
int C = 1;
//D: 0(N * isend -> N * waitany) with 1(N * recv)
int D = 1;
//E: 0(N*send) with 1(N*irecv, N*wait)
int E = 1;
//F: 0(N*send) with 1(N*irecv, N*waitany)
int F = 1;
//G: 0(N* isend -> waitall) with 1(N*recv)
int G = 1;
//H: 0(N*send) with 1(N*irecv, waitall)
int H = 1;
//I: 0(2*N*send, 2*N*Irecv, Waitall) with
// 1(N*irecv, waitall, N*isend, N*waitany) with
// 2(N*irecv, N*waitany, N*isend, waitall)
int I = 1;
//J: 0(N*isend, N*test, N*wait) with (N*irecv, N*test, N*wait)
int J = 1;
int N = 13;
int tag = 12345;
/////////////////////////////////////////
////////////////// RANK 0
///////////////////////////////////
if (rank == 0) {
MPI_Request request;
MPI_Status status;
MPI_Request req[2 * N];
MPI_Status sta[2 * N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
if (A) {
TRACE_smpi_set_category("A");
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &request);
MPI_Wait(&request, &status);
}
MPI_Barrier(MPI_COMM_WORLD);
if (B) {
TRACE_smpi_set_category("B");
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
if (C) {
TRACE_smpi_set_category("C");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (D) {
TRACE_smpi_set_category("D");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (E) {
TRACE_smpi_set_category("E");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (F) {
TRACE_smpi_set_category("F");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (G) {
TRACE_smpi_set_category("G");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
if (H) {
TRACE_smpi_set_category("H");
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (I) {
TRACE_smpi_set_category("I");
for (i = 0; i < 2 * N; i++) {
if (i < N) {
MPI_Send(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD);
} else {
MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < 2 * N; i++) {
if (i < N) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD,
&req[i]);
} else {
MPI_Irecv(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD,
&req[i]);
}
}
MPI_Waitall(2 * N, req, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
if (J) {
TRACE_smpi_set_category("J");
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int flag;
MPI_Test(&req[i], &flag, &sta[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
}
free(r);
/////////////////////////////////////////
////////////////// RANK 1
///////////////////////////////////
} else if (rank == 1) {
MPI_Request request;
MPI_Status status;
MPI_Request req[N];
MPI_Status sta[N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
if (A) {
TRACE_smpi_set_category("A");
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
}
MPI_Barrier(MPI_COMM_WORLD);
if (B) {
TRACE_smpi_set_category("B");
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &request);
MPI_Wait(&request, &status);
}
MPI_Barrier(MPI_COMM_WORLD);
if (C) {
TRACE_smpi_set_category("C");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (D) {
TRACE_smpi_set_category("D");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (E) {
TRACE_smpi_set_category("E");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (F) {
TRACE_smpi_set_category("F");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (G) {
TRACE_smpi_set_category("G");
for (i = 0; i < N; i++) {
MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (H) {
TRACE_smpi_set_category("H");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
if (I) {
TRACE_smpi_set_category("I");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < N; i++) {
MPI_Isend(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
MPI_Waitall(N, req, sta);
// for (i = 0; i < N; i++){
// MPI_Wait (&req[i], &sta[i]);
// }
}
MPI_Barrier(MPI_COMM_WORLD);
if (J) {
TRACE_smpi_set_category("J");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int flag;
MPI_Test(&req[i], &flag, &sta[i]);
}
for (i = 0; i < N; i++) {
MPI_Wait(&req[i], &sta[i]);
}
}
free(r);
/////////////////////////////////////////
////////////////// RANK 2
///////////////////////////////////
} else if (rank == 2) {
// MPI_Request request;
// MPI_Status status;
MPI_Request req[N];
MPI_Status sta[N];
int *r = (int *) malloc(sizeof(int) * DATATOSENT);
if (A) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (B) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (C) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (D) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (E) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (F) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (G) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (H) {
}
MPI_Barrier(MPI_COMM_WORLD);
if (I) {
TRACE_smpi_set_category("I");
for (i = 0; i < N; i++) {
MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
}
for (i = 0; i < N; i++) {
int completed;
MPI_Waitany(N, req, &completed, sta);
}
MPI_Barrier(MPI_COMM_WORLD);
for (i = 0; i < N; i++) {
MPI_Send(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD);
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (J) {
}
free(r);
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
