Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
This file was not supposed to be still manually privatized
authordegomme <augustin.degomme@unibas.ch>
Fri, 5 Feb 2016 14:54:18 +0000 (15:54 +0100)
committerdegomme <augustin.degomme@unibas.ch>
Fri, 5 Feb 2016 14:59:13 +0000 (15:59 +0100)
There its _manual version for this case (systems without automatic privatization support).

teshsuite/smpi/mpich3-test/coll/allgatherv4.c

index 65e73f5..d14e974 100644 (file)
@@ -4,7 +4,6 @@
  *  (C) 2003 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
  *  (C) 2003 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
-
 #include "mpi.h"
 #include "mpitest.h"
 #include <stdio.h>
 #include "mpi.h"
 #include "mpitest.h"
 #include <stdio.h>
 #include <time.h>
 #include <math.h>
 #include <assert.h>
 #include <time.h>
 #include <math.h>
 #include <assert.h>
-
 /* FIXME: What is this test supposed to accomplish? */
 /* FIXME: What is this test supposed to accomplish? */
-
 #define START_BUF (1)
 #define LARGE_BUF (256 * 1024)
 #define START_BUF (1)
 #define LARGE_BUF (256 * 1024)
-
 /* FIXME: MAX_BUF is too large */
 #define MAX_BUF   (32 * 1024 * 1024)
 #define LOOPS 10
 /* FIXME: MAX_BUF is too large */
 #define MAX_BUF   (32 * 1024 * 1024)
 #define LOOPS 10
-
-SMPI_VARINIT_GLOBAL(sbuf, char*);
-SMPI_VARINIT_GLOBAL(rbuf, char*);
-SMPI_VARINIT_GLOBAL(recvcounts, int*);
-SMPI_VARINIT_GLOBAL(displs, int*);
-SMPI_VARINIT_GLOBAL_AND_SET(errs, int, 0);
-
+char *sbuf, *rbuf;
+int *recvcounts, *displs;
+int errs = 0;
 /* #define dprintf printf */
 #define dprintf(...)
 /* #define dprintf printf */
 #define dprintf(...)
