Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
4d4c39a233d5eb272674f67db48a7c5182309e78
[simgrid.git] / teshsuite / smpi / mpich3-test / datatype / hindexed-zeros.c
1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 /*
3  *  (C) 2001 by Argonne National Laboratory.
4  *      See COPYRIGHT in top-level directory.
5  */
6 #include <math.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include "mpi.h"
11
12 static int verbose = 0;
13
14 int main(int argc, char *argv[]);
15 int parse_args(int argc, char **argv);
16 int hindexed_zerotype_test(void);
17 int hindexed_sparsetype_test(void);
18
19 struct test_struct_1 {
20     int a,b,c,d;
21 };
22
23 int main(int argc, char *argv[])
24 {
25     int err, errs = 0;
26
27     /* Initialize MPI */
28     MPI_Init(&argc, &argv);
29     parse_args(argc, argv);
30
31     /* To improve reporting of problems about operations, we
32        change the error handler to errors return */
33     MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
34
35     err = hindexed_zerotype_test();
36     if (verbose && err) fprintf(stderr, "error in hindexed_zerotype_test\n");
37     errs += err;
38
39     err = hindexed_sparsetype_test();
40     if (verbose && err) fprintf(stderr, "error in hindexed_sparsetype_test\n");
41     errs += err;
42
43     /* print message and exit */
44     if (errs) {
45         fprintf(stderr, "Found %d errors\n", errs);
46     }
47     else {
48         printf(" No Errors\n");
49     }
50     MPI_Finalize();
51     return 0;
52 }
53
54 /* tests with an hindexed type with all zero length blocks */
55 int hindexed_zerotype_test(void)
56 {
57     int err, errs = 0;
58     int count, elements;
59     MPI_Datatype mytype;
60     MPI_Request request;
61     MPI_Status status;
62
63     int blks[]       = { 0, 0, 0 };
64     MPI_Aint disps[] = { 0, 4, 16 };
65
66     err = MPI_Type_hindexed(3, blks, disps, MPI_INT, &mytype);
67     if (err != MPI_SUCCESS) {
68         errs++;
69         if (verbose) {
70             fprintf(stderr, "MPI_Type_hindexed returned error\n");
71         }
72     }
73
74     MPI_Type_commit(&mytype);
75
76     err = MPI_Irecv(NULL, 2, mytype, 0, 0, MPI_COMM_SELF, &request);
77     if (err != MPI_SUCCESS) {
78         errs++;
79         if (verbose) {
80             fprintf(stderr, "MPI_Irecv returned error\n");
81         }
82     }
83
84     err = MPI_Send(NULL, 1, mytype, 0, 0, MPI_COMM_SELF);
85     if (err != MPI_SUCCESS) {
86         errs++;
87         if (verbose) {
88             fprintf(stderr, "MPI_Send returned error\n");
89         }
90     }
91
92     err = MPI_Wait(&request, &status);
93     if (err != MPI_SUCCESS) {
94         errs++;
95         if (verbose) {
96             fprintf(stderr, "MPI_Wait returned error\n");
97         }
98     }
99
100     /* verify count and elements */
101     err = MPI_Get_count(&status, mytype, &count);
102     if (err != MPI_SUCCESS) {
103         errs++;
104         if (verbose) {
105             fprintf(stderr, "MPI_Get_count returned error\n");
106         }
107     }
108     if (count != 0) {
109         errs++;
110         if (verbose) {
111             fprintf(stderr, "count = %d; should be 0\n", count);
112         }
113     }
114
115     err = MPI_Get_elements(&status, mytype, &elements);
116     if (err != MPI_SUCCESS) {
117         errs++;
118         if (verbose) {
119             fprintf(stderr, "MPI_Get_elements returned error\n");
120         }
121     }
122     if (elements != 0) {
123         errs++;
124         if (verbose) {
125             fprintf(stderr, "elements = %d; should be 0\n", elements);
126         }
127     }
128
129    // MPI_Type_free(&mytype);
130
131     return errs;
132 }
133
134 /* tests a short receive into a sparse hindexed type with a zero
135  * length block in it.  sort of eccentric, but we've got the basic
136  * stuff covered with other tests.
137  */
138 int hindexed_sparsetype_test(void)
139 {
140     int err, errs = 0;
141     int i, count, elements;
142     MPI_Datatype mytype;
143     MPI_Request request;
144     MPI_Status status;
145
146     int sendbuf[6]   = { 1, 2, 3, 4, 5, 6 };
147     int recvbuf[16];
148     int correct[16] = { 1, -2, 4, -4, 2, 3, 5, -8, -9, -10, 6,
149                         -12, -13, -14, -15, -16 };
150
151     int blks[]       = { 1, 0,             2,             1 };
152     MPI_Aint disps[] = { 0, 1*sizeof(int), 4*sizeof(int), 2*sizeof(int) };
153
154     err = MPI_Type_hindexed(4, blks, disps, MPI_INT, &mytype);
155     if (err != MPI_SUCCESS) {
156         errs++;
157         if (verbose) {
158             fprintf(stderr, "MPI_Type_hindexed returned error\n");
159         }
160     }
161
162     MPI_Type_commit(&mytype);
163
164     for (i=0; i < 16; i++) recvbuf[i] = -(i+1);
165
166     err = MPI_Irecv(recvbuf, 2, mytype, 0, 0, MPI_COMM_SELF, &request);
167     if (err != MPI_SUCCESS) {
168         errs++;
169         if (verbose) {
170             fprintf(stderr, "MPI_Irecv returned error\n");
171         }
172     }
173
174     err = MPI_Send(sendbuf, 6, MPI_INT, 0, 0, MPI_COMM_SELF);
175     if (err != MPI_SUCCESS) {
176         errs++;
177         if (verbose) {
178             fprintf(stderr, "MPI_Send returned error\n");
179         }
180     }
181
182     err = MPI_Wait(&request, &status);
183     if (err != MPI_SUCCESS) {
184         errs++;
185         if (verbose) {
186             fprintf(stderr, "MPI_Wait returned error\n");
187         }
188     }
189  
190     /* verify data */
191     for (i=0; i < 16; i++) {
192         if (recvbuf[i] != correct[i]) {
193             errs++;
194             if (verbose) {
195                 fprintf(stderr, "recvbuf[%d] = %d; should be %d\n",
196                         i, recvbuf[i], correct[i]);
197             }
198         }
199     }
200
201     /* verify count and elements */
202     err = MPI_Get_count(&status, mytype, &count);
203     if (err != MPI_SUCCESS) {
204         errs++;
205         if (verbose) {
206             fprintf(stderr, "MPI_Get_count returned error\n");
207         }
208     }
209     if (count != MPI_UNDEFINED) {
210         errs++;
211         if (verbose) {
212             fprintf(stderr, "count = %d; should be MPI_UNDEFINED (%d)\n",
213                     count, MPI_UNDEFINED);
214         }
215     }
216
217     err = MPI_Get_elements(&status, mytype, &elements);
218     if (err != MPI_SUCCESS) {
219         errs++;
220         if (verbose) {
221             fprintf(stderr, "MPI_Get_elements returned error\n");
222         }
223     }
224     if (elements != 6) {
225         errs++;
226         if (verbose) {
227             fprintf(stderr, "elements = %d; should be 6\n", elements);
228         }
229     }
230
231 //    MPI_Type_free(&mytype);
232
233     return errs;
234 }
235
236
237 int parse_args(int argc, char **argv)
238 {
239     /*
240     int ret;
241
242     while ((ret = getopt(argc, argv, "v")) >= 0)
243     {
244         switch (ret) {
245             case 'v':
246                 verbose = 1;
247                 break;
248         }
249     }
250     */
251     if (argc > 1 && strcmp(argv[1], "-v") == 0)
252         verbose = 1;
253     return 0;
254 }