Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
This file was not supposed to be still manually privatized
[simgrid.git] / teshsuite / smpi / mpich3-test / coll / allgatherv4.c
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 /*
3  *
4  *  (C) 2003 by Argonne National Laboratory.
5  *      See COPYRIGHT in top-level directory.
6  */
7 #include "mpi.h"
8 #include "mpitest.h"
9 #include <stdio.h>
10 #include <stdlib.h>
11 #ifdef HAVE_SYS_TIME_H
12 #include <sys/time.h>
13 #endif
14 #include <time.h>
15 #include <math.h>
16 #include <assert.h>
17 /* FIXME: What is this test supposed to accomplish? */
18 #define START_BUF (1)
19 #define LARGE_BUF (256 * 1024)
20 /* FIXME: MAX_BUF is too large */
21 #define MAX_BUF   (32 * 1024 * 1024)
22 #define LOOPS 10
23 char *sbuf, *rbuf;
24 int *recvcounts, *displs;
25 int errs = 0;
26 /* #define dprintf printf */
27 #define dprintf(...)
28 typedef enum {
29     REGULAR,
30     BCAST,
31     SPIKE,
32     HALF_FULL,
33     LINEAR_DECREASE,
34     BELL_CURVE
35 } test_t;
36 void comm_tests(MPI_Comm comm);
37 double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double *max_time);
38 int main(int argc, char **argv)
39 {
40     int comm_size, comm_rank;
41     MPI_Comm comm;
42     MTest_Init(&argc, &argv);
43     MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
44     MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
45     if (comm_size < 3) {
46         fprintf(stderr, "At least 3 processes required\n");
47         MPI_Abort(MPI_COMM_WORLD, 1);
48     }
49     if (LARGE_BUF * comm_size > MAX_BUF)
50         goto fn_exit;
51     sbuf = (void *) calloc(MAX_BUF, 1);
52     rbuf = (void *) calloc(MAX_BUF, 1);
53     srand(time(NULL));
54     recvcounts = (void *) malloc(comm_size * sizeof(int));
55     displs = (void *) malloc(comm_size * sizeof(int));
56     if (!recvcounts || !displs || !sbuf || !rbuf) {
57         fprintf(stderr, "Unable to allocate memory:\n");
58         if (!sbuf)
59             fprintf(stderr, "\tsbuf of %d bytes\n", MAX_BUF);
60         if (!rbuf)
61             fprintf(stderr, "\trbuf of %d bytes\n", MAX_BUF);
62         if (!recvcounts)
63             fprintf(stderr, "\trecvcounts of %zd bytes\n", comm_size * sizeof(int));
64         if (!displs)
65             fprintf(stderr, "\tdispls of %zd bytes\n", comm_size * sizeof(int));
66         fflush(stderr);
67         MPI_Abort(MPI_COMM_WORLD, -1);
68     }
69     if (!comm_rank) {
70         dprintf("Message Range: (%d, %d); System size: %d\n", START_BUF, LARGE_BUF, comm_size);
71         fflush(stdout);
72     }
73     /* COMM_WORLD tests */
74     if (!comm_rank) {
75         dprintf("\n\n==========================================================\n");
76         dprintf("                         MPI_COMM_WORLD\n");
77         dprintf("==========================================================\n");
78     }
79     comm_tests(MPI_COMM_WORLD);
80     /* non-COMM_WORLD tests */
81     if (!comm_rank) {
82         dprintf("\n\n==========================================================\n");
83         dprintf("                         non-COMM_WORLD\n");
84         dprintf("==========================================================\n");
85     }
86     MPI_Comm_split(MPI_COMM_WORLD, (comm_rank == comm_size - 1) ? 0 : 1, 0, &comm);
87     if (comm_rank < comm_size - 1)
88         comm_tests(comm);
89     MPI_Comm_free(&comm);
90     /* Randomized communicator tests */
91     if (!comm_rank) {
92         dprintf("\n\n==========================================================\n");
93         dprintf("                         Randomized Communicator\n");
94         dprintf("==========================================================\n");
95     }
96     MPI_Comm_split(MPI_COMM_WORLD, 0, rand(), &comm);
97     comm_tests(comm);
98     MPI_Comm_free(&comm);
99     free(sbuf);
100     free(rbuf);
101     free(recvcounts);
102     free(displs);
103   fn_exit:
104     MTest_Finalize(errs);
105     MPI_Finalize();
106     return 0;
107 }
108 void comm_tests(MPI_Comm comm)
109 {
110     int comm_size, comm_rank;
111     double rtime, max_time;
112     long long msg_size;
113     MPI_Comm_size(comm, &comm_size);
114     MPI_Comm_rank(comm, &comm_rank);
115     for (msg_size = START_BUF; msg_size <= LARGE_BUF; msg_size *= 2) {
116         if (!comm_rank) {
117             dprintf("\n====> MSG_SIZE: %d\n", (int) msg_size);
118             fflush(stdout);
119         }
120         rtime = run_test(msg_size, comm, REGULAR, &max_time);
121         if (!comm_rank) {
122             dprintf("REGULAR:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
123             fflush(stdout);
124         }
125         rtime = run_test(msg_size, comm, BCAST, &max_time);
126         if (!comm_rank) {
127             dprintf("BCAST:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
128             fflush(stdout);
129         }
130         rtime = run_test(msg_size, comm, SPIKE, &max_time);
131         if (!comm_rank) {
132             dprintf("SPIKE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
133             fflush(stdout);
134         }
135         rtime = run_test(msg_size, comm, HALF_FULL, &max_time);
136         if (!comm_rank) {
137             dprintf("HALF_FULL:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
138             fflush(stdout);
139         }
140         rtime = run_test(msg_size, comm, LINEAR_DECREASE, &max_time);
141         if (!comm_rank) {
142             dprintf("LINEAR_DECREASE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
143             fflush(stdout);
144         }
145         rtime = run_test(msg_size, comm, BELL_CURVE, &max_time);
146         if (!comm_rank) {
147             dprintf("BELL_CURVE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time);
148             fflush(stdout);
149         }
150     }
151 }
152 double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double *max_time)
153 {
154     int i, j;
155     int comm_size, comm_rank;
156     double start, end;
157     double total_time, avg_time;
158     MPI_Aint tmp;
159     MPI_Comm_size(comm, &comm_size);
160     MPI_Comm_rank(comm, &comm_rank);
161     displs[0] = 0;
162     for (i = 0; i < comm_size; i++) {
163         if (test_type == REGULAR)
164             recvcounts[i] = msg_size;
165         else if (test_type == BCAST)
166             recvcounts[i] = (!i) ? msg_size : 0;
167         else if (test_type == SPIKE)
168             recvcounts[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1)));
169         else if (test_type == HALF_FULL)
170             recvcounts[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0;
171         else if (test_type == LINEAR_DECREASE) {
172             tmp = 2 * msg_size * (comm_size - 1 - i) / (comm_size - 1);
173             if (tmp != (int) tmp) {
174                 fprintf(stderr, "Integer overflow in variable tmp\n");
175                 MPI_Abort(MPI_COMM_WORLD, 1);
176             }
177             recvcounts[i] = (int) tmp;
178             /* If the maximum message size is too large, don't run */
179             if (tmp > MAX_BUF)
180                 return 0;
181         }
182         else if (test_type == BELL_CURVE) {
183             for (j = 0; j < i; j++) {
184                 if (i - 1 + j >= comm_size)
185                     continue;
186                 tmp = msg_size * comm_size / (log(comm_size) * i);
187                 recvcounts[i - 1 + j] = (int) tmp;
188                 displs[i - 1 + j] = 0;
189                 /* If the maximum message size is too large, don't run */
190                 if (tmp > MAX_BUF)
191                     return 0;
192             }
193         }
194         if (i < comm_size - 1)
195             displs[i + 1] = displs[i] + recvcounts[i];
196     }
197     /* Test that:
198      * 1: sbuf is large enough
199      * 2: rbuf is large enough
200      * 3: There were no failures (e.g., tmp nowhere > rbuf size
201      */
202     MPI_Barrier(comm);
203     start = MPI_Wtime();
204     for (i = 0; i < LOOPS; i++) {
205         MPI_Allgatherv(sbuf, recvcounts[comm_rank], MPI_CHAR,
206                        rbuf, recvcounts, displs, MPI_CHAR, comm);
207     }
208     end = MPI_Wtime();
209     MPI_Barrier(comm);
210     /* Convert to microseconds (why?) */
211     total_time = 1.0e6 * (end - start);
212     MPI_Reduce(&total_time, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0, comm);
213     MPI_Reduce(&total_time, max_time, 1, MPI_DOUBLE, MPI_MAX, 0, comm);
214     return (avg_time / (LOOPS * comm_size));
215 }