-
 typedef enum {
     REGULAR,
     BCAST,
 typedef enum {
     REGULAR,
     BCAST,
@@ -42,46 +33,43 @@ typedef enum {
     LINEAR_DECREASE,
     BELL_CURVE
 } test_t;
     LINEAR_DECREASE,
     BELL_CURVE
 } test_t;
-
 void comm_tests(MPI_Comm comm);
 void comm_tests(MPI_Comm comm);
-double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double * max_time);
-
-int main(int argc, char ** argv)
+double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double *max_time);
+int main(int argc, char **argv)
 {
     int comm_size, comm_rank;
     MPI_Comm comm;
 {
     int comm_size, comm_rank;
     MPI_Comm comm;
-
     MTest_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
     MTest_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
-
+    if (comm_size < 3) {
+        fprintf(stderr, "At least 3 processes required\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
     if (LARGE_BUF * comm_size > MAX_BUF)
         goto fn_exit;
     if (LARGE_BUF * comm_size > MAX_BUF)
         goto fn_exit;
-
-    SMPI_VARGET_GLOBAL(sbuf) = (void *) calloc(MAX_BUF, 1);
-    SMPI_VARGET_GLOBAL(rbuf) = (void *) calloc(MAX_BUF, 1);
-
+    sbuf = (void *) calloc(MAX_BUF, 1);
+    rbuf = (void *) calloc(MAX_BUF, 1);
     srand(time(NULL));
     srand(time(NULL));
-
-    SMPI_VARGET_GLOBAL(recvcounts) = (void *) malloc(comm_size * sizeof(int));
-    SMPI_VARGET_GLOBAL(displs) = (void *) malloc(comm_size * sizeof(int));
-    if (!SMPI_VARGET_GLOBAL(recvcounts) || !SMPI_VARGET_GLOBAL(displs) || !SMPI_VARGET_GLOBAL(sbuf) || !SMPI_VARGET_GLOBAL(rbuf)) {
+    recvcounts = (void *) malloc(comm_size * sizeof(int));
+    displs = (void *) malloc(comm_size * sizeof(int));
+    if (!recvcounts || !displs || !sbuf || !rbuf) {
         fprintf(stderr, "Unable to allocate memory:\n");
         fprintf(stderr, "Unable to allocate memory:\n");
-       if (!SMPI_VARGET_GLOBAL(sbuf)) fprintf(stderr,"\tsbuf of %d bytes\n", MAX_BUF );
-       if (!SMPI_VARGET_GLOBAL(rbuf)) fprintf(stderr,"\trbuf of %d bytes\n", MAX_BUF );
-       if (!SMPI_VARGET_GLOBAL(recvcounts)) fprintf(stderr,"\trecvcounts of %zd bytes\n", comm_size * sizeof(int) );
-       if (!SMPI_VARGET_GLOBAL(displs)) fprintf(stderr,"\tdispls of %zd bytes\n", comm_size * sizeof(int) );
+        if (!sbuf)
+            fprintf(stderr, "\tsbuf of %d bytes\n", MAX_BUF);
+        if (!rbuf)
+            fprintf(stderr, "\trbuf of %d bytes\n", MAX_BUF);
+        if (!recvcounts)
+            fprintf(stderr, "\trecvcounts of %zd bytes\n", comm_size * sizeof(int));
+        if (!displs)
+            fprintf(stderr, "\tdispls of %zd bytes\n", comm_size * sizeof(int));
         fflush(stderr);
         MPI_Abort(MPI_COMM_WORLD, -1);
         fflush(stderr);
         MPI_Abort(MPI_COMM_WORLD, -1);
-        exit(-1);
     }
     }
-
     if (!comm_rank) {
         dprintf("Message Range: (%d, %d); System size: %d\n", START_BUF, LARGE_BUF, comm_size);
         fflush(stdout);
     }
     if (!comm_rank) {
         dprintf("Message Range: (%d, %d); System size: %d\n", START_BUF, LARGE_BUF, comm_size);
         fflush(stdout);
     }
-
-
     /* COMM_WORLD tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
     /* COMM_WORLD tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
@@ -89,7 +77,6 @@ int main(int argc, char ** argv)
         dprintf("==========================================================\n");
     }
     comm_tests(MPI_COMM_WORLD);
         dprintf("==========================================================\n");
     }
     comm_tests(MPI_COMM_WORLD);
-
     /* non-COMM_WORLD tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
     /* non-COMM_WORLD tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
@@ -100,7 +87,6 @@ int main(int argc, char ** argv)
     if (comm_rank < comm_size - 1)
         comm_tests(comm);
     MPI_Comm_free(&comm);
     if (comm_rank < comm_size - 1)
         comm_tests(comm);
     MPI_Comm_free(&comm);
-
     /* Randomized communicator tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
     /* Randomized communicator tests */
     if (!comm_rank) {
         dprintf("\n\n==========================================================\n");
@@ -110,65 +96,52 @@ int main(int argc, char ** argv)
     MPI_Comm_split(MPI_COMM_WORLD, 0, rand(), &comm);
     comm_tests(comm);
     MPI_Comm_free(&comm);
     MPI_Comm_split(MPI_COMM_WORLD, 0, rand(), &comm);
     comm_tests(comm);
     MPI_Comm_free(&comm);
-
-    free(SMPI_VARGET_GLOBAL(sbuf));
-    free(SMPI_VARGET_GLOBAL(rbuf));
-    free(SMPI_VARGET_GLOBAL(recvcounts));
-    free(SMPI_VARGET_GLOBAL(displs));
-
-fn_exit:
-    MTest_Finalize(SMPI_VARGET_GLOBAL(errs));
+    free(sbuf);
+    free(rbuf);
+    free(recvcounts);
+    free(displs);
+  fn_exit:
+    MTest_Finalize(errs);
     MPI_Finalize();
     MPI_Finalize();
-
     return 0;
 }
     return 0;
 }
-
 void comm_tests(MPI_Comm comm)
 {
     int comm_size, comm_rank;
 void comm_tests(MPI_Comm comm)
 {
     int comm_size, comm_rank;
-    double rtime = rtime;       /* stop warning about unused variable */
-    double max_time;
+    double rtime, max_time;
     long long msg_size;
     long long msg_size;
-
     MPI_Comm_size(comm, &comm_size);
     MPI_Comm_rank(comm, &comm_rank);
     MPI_Comm_size(comm, &comm_size);
     MPI_Comm_rank(comm, &comm_rank);
-
     for (msg_size = START_BUF; msg_size <= LARGE_BUF; msg_size *= 2) {
         if (!comm_rank) {
             dprintf("\n====> MSG_SIZE: %d\n", (int) msg_size);
             fflush(stdout);
         }
     for (msg_size = START_BUF; msg_size <= LARGE_BUF; msg_size *= 2) {
         if (!comm_rank) {
             dprintf("\n====> MSG_SIZE: %d\n", (int) msg_size);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, REGULAR, &max_time);
         if (!comm_rank) {
             dprintf("REGULAR:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
         rtime = run_test(msg_size, comm, REGULAR, &max_time);
         if (!comm_rank) {
             dprintf("REGULAR:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, BCAST, &max_time);
         if (!comm_rank) {
             dprintf("BCAST:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
         rtime = run_test(msg_size, comm, BCAST, &max_time);
         if (!comm_rank) {
             dprintf("BCAST:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, SPIKE, &max_time);
         if (!comm_rank) {
             dprintf("SPIKE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
         rtime = run_test(msg_size, comm, SPIKE, &max_time);
         if (!comm_rank) {
             dprintf("SPIKE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, HALF_FULL, &max_time);
         if (!comm_rank) {
             dprintf("HALF_FULL:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
         rtime = run_test(msg_size, comm, HALF_FULL, &max_time);
         if (!comm_rank) {
             dprintf("HALF_FULL:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, LINEAR_DECREASE, &max_time);
         if (!comm_rank) {
             dprintf("LINEAR_DECREASE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
         rtime = run_test(msg_size, comm, LINEAR_DECREASE, &max_time);
         if (!comm_rank) {
             dprintf("LINEAR_DECREASE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
             fflush(stdout);
         }
-
         rtime = run_test(msg_size, comm, BELL_CURVE, &max_time);
         if (!comm_rank) {
             dprintf("BELL_CURVE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
         rtime = run_test(msg_size, comm, BELL_CURVE, &max_time);
         if (!comm_rank) {
             dprintf("BELL_CURVE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
@@ -176,75 +149,67 @@ void comm_tests(MPI_Comm comm)
         }
     }
 }
         }
     }
 }
-
-double run_test(long long msg_size, MPI_Comm comm, test_t test_type, 
-               double * max_time)
+double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double *max_time)
 {
     int i, j;
     int comm_size, comm_rank;
     double start, end;
     double total_time, avg_time;
     MPI_Aint tmp;
 {
     int i, j;
     int comm_size, comm_rank;
     double start, end;
     double total_time, avg_time;
     MPI_Aint tmp;
-
     MPI_Comm_size(comm, &comm_size);
     MPI_Comm_rank(comm, &comm_rank);
     MPI_Comm_size(comm, &comm_size);
     MPI_Comm_rank(comm, &comm_rank);
-
-    SMPI_VARGET_GLOBAL(displs)[0] = 0;
+    displs[0] = 0;
     for (i = 0; i < comm_size; i++) {
         if (test_type == REGULAR)
     for (i = 0; i < comm_size; i++) {
         if (test_type == REGULAR)
-            SMPI_VARGET_GLOBAL(recvcounts)[i] = msg_size;
+            recvcounts[i] = msg_size;
         else if (test_type == BCAST)
         else if (test_type == BCAST)
-            SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? msg_size : 0;
+            recvcounts[i] = (!i) ? msg_size : 0;
         else if (test_type == SPIKE)
         else if (test_type == SPIKE)
-            SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1)));
+            recvcounts[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1)));
         else if (test_type == HALF_FULL)
         else if (test_type == HALF_FULL)
-            SMPI_VARGET_GLOBAL(recvcounts)[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0;
+            recvcounts[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0;
         else if (test_type == LINEAR_DECREASE) {
             tmp = 2 * msg_size * (comm_size - 1 - i) / (comm_size - 1);
         else if (test_type == LINEAR_DECREASE) {
             tmp = 2 * msg_size * (comm_size - 1 - i) / (comm_size - 1);
-           if (tmp != (int)tmp) {
-               fprintf( stderr, "Integer overflow in variable tmp\n" );
-               MPI_Abort( MPI_COMM_WORLD, 1 );
-                exit(1);
-           }
-            SMPI_VARGET_GLOBAL(recvcounts)[i] = (int) tmp;
-
+            if (tmp != (int) tmp) {
+                fprintf(stderr, "Integer overflow in variable tmp\n");
+                MPI_Abort(MPI_COMM_WORLD, 1);
+            }
+            recvcounts[i] = (int) tmp;
             /* If the maximum message size is too large, don't run */
             /* If the maximum message size is too large, don't run */
-            if (tmp > MAX_BUF) return 0;
+            if (tmp > MAX_BUF)
+                return 0;
         }
         else if (test_type == BELL_CURVE) {
             for (j = 0; j < i; j++) {
         }
         else if (test_type == BELL_CURVE) {
             for (j = 0; j < i; j++) {
-                if (i - 1 + j >= comm_size) continue;
+                if (i - 1 + j >= comm_size)
+                    continue;
                 tmp = msg_size * comm_size / (log(comm_size) * i);
                 tmp = msg_size * comm_size / (log(comm_size) * i);
-                SMPI_VARGET_GLOBAL(recvcounts)[i - 1 + j] = (int) tmp;
-                SMPI_VARGET_GLOBAL(displs)[i - 1 + j] = 0;
-
+                recvcounts[i - 1 + j] = (int) tmp;
+                displs[i - 1 + j] = 0;
                 /* If the maximum message size is too large, don't run */
                 /* If the maximum message size is too large, don't run */
-                if (tmp > MAX_BUF) return 0;
+                if (tmp > MAX_BUF)
+                    return 0;
             }
         }
             }
         }
-
         if (i < comm_size - 1)
         if (i < comm_size - 1)
-            SMPI_VARGET_GLOBAL(displs)[i+1] = SMPI_VARGET_GLOBAL(displs)[i] + SMPI_VARGET_GLOBAL(recvcounts)[i];
+            displs[i + 1] = displs[i] + recvcounts[i];
     }
     }
-
     /* Test that:
     /* Test that:
-       1: sbuf is large enough
-       2: rbuf is large enough
-       3: There were no failures (e.g., tmp nowhere > rbuf size 
-    */
+     * 1: sbuf is large enough
+     * 2: rbuf is large enough
+     * 3: There were no failures (e.g., tmp nowhere > rbuf size
+     */
     MPI_Barrier(comm);
     start = MPI_Wtime();
     for (i = 0; i < LOOPS; i++) {
     MPI_Barrier(comm);
     start = MPI_Wtime();
     for (i = 0; i < LOOPS; i++) {
-        MPI_Allgatherv(SMPI_VARGET_GLOBAL(sbuf), SMPI_VARGET_GLOBAL(recvcounts)[comm_rank], MPI_CHAR,
-                       SMPI_VARGET_GLOBAL(rbuf), SMPI_VARGET_GLOBAL(recvcounts), SMPI_VARGET_GLOBAL(displs), MPI_CHAR, comm);
+        MPI_Allgatherv(sbuf, recvcounts[comm_rank], MPI_CHAR,
+                       rbuf, recvcounts, displs, MPI_CHAR, comm);
     }
     end = MPI_Wtime();
     MPI_Barrier(comm);
     }
     end = MPI_Wtime();
     MPI_Barrier(comm);
-
     /* Convert to microseconds (why?) */
     total_time = 1.0e6 * (end - start);
     MPI_Reduce(&total_time, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0, comm);
     MPI_Reduce(&total_time, max_time, 1, MPI_DOUBLE, MPI_MAX, 0, comm);
     /* Convert to microseconds (why?) */
     total_time = 1.0e6 * (end - start);
     MPI_Reduce(&total_time, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0, comm);
     MPI_Reduce(&total_time, max_time, 1, MPI_DOUBLE, MPI_MAX, 0, comm);
-
     return (avg_time / (LOOPS * comm_size));
 }
     return (avg_time / (LOOPS * comm_size));
 }