X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c57842fe897f53b46f0be3da87f7c996674be7d6..5ca17dc381bb7fba4f2689143e2080f7549ee0ab:/teshsuite/smpi/mpich3-test/rma/mixedsync.c

diff --git a/teshsuite/smpi/mpich3-test/rma/mixedsync.c b/teshsuite/smpi/mpich3-test/rma/mixedsync.c
index c558516c9d..0bf63c3c5b 100644
--- a/teshsuite/smpi/mpich3-test/rma/mixedsync.c
+++ b/teshsuite/smpi/mpich3-test/rma/mixedsync.c
@@ -14,24 +14,24 @@
 static char MTEST_Descrip[] = "Mix synchronization types";
 */
 
-void delay( double time );
-void delay( double time )
+void delay(double time);
+void delay(double time)
 {
     double t1;
     t1 = MPI_Wtime();
-    while (MPI_Wtime() - t1 < time) ;
+    while (MPI_Wtime() - t1 < time);
 }
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
-    int      errs = 0;
-    int      crank, csize, source, dest, loop;
-    int      *buf0, *buf1, *buf2, *inbuf2, count0, count1, count2, count, i;
+    int errs = 0;
+    int crank, csize, source, dest, loop;
+    int *buf0, *buf1, *buf2, *inbuf2, count0, count1, count2, count, i;
     MPI_Comm comm;
-    MPI_Win  win;
-    int      *winbuf;
+    MPI_Win win;
+    int *winbuf;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     comm = MPI_COMM_WORLD;
 
@@ -40,205 +40,189 @@ int main( int argc, char *argv[] )
     count2 = 100;
 
     count = count0 + count1 + count2 + 2;
-    
+
     /* Allocate and initialize the local buffers */
