kill all trailling whitespaces

[simgrid.git] / teshsuite / smpi / isp / umpire / collective-exhaustive-no-error.c

diff --git a/teshsuite/smpi/isp/umpire/collective-exhaustive-no-error.c b/teshsuite/smpi/isp/umpire/collective-exhaustive-no-error.c
index 1e53e14..98fcd9f 100644 (file)
--- a/teshsuite/smpi/isp/umpire/collective-exhaustive-no-error.c
+++ b/teshsuite/smpi/isp/umpire/collective-exhaustive-no-error.c
@@ -65,7 +65,7 @@ complex_prod (void *inp, void *inoutp, int *len, MPI_Datatype *dptr)
     c.real = inout->real * in->real - inout->imag * in->imag;
     c.imag = inout->real * in->imag + inout->imag * in->real;
     *inout = c;
-    in++; 
+    in++;
     inout++;
   }
 
@@ -99,7 +99,7 @@ main (int argc, char **argv)
 
   buf0 = (int *) malloc (buf_size * nprocs * sizeof(int));
   assert (buf0);
-  for (i = 0; i < buf_size * nprocs; i++) 
+  for (i = 0; i < buf_size * nprocs; i++)
     buf0[i] = rank;
 
 #ifdef RUN_ALLTOALLV
@@ -128,7 +128,7 @@ main (int argc, char **argv)
   if (rank == 0) {
     buf1 = (int *) malloc (buf_size * nprocs * sizeof(int));
     assert (buf1);
-    for (i = 0; i < buf_size * nprocs; i++) 
+    for (i = 0; i < buf_size * nprocs; i++)
       buf1[i] = i;
 
     displs = (int *) malloc (nprocs * sizeof(int));
@@ -149,93 +149,93 @@ main (int argc, char **argv)
   }
 
 #ifdef RUN_BARRIER
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Barrier (comm);
 #endif
 
 #ifdef RUN_BCAST
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Bcast (buf0, buf_size, MPI_INT, 0, comm);
 #endif
 
 #ifdef RUN_GATHER
-  for (i = 0; i < OP_COUNT; i++) 
-    MPI_Gather (&buf0[rank*buf_size], buf_size, 
+  for (i = 0; i < OP_COUNT; i++)
+    MPI_Gather (&buf0[rank*buf_size], buf_size,
                MPI_INT, buf1, buf_size, MPI_INT, 0, comm);
 #endif
 
 #ifdef RUN_SCATTER
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scatter (buf1, buf_size, MPI_INT, buf0, buf_size, MPI_INT, 0, comm);
 #endif
 
 #ifdef RUN_GATHERV
-  for (i = 0; i < OP_COUNT; i++) 
-    MPI_Gatherv (&buf0[rank*buf_size], 
-                (rank < buf_size) ? rank : buf_size, 
+  for (i = 0; i < OP_COUNT; i++)
+    MPI_Gatherv (&buf0[rank*buf_size],
+                (rank < buf_size) ? rank : buf_size,
                 MPI_INT, buf1, rcounts, displs, MPI_INT, 0, comm);
 #endif
 
 #ifdef RUN_SCATTERV
-  for (i = 0; i < OP_COUNT; i++) 
-    MPI_Scatterv (buf1, counts, displs, MPI_INT, buf0, 
+  for (i = 0; i < OP_COUNT; i++)
+    MPI_Scatterv (buf1, counts, displs, MPI_INT, buf0,
                  (rank < buf_size) ? rank : buf_size, MPI_INT, 0, comm);
 #endif
 
 #ifdef RUN_REDUCE
 #ifdef RUN_MAX
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_MAX, 0, comm);
 #endif
 
 #ifdef RUN_MIN
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_MIN, 0, comm);
 #endif
 
 #ifdef RUN_SUM
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_SUM, 0, comm);
 #endif
 
 #ifdef RUN_PROD
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_PROD, 0, comm);
 #endif
 
 #ifdef RUN_LAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_LAND, 0, comm);
 #endif
 
 #ifdef RUN_BAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_BAND, 0, comm);
 #endif
 
 #ifdef RUN_LOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_LOR, 0, comm);
 #endif
 
 #ifdef RUN_BOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_BOR, 0, comm);
 #endif
 
 #ifdef RUN_LXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_LXOR, 0, comm);
 #endif
 
 #ifdef RUN_BXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (buf0, buf1, buf_size, MPI_INT, MPI_BXOR, 0, comm);
 #endif
 
 #ifdef RUN_MAXLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Reduce (buf0, buf1, buf_size, MPI_2INT, MPI_MAXLOC, 0, comm);
   else
     fprintf (stderr, "Not enough tasks for MAXLOC test\n");
@@ -243,14 +243,14 @@ main (int argc, char **argv)
 
 #ifdef RUN_MINLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Reduce (buf0, buf1, buf_size, MPI_2INT, MPI_MINLOC, 0, comm);
   else
     fprintf (stderr, "Not enough tasks for MINLOC test\n");
 #endif
 
 #ifdef RUN_USEROP
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce (a, answer, buf_size, ctype, user_op, 0, comm);
 #endif
 #endif
@@ -258,7 +258,7 @@ main (int argc, char **argv)
   if (rank != 0) {
     buf1 = (int *) malloc (buf_size * nprocs * sizeof(int));
     assert (buf1);
-    for (i = 0; i < buf_size * nprocs; i++) 
+    for (i = 0; i < buf_size * nprocs; i++)
       buf1[i] = i;
 
     displs = (int *) malloc (nprocs * sizeof(int));
@@ -279,82 +279,82 @@ main (int argc, char **argv)
   }
 
 #ifdef RUN_ALLGATHER
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allgather (buf0, buf_size, MPI_INT, buf1, buf_size, MPI_INT, comm);
 #endif
 
 #ifdef RUN_ALLTOALL
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Alltoall (buf1, buf_size, MPI_INT, buf0, buf_size, MPI_INT, comm);
 #endif
 
 #ifdef RUN_ALLGATHERV
