1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the COPYING file, which can be found at the root of the source code *
* distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
* If you do not have access to either file, you may request a copy from *
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* Purpose: Common MPI routines
*
*/
#include "H5private.h" /* Generic Functions */
#include "H5Eprivate.h" /* Error handling */
#include "H5MMprivate.h" /* Memory Management */
#ifdef H5_HAVE_PARALLEL
/*-------------------------------------------------------------------------
* Function: H5_mpi_comm_dup
*
* Purpose: Duplicate an MPI communicator.
*
* Does not duplicate MPI_COMM_NULL. Instead, comm_new will
* be set to MPI_COMM_NULL directly.
*
* The new communicator is returned via the comm_new pointer.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_comm_dup(MPI_Comm comm, MPI_Comm *comm_new)
{
herr_t ret_value = SUCCEED;
MPI_Comm comm_dup = MPI_COMM_NULL;
int mpi_code;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!comm_new)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "comm_new cannot be NULL")
/* Handle MPI_COMM_NULL separately */
if (MPI_COMM_NULL == comm) {
/* Don't duplicate MPI_COMM_NULL since that's an error in MPI */
comm_dup = MPI_COMM_NULL;
}
else {
/* Duplicate the MPI communicator */
if (MPI_SUCCESS != (mpi_code = MPI_Comm_dup(comm, &comm_dup)))
HMPI_GOTO_ERROR(FAIL, "MPI_Comm_dup failed", mpi_code)
/* Set MPI_ERRORS_RETURN on comm_dup so that MPI failures are not fatal,
* and return codes can be checked and handled.
*/
if (MPI_SUCCESS != (mpi_code = MPI_Comm_set_errhandler(comm_dup, MPI_ERRORS_RETURN)))
HMPI_GOTO_ERROR(FAIL, "MPI_Errhandler_set failed", mpi_code)
}
/* Copy the new communicator to the return argument */
*comm_new = comm_dup;
done:
if (FAIL == ret_value) {
/* need to free anything created here */
if (MPI_COMM_NULL != comm_dup)
MPI_Comm_free(&comm_dup);
}
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5_mpi_comm_dup() */
/*-------------------------------------------------------------------------
* Function: H5_mpi_info_dup
*
* Purpose: Duplicate an MPI info.
*
* If the info object is MPI_INFO_NULL, no duplicate
* is made but the same value assigned to the new info object
* handle.
*
* The new info is returned via the info_new pointer.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_info_dup(MPI_Info info, MPI_Info *info_new)
{
herr_t ret_value = SUCCEED;
MPI_Info info_dup = MPI_INFO_NULL;
int mpi_code;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!info_new)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "info_new cannot be NULL")
/* Duplicate the MPI info */
if (info == MPI_INFO_NULL) {
/* Don't duplicate MPI_INFO_NULL. Just copy it. */
info_dup = MPI_INFO_NULL;
}
else {
/* Duplicate the info */
if (MPI_SUCCESS != (mpi_code = MPI_Info_dup(info, &info_dup)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_dup failed", mpi_code)
}
/* Copy the new info to the return argument */
*info_new = info_dup;
done:
if (FAIL == ret_value) {
/* need to free anything created here */
if (MPI_INFO_NULL != info_dup)
MPI_Info_free(&info_dup);
}
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5_mpi_info_dup() */
/*-------------------------------------------------------------------------
* Function: H5_mpi_comm_free
*
* Purpose: Free an MPI communicator.
*
* If comm is MPI_COMM_NULL this call does nothing.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_comm_free(MPI_Comm *comm)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!comm)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "comm pointer cannot be NULL")
/* Free the communicator */
if (MPI_COMM_NULL != *comm)
MPI_Comm_free(comm);
*comm = MPI_COMM_NULL;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* End H5_mpi_comm_free() */
/*-------------------------------------------------------------------------
* Function: H5_mpi_info_free
*
* Purpose: Free the MPI info.
*
* If info is MPI_INFO_NULL this call does nothing.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_info_free(MPI_Info *info)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!info)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "info pointer cannot be NULL")
/* Free the info */
if (MPI_INFO_NULL != *info)
MPI_Info_free(info);
*info = MPI_INFO_NULL;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* End H5_mpi_info_free() */
/*-------------------------------------------------------------------------
* Function: H5_mpi_comm_cmp
*
* Purpose: Compares two MPI communicators.
*
* Note that passing MPI_COMM_NULL to this function will not
* throw errors, unlike MPI_Comm_compare().
*
* We consider MPI communicators to be the "same" when the
* groups are identical. We don't care about the context
* since that will always be different as we call MPI_Comm_dup
* when we store the communicator in the fapl.
*
* The out parameter is a value like strcmp. The value is
* undefined when the return value is FAIL.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_comm_cmp(MPI_Comm comm1, MPI_Comm comm2, int *result)
{
int mpi_code;
int mpi_result = MPI_IDENT;
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!result)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "result cannot be NULL")
/* Set out parameter to something reasonable in case something goes wrong */
*result = 0;
/* Can't pass MPI_COMM_NULL to MPI_Comm_compare() so we have to handle
* it in special cases.
*
* MPI_Comm can either be an integer type or a pointer. We cast them
* to intptr_t so we can compare them with < and > when needed.
*/
if (MPI_COMM_NULL == comm1 && MPI_COMM_NULL == comm2) {
/* Special case of both communicators being MPI_COMM_NULL */
*result = 0;
}
else if (MPI_COMM_NULL == comm1 || MPI_COMM_NULL == comm2) {
/* Special case of one communicator being MPI_COMM_NULL */
*result = (intptr_t)comm1 < (intptr_t)comm2 ? -1 : 1;
}
else {
/* Normal communicator compare */
/* Compare the MPI communicators */
if (MPI_SUCCESS != (mpi_code = MPI_Comm_compare(comm1, comm2, &mpi_result)))
HMPI_GOTO_ERROR(FAIL, "MPI_Comm_compare failed", mpi_code)
/* Set the result */
if (MPI_IDENT == mpi_result || MPI_CONGRUENT == mpi_result)
*result = 0;
else
*result = (intptr_t)comm1 < (intptr_t)comm2 ? -1 : 1;
}
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5_mpi_comm_cmp() */
/*-------------------------------------------------------------------------
* Function: H5_mpi_info_cmp
*
* Purpose: Compares two MPI info objects.
*
* For our purposes, two mpi info objects are the "same" if
* they contain the same key-value pairs or are both
* MPI_INFO_NULL.
*
* The out parameter is a value like strcmp. The value is
* undefined when the return value is FAIL.
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5_mpi_info_cmp(MPI_Info info1, MPI_Info info2, int *result)
{
hbool_t same = FALSE;
char *key = NULL;
char *value1 = NULL;
char *value2 = NULL;
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI(FAIL)
/* Check arguments */
if (!result)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "result cannot be NULL")
/* Check for MPI_INFO_NULL */
if (MPI_INFO_NULL == info1 && MPI_INFO_NULL == info2) {
/* Special case of both info objects being MPI_INFO_NULL */
same = TRUE;
}
else if (MPI_INFO_NULL == info1 || MPI_INFO_NULL == info2) {
/* Special case of one info object being MPI_INFO_NULL */
same = FALSE;
}
else {
int mpi_code;
int nkeys_1;
int nkeys_2;
/* Check if the number of keys is the same */
if (MPI_SUCCESS != (mpi_code = MPI_Info_get_nkeys(info1, &nkeys_1)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_get_nkeys failed", mpi_code)
if (MPI_SUCCESS != (mpi_code = MPI_Info_get_nkeys(info2, &nkeys_2)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_get_nkeys failed", mpi_code)
if (nkeys_1 != nkeys_2)
same = FALSE;
else if (0 == nkeys_1 && 0 == nkeys_2)
same = TRUE;
else {
int i;
int flag1 = -1;
int flag2 = -1;
/* Allocate buffers for iteration */
if (NULL == (key = (char *)H5MM_malloc(MPI_MAX_INFO_KEY * sizeof(char))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
if (NULL == (value1 = (char *)H5MM_malloc(MPI_MAX_INFO_VAL * sizeof(char))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
if (NULL == (value2 = (char *)H5MM_malloc(MPI_MAX_INFO_VAL * sizeof(char))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
/* Iterate over the keys, comparing them */
for (i = 0; i < nkeys_1; i++) {
same = TRUE;
/* Memset the buffers to zero */
HDmemset(key, 0, MPI_MAX_INFO_KEY);
HDmemset(value1, 0, MPI_MAX_INFO_VAL);
HDmemset(value2, 0, MPI_MAX_INFO_VAL);
/* Get the nth key */
if (MPI_SUCCESS != (mpi_code = MPI_Info_get_nthkey(info1, i, key)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_get_nthkey failed", mpi_code)
/* Get the values */
if (MPI_SUCCESS != (mpi_code = MPI_Info_get(info1, key, MPI_MAX_INFO_VAL, value1, &flag1)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_get failed", mpi_code)
if (MPI_SUCCESS != (mpi_code = MPI_Info_get(info2, key, MPI_MAX_INFO_VAL, value2, &flag2)))
HMPI_GOTO_ERROR(FAIL, "MPI_Info_get failed", mpi_code)
/* Compare values and flags */
if (!flag1 || !flag2 || HDmemcmp(value1, value2, MPI_MAX_INFO_VAL)) {
same = FALSE;
break;
}
} /* end for */
} /* end else */
} /* end else */
/* Set the output value
*
* MPI_Info can either be an integer type or a pointer. We cast them
* to intptr_t so we can compare them with < and > when needed.
*/
if (same)
*result = 0;
else
*result = (intptr_t)info1 < (intptr_t)info2 ? -1 : 1;
done:
if (key)
H5MM_xfree(key);
if (value1)
H5MM_xfree(value1);
if (value2)
H5MM_xfree(value2);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5_mpi_info_cmp() */
#endif /* H5_HAVE_PARALLEL */
|