-    buf0   = (int *)malloc( count0 * sizeof(int) );
-    buf1   = (int *)malloc( count1 * sizeof(int) );
-    buf2   = (int *)malloc( count2 * sizeof(int) );
-    inbuf2 = (int *)malloc( count2 * sizeof(int) );
+    buf0 = (int *) malloc(count0 * sizeof(int));
+    buf1 = (int *) malloc(count1 * sizeof(int));
+    buf2 = (int *) malloc(count2 * sizeof(int));
+    inbuf2 = (int *) malloc(count2 * sizeof(int));
     if (!buf0 || !buf1 || !buf2 || !inbuf2) {
-	fprintf( stderr, "Unable to allocated buf0-2\n" );
-	MPI_Abort( MPI_COMM_WORLD, 1 );
+        fprintf(stderr, "Unable to allocated buf0-2\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    for (i=0; i<count0; i++) buf0[i] = i;
-    for (i=0; i<count1; i++) buf1[i] = i + count0;
-    for (i=0; i<count2; i++) buf2[i] = i + count0 + count1;
+    for (i = 0; i < count0; i++)
+        buf0[i] = i;
+    for (i = 0; i < count1; i++)
+        buf1[i] = i + count0;
+    for (i = 0; i < count2; i++)
+        buf2[i] = i + count0 + count1;
 
     /* Allocate the window buffer and create the memory window. */
-    MPI_Alloc_mem( count*sizeof(int), MPI_INFO_NULL, &winbuf );
+    MPI_Alloc_mem(count * sizeof(int), MPI_INFO_NULL, &winbuf);
     if (!winbuf) {
-	fprintf( stderr, "Unable to allocate %d words\n", count );
-	MPI_Abort( MPI_COMM_WORLD, 0 );
+        fprintf(stderr, "Unable to allocate %d words\n", count);
+        MPI_Abort(MPI_COMM_WORLD, 0);
     }
-    MPI_Win_create( winbuf, count*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-		    comm, &win );
+    MPI_Win_create(winbuf, count * sizeof(int), sizeof(int), MPI_INFO_NULL, comm, &win);
 
-    MPI_Comm_size( comm, &csize );
-    MPI_Comm_rank( comm, &crank );
-    dest   = 0;
+    MPI_Comm_size(comm, &csize);
+    MPI_Comm_rank(comm, &crank);
+    dest = 0;
     source = 1;
 
-    for (loop=0; loop<2; loop++) {
-	/* Perform several communication operations, mixing synchronization
-	   types.  Use multiple communication to avoid the single-operation
-	   optimization that may be present. */
-	MTestPrintfMsg( 3, "Beginning loop %d of mixed sync put operations\n", 
-			loop );	
-	MPI_Barrier( comm );
-	if (crank == source) {
-	    MTestPrintfMsg( 3, "About to perform exclusive lock\n" );
-	    MPI_Win_lock( MPI_LOCK_EXCLUSIVE, dest, 0, win );
-	    MPI_Put( buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, win );
-	    MPI_Put( buf1, count1, MPI_INT, dest, count0, count1, MPI_INT, 
-		     win );
-	    MPI_Put( buf2, count2, MPI_INT, dest, count0+count1, count2, 
-		     MPI_INT, win );
-	    MPI_Win_unlock( dest, win );
-	    MTestPrintfMsg( 3, "Released exclusive lock\n" );
-	}
-	else if (crank == dest) {
-	    /* Just delay a bit */
-	    delay( 0.0001 );
-	}
-
-	/* The synchronization mode can only be changed when the process 
-	   memory and public copy are guaranteed to have the same values 
-	   (See 11.7, Semantics and Correctness). This barrier ensures that 
-	   the lock/unlock completes before the fence call.  */
-	MPI_Barrier( comm );
-
-	MTestPrintfMsg( 3, "About to start fence\n" );
-	MPI_Win_fence( 0, win );
-	if (crank == source) {
-	    MPI_Put( buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, win );
-	    MPI_Put( buf1, count1, MPI_INT, dest, 1+count0, count1, MPI_INT, 
-		     win );
-	    MPI_Put( buf2, count2, MPI_INT, dest, 1+count0+count1, count2, 
-		     MPI_INT, win );
-	}
-	MPI_Win_fence( 0, win );
-	MTestPrintfMsg( 3, "Finished with fence sync\n" );
-
-	/* Check results */
-	if (crank == dest) {
-	    for (i=0; i<count0+count1+count2; i++) {
-		if (winbuf[1+i] != i) {
-		    errs++;
-		    if (errs < 10) {
-			fprintf( stderr, "winbuf[%d] = %d, expected %d\n",
-				 1+i, winbuf[1+i], i ); fflush(stderr);
-		    }
-		}
-	    }
-	}
-	
-	/* End of test loop */
+    for (loop = 0; loop < 2; loop++) {
+        /* Perform several communication operations, mixing synchronization
+         * types.  Use multiple communication to avoid the single-operation
+         * optimization that may be present. */
+        MTestPrintfMsg(3, "Beginning loop %d of mixed sync put operations\n", loop);
+        MPI_Barrier(comm);
+        if (crank == source) {
+            MTestPrintfMsg(3, "About to perform exclusive lock\n");
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, dest, 0, win);
+            MPI_Put(buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, win);
+            MPI_Put(buf1, count1, MPI_INT, dest, count0, count1, MPI_INT, win);
+            MPI_Put(buf2, count2, MPI_INT, dest, count0 + count1, count2, MPI_INT, win);
+            MPI_Win_unlock(dest, win);
+            MTestPrintfMsg(3, "Released exclusive lock\n");
+        }
+        else if (crank == dest) {
+            /* Just delay a bit */
+            delay(0.0001);
+        }
+
+        /* The synchronization mode can only be changed when the process
+         * memory and public copy are guaranteed to have the same values
+         * (See 11.7, Semantics and Correctness). This barrier ensures that
+         * the lock/unlock completes before the fence call.  */
+        MPI_Barrier(comm);
+
+        MTestPrintfMsg(3, "About to start fence\n");
+        MPI_Win_fence(0, win);
+        if (crank == source) {
+            MPI_Put(buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, win);
+            MPI_Put(buf1, count1, MPI_INT, dest, 1 + count0, count1, MPI_INT, win);
+            MPI_Put(buf2, count2, MPI_INT, dest, 1 + count0 + count1, count2, MPI_INT, win);
+        }
+        MPI_Win_fence(0, win);
+        MTestPrintfMsg(3, "Finished with fence sync\n");
+
+        /* Check results */
+        if (crank == dest) {
+            for (i = 0; i < count0 + count1 + count2; i++) {
+                if (winbuf[1 + i] != i) {
+                    errs++;
+                    if (errs < 10) {
+                        fprintf(stderr, "winbuf[%d] = %d, expected %d\n", 1 + i, winbuf[1 + i], i);
+                        fflush(stderr);
+                    }
+                }
+            }
+        }
+
+        /* End of test loop */
     }
 
     /* Use mixed put and accumulate */
-    for (loop=0; loop<2; loop++) {
-	/* Perform several communication operations, mixing synchronization
-	   types.  Use multiple communication to avoid the single-operation
-	   optimization that may be present. */
-	MTestPrintfMsg( 3, "Begining loop %d of mixed sync put/acc operations\n", 
-			loop );	
-	memset( winbuf, 0, count*sizeof(int) );
-	MPI_Barrier( comm );
-	if (crank == source) {
-	    MPI_Win_lock( MPI_LOCK_EXCLUSIVE, dest, 0, win );
-	    MPI_Accumulate( buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, 
-			    MPI_SUM, win );
-	    MPI_Accumulate( buf1, count1, MPI_INT, dest, count0, count1, 
-			    MPI_INT, MPI_SUM, win );
-	    MPI_Put( buf2, count2, MPI_INT, dest, count0+count1, count2, 
-		     MPI_INT, win );
-	    MPI_Win_unlock( dest, win );
-	}
-	else if (crank == dest) {
-	    /* Just delay a bit */
-	    delay( 0.0001 );
-	}
-	/* See above - the fence should not start until the unlock completes */
-	MPI_Barrier( comm );
-	MPI_Win_fence( 0, win );
-	if (crank == source) {
-	    MPI_Accumulate( buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, 
-			    MPI_REPLACE, win );
-	    MPI_Accumulate( buf1, count1, MPI_INT, dest, 1+count0, count1, 
-			    MPI_INT, MPI_REPLACE, win );
-	    MPI_Put( buf2, count2, MPI_INT, dest, 1+count0+count1, count2, 
-		     MPI_INT, win );
-	}
-	MPI_Win_fence( 0, win );
-
-	/* Check results */
-	if (crank == dest) {
-	    for (i=0; i<count0+count1+count2; i++) {
-		if (winbuf[1+i] != i) {
-		    errs++;
-		    if (errs < 10) {
-			fprintf( stderr, "winbuf[%d] = %d, expected %d\n",
-				 1+i, winbuf[1+i], i ); fflush(stderr);
-		    }
-		}
-	    }
-	}
-	
-	/* End of test loop */
+    for (loop = 0; loop < 2; loop++) {
+        /* Perform several communication operations, mixing synchronization
+         * types.  Use multiple communication to avoid the single-operation
+         * optimization that may be present. */
+        MTestPrintfMsg(3, "Begining loop %d of mixed sync put/acc operations\n", loop);
+        memset(winbuf, 0, count * sizeof(int));
+        MPI_Barrier(comm);
+        if (crank == source) {
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, dest, 0, win);
+            MPI_Accumulate(buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, MPI_SUM, win);
+            MPI_Accumulate(buf1, count1, MPI_INT, dest, count0, count1, MPI_INT, MPI_SUM, win);
+            MPI_Put(buf2, count2, MPI_INT, dest, count0 + count1, count2, MPI_INT, win);
+            MPI_Win_unlock(dest, win);
+        }
+        else if (crank == dest) {
+            /* Just delay a bit */
+            delay(0.0001);
+        }
+        /* See above - the fence should not start until the unlock completes */
+        MPI_Barrier(comm);
+        MPI_Win_fence(0, win);
+        if (crank == source) {
+            MPI_Accumulate(buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, MPI_REPLACE, win);
+            MPI_Accumulate(buf1, count1, MPI_INT, dest, 1 + count0, count1,
+                           MPI_INT, MPI_REPLACE, win);
+            MPI_Put(buf2, count2, MPI_INT, dest, 1 + count0 + count1, count2, MPI_INT, win);
+        }
+        MPI_Win_fence(0, win);
+
+        /* Check results */
+        if (crank == dest) {
+            for (i = 0; i < count0 + count1 + count2; i++) {
+                if (winbuf[1 + i] != i) {
+                    errs++;
+                    if (errs < 10) {
+                        fprintf(stderr, "winbuf[%d] = %d, expected %d\n", 1 + i, winbuf[1 + i], i);
+                        fflush(stderr);
+                    }
+                }
+            }
+        }
+
+        /* End of test loop */
     }
 
     /* Use mixed accumulate and get */
-    for (loop=0; loop<2; loop++) {
-	/* Perform several communication operations, mixing synchronization
-	   types.  Use multiple communication to avoid the single-operation
-	   optimization that may be present. */
-	MTestPrintfMsg( 3, "Begining loop %d of mixed sync put/get/acc operations\n", 
-			loop );	
-	MPI_Barrier( comm );
-	if (crank == source) {
-	    MPI_Win_lock( MPI_LOCK_EXCLUSIVE, dest, 0, win );
-	    MPI_Accumulate( buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, 
-			    MPI_REPLACE, win );
-	    MPI_Put( buf1, count1, MPI_INT, dest, count0, count1, MPI_INT, 
-		     win );
-	    MPI_Get( inbuf2, count2, MPI_INT, dest, count0+count1, count2, 
-		     MPI_INT, win );
-	    MPI_Win_unlock( dest, win );
-	}
-	else if (crank == dest) {
-	    /* Just delay a bit */
-	    delay( 0.0001 );
-	}
-	/* See above - the fence should not start until the unlock completes */
-	MPI_Barrier( comm );
-	MPI_Win_fence( 0, win );
-	if (crank == source) {
-	    MPI_Accumulate( buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, 
-			    MPI_REPLACE, win );
-	    MPI_Put( buf1, count1, MPI_INT, dest, 1+count0, count1, MPI_INT, 
-		     win );
-	    MPI_Get( inbuf2, count2, MPI_INT, dest, 1+count0+count1, count2, 
-		     MPI_INT, win );
-	}
-	MPI_Win_fence( 0, win );
-
-	/* Check results */
-	if (crank == dest) {
-	    /* Do the put/accumulate parts */
-	    for (i=0; i<count0+count1; i++) {
-		if (winbuf[1+i] != i) {
-		    errs++;
-		    if (errs < 10) {
-			fprintf( stderr, "winbuf[%d] = %d, expected %d\n",
-				 1+i, winbuf[1+i], i ); fflush(stderr);
-		    }
-		}
-	    }
-	}
-	
-	/* End of test loop */
+    for (loop = 0; loop < 2; loop++) {
+        /* Perform several communication operations, mixing synchronization
+         * types.  Use multiple communication to avoid the single-operation
+         * optimization that may be present. */
+        MTestPrintfMsg(3, "Begining loop %d of mixed sync put/get/acc operations\n", loop);
+        MPI_Barrier(comm);
+        if (crank == source) {
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, dest, 0, win);
+            MPI_Accumulate(buf0, count0, MPI_INT, dest, 0, count0, MPI_INT, MPI_REPLACE, win);
+            MPI_Put(buf1, count1, MPI_INT, dest, count0, count1, MPI_INT, win);
+            MPI_Get(inbuf2, count2, MPI_INT, dest, count0 + count1, count2, MPI_INT, win);
+            MPI_Win_unlock(dest, win);
+        }
+        else if (crank == dest) {
+            /* Just delay a bit */
+            delay(0.0001);
+        }
+        /* See above - the fence should not start until the unlock completes */
+        MPI_Barrier(comm);
+        MPI_Win_fence(0, win);
+        if (crank == source) {
+            MPI_Accumulate(buf0, count0, MPI_INT, dest, 1, count0, MPI_INT, MPI_REPLACE, win);
+            MPI_Put(buf1, count1, MPI_INT, dest, 1 + count0, count1, MPI_INT, win);
+            MPI_Get(inbuf2, count2, MPI_INT, dest, 1 + count0 + count1, count2, MPI_INT, win);
+        }
+        MPI_Win_fence(0, win);
+
+        /* Check results */
+        if (crank == dest) {
+            /* Do the put/accumulate parts */
+            for (i = 0; i < count0 + count1; i++) {
+                if (winbuf[1 + i] != i) {
+                    errs++;
+                    if (errs < 10) {
+                        fprintf(stderr, "winbuf[%d] = %d, expected %d\n", 1 + i, winbuf[1 + i], i);
+                        fflush(stderr);
+                    }
+                }
+            }
+        }
+
+        /* End of test loop */
     }
 
-    MTestPrintfMsg( 3, "Freeing the window\n" );
-    MPI_Barrier( comm );
-    MPI_Win_free( &win );
-    MPI_Free_mem( winbuf );
-    free( buf0 );
-    free( buf1 );
-    free( buf2 );
-    free( inbuf2 );
+    MTestPrintfMsg(3, "Freeing the window\n");
+    MPI_Barrier(comm);
+    MPI_Win_free(&win);
+    MPI_Free_mem(winbuf);
+    free(buf0);
+    free(buf1);
+    free(buf2);
+    free(inbuf2);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
 
     MPI_Finalize();
     return 0;