-  for (i = 0; i < OP_COUNT; i++) 
-    MPI_Allgatherv (buf0, 
-                   (rank < buf_size) ? rank : buf_size, 
+  for (i = 0; i < OP_COUNT; i++)
+    MPI_Allgatherv (buf0,
+                   (rank < buf_size) ? rank : buf_size,
                    MPI_INT, buf1, rcounts, displs, MPI_INT, comm);
 #endif
 
 #ifdef RUN_ALLTOALLV
-  for (i = 0; i < OP_COUNT; i++) 
-    MPI_Alltoallv (buf1, alltoallvcounts, displs, MPI_INT, 
+  for (i = 0; i < OP_COUNT; i++)
+    MPI_Alltoallv (buf1, alltoallvcounts, displs, MPI_INT,
                   buf0, alltoallvcounts, displs, MPI_INT, comm);
 #endif
 
 #ifdef RUN_ALLREDUCE
 #ifdef RUN_MAX
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_MAX, comm);
 #endif
 
 #ifdef RUN_MIN
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_MIN, comm);
 #endif
 
 #ifdef RUN_SUM
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_SUM, comm);
 #endif
 
 #ifdef RUN_PROD
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_PROD, comm);
 #endif
 
 #ifdef RUN_LAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_LAND, comm);
 #endif
 
 #ifdef RUN_BAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_BAND, comm);
 #endif
 
 #ifdef RUN_LOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_LOR, comm);
 #endif
 
 #ifdef RUN_BOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_BOR, comm);
 #endif
 
 #ifdef RUN_LXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_LXOR, comm);
 #endif
 
 #ifdef RUN_BXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (buf0, buf1, buf_size, MPI_INT, MPI_BXOR, comm);
 #endif
 
 #ifdef RUN_MAXLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Allreduce (buf0, buf1, buf_size, MPI_2INT, MPI_MAXLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MAXLOC test\n");
@@ -362,72 +362,72 @@ main (int argc, char **argv)
 
 #ifdef RUN_MINLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Allreduce (buf0, buf1, buf_size, MPI_2INT, MPI_MINLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MINLOC test\n");
 #endif
 
 #ifdef RUN_USEROP
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Allreduce (a, answer, buf_size, ctype, user_op, comm);
 #endif
 #endif
 
 #ifdef RUN_REDUCE_SCATTER
 #ifdef RUN_MAX
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_MAX, comm);
 #endif
 
 #ifdef RUN_MIN
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_MIN, comm);
 #endif
 
 #ifdef RUN_SUM
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_SUM, comm);
 #endif
 
 #ifdef RUN_PROD
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_PROD, comm);
 #endif
 
 #ifdef RUN_LAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_LAND, comm);
 #endif
 
 #ifdef RUN_BAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_BAND, comm);
 #endif
 
 #ifdef RUN_LOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_LOR, comm);
 #endif
 
 #ifdef RUN_BOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_BOR, comm);
 #endif
 
 #ifdef RUN_LXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_LXOR, comm);
 #endif
 
 #ifdef RUN_BXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_INT, MPI_BXOR, comm);
 #endif
 
 #ifdef RUN_MAXLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_2INT, MPI_MAXLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MAXLOC test\n");
@@ -435,72 +435,72 @@ main (int argc, char **argv)
 
 #ifdef RUN_MINLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Reduce_scatter (buf0, buf1, rcounts, MPI_2INT, MPI_MINLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MINLOC test\n");
 #endif
 
 #ifdef RUN_USEROP
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Reduce_scatter (a, answer, rcounts, ctype, user_op, comm);
 #endif
 #endif
 
 #ifdef RUN_SCAN
 #ifdef RUN_MAX
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_MAX, comm);
 #endif
 
 #ifdef RUN_MIN
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_MIN, comm);
 #endif
 
 #ifdef RUN_SUM
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_SUM, comm);
 #endif
 
 #ifdef RUN_PROD
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_PROD, comm);
 #endif
 
 #ifdef RUN_LAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_LAND, comm);
 #endif
 
 #ifdef RUN_BAND
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_BAND, comm);
 #endif
 
 #ifdef RUN_LOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_LOR, comm);
 #endif
 
 #ifdef RUN_BOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_BOR, comm);
 #endif
 
 #ifdef RUN_LXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_LXOR, comm);
 #endif
 
 #ifdef RUN_BXOR
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (buf0, buf1, buf_size, MPI_INT, MPI_BXOR, comm);
 #endif
 
 #ifdef RUN_MAXLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Scan (buf0, buf1, buf_size, MPI_2INT, MPI_MAXLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MAXLOC test\n");
@@ -508,14 +508,14 @@ main (int argc, char **argv)
 
 #ifdef RUN_MINLOC
   if (nprocs > 1)
-    for (i = 0; i < OP_COUNT; i++) 
+    for (i = 0; i < OP_COUNT; i++)
       MPI_Scan (buf0, buf1, buf_size, MPI_2INT, MPI_MINLOC, comm);
   else
     fprintf (stderr, "Not enough tasks for MINLOC test\n");
 #endif
 
 #ifdef RUN_USEROP
-  for (i = 0; i < OP_COUNT; i++) 
+  for (i = 0; i < OP_COUNT; i++)
     MPI_Scan (a, answer, buf_size, ctype, user_op, comm);
 #endif
 #endif