SIONlib  1.7.5
Scalable I/O library for parallel access to task-local files
partest_sionfile.c
1 /****************************************************************************
2 ** SIONLIB http://www.fz-juelich.de/jsc/sionlib **
3 *****************************************************************************
4 ** Copyright (c) 2008-2019 **
5 ** Forschungszentrum Juelich, Juelich Supercomputing Centre **
6 ** **
7 ** See the file COPYRIGHT in the package base directory for details **
8 ****************************************************************************/
9 
10 #define _XOPEN_SOURCE 700
11 
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <ctype.h>
16 #include <unistd.h>
17 #include <mpi.h>
18 #include <time.h>
19 #include <math.h>
20 
21 #include "sion.h"
22 #include "sion_debug.h"
23 #include "sion_printts.h"
24 #include "partest.h"
25 #include "partest_util.h"
26 
27 sion_int64 partest_write_chunk_to_sionfile( int sid,
28  int rank,
29  char *localbuffer,
30  _test_options *options,
31  int do_debug,
32  double *checksum_fp,
33  int *chunkcnt);
34 
35 sion_int64 partest_read_chunk_from_sionfile( int sid,
36  int rank,
37  char *localbuffer,
38  _test_options *options,
39  int do_debug,
40  double *checksum_fp,
41  int *chunkcnt);
42 
43  /****************************************************************************************************************
44  *
45  * test_paropen_multi_mpi
46  *
47  ***************************************************************************************************************/
48 int test_paropen_multi_mpi(char *filename,
49  char *localbuffer,
50  _test_communicators *communicators,
51  _test_options *options
52  ) {
53 
54  double starttime, write_starttime, read_starttime, unlinktime, gunlinktime;
55  double timings[TIMINGS_MAX_NUM],ftimings[TIMINGS_MAX_NUM],gtimings[TIMINGS_MAX_NUM];
56  sion_int64 stats[STATS_MAX_NUM], fstats[STATS_MAX_NUM], gstats[STATS_MAX_NUM];
57 
58  double checksum_fp, checksum_read_fp;
59  int globalrank, sid, i;
60  int chunkcnt, using_hints;
61  sion_int64 rchunksize;
62  sion_int32 rfsblksize;
63  char *newfname=NULL;
64  int do_debug;
65  int ser_count,ser_step,ser_done;
66  char file_mode[32];
67 
68  /* */ DPRINTFTS(communicators->all_rank, "start");
69  /* numfiles>=1 -> sion will split the communicator */
70  /* numfiles<=0 -> communicators->local contain correct local communicator, computed by split_communicator */
71 
72  /* not working task ? */
73  if (communicators->work_size == -1) {
74  return (0);
75  }
76 
77  if(0){
78 
79  MPI_Comm_size(communicators->work, &communicators->work_size);
80  MPI_Comm_rank(communicators->work, &communicators->work_rank);
81  MPI_Comm_size(communicators->workread, &communicators->workread_size);
82  MPI_Comm_rank(communicators->workread, &communicators->workread_rank);
83  fprintf(stderr, "timings[%06d] entering test_paropen_multi_mpi work=%d of %d workread=%d of %d\n", communicators->all_rank,
84  communicators->work_rank, communicators->work_size,
85  communicators->workread_rank, communicators->workread_size
86  );
87  }
88 
89 
90  do_debug=(((options->debug && communicators->all_rank == 0)) || ((options->Debug && (communicators->all_rank+1) == communicators->all_size)));
91 
92  for(i=0;i<TIMINGS_MAX_NUM;i++) timings[i]=ftimings[i]=gtimings[i]=0.0;
93  for(i=0;i<STATS_MAX_NUM;i++) stats[i]=fstats[i]=gstats[i]=0;
94 
95  if(options->do_write) {
96  /****************************** WRITE *****************************/
97 
98  /* to synchronize start */
99  barrier_after_start(communicators->local);
100 
101  /* TIMING */ write_starttime = starttime = MPI_Wtime();
102  strcpy(file_mode, "bw");
103  if(options->use_posix) {
104  strcat(file_mode, ",posix");
105  } else {
106  strcat(file_mode, ",ansi");
107  }
108  if (options->collmsa) {
109  strcat(file_mode, ",collmsa");
110  }
111  sid = sion_paropen_mpi(filename, file_mode, &options->numfiles, communicators->work, &communicators->local,
112  &options->chunksize, &options->fsblksize, &globalrank, NULL, &newfname);
113  using_hints=sion_using_hints(sid);
114  stats[STATS_WR_NUM_FILES]=options->numfiles;
115  /* TIMING */ timings[TIMINGS_WR_OPEN] = MPI_Wtime()-starttime;
116 
117  /* TIMING */ starttime = MPI_Wtime();
118  barrier_after_open(communicators->local);
119  /* TIMING */ timings[TIMINGS_WR_OPEN_BARR_FILE] += MPI_Wtime()-starttime;
120 
121  /* TIMING */ starttime = MPI_Wtime();
122  barrier_after_open(communicators->work);
123  /* TIMING */ timings[TIMINGS_WR_OPEN_BARR_GLOBAL] = MPI_Wtime()-starttime;
124 
125  /* local is computed again by sion_paropen_mpi if numfiles >=1 */
126  /* TIMING */ starttime = MPI_Wtime();
127  MPI_Comm_size(communicators->local, &communicators->local_size);
128  MPI_Comm_rank(communicators->local, &communicators->local_rank);
129 
130  if(options->serialize_blocknum==-2) sion_startof_transaction_mpi(sid);
131  if(options->serialize_blocknum>0) ser_step=options->serialize_blocknum;
132  else ser_step=communicators->local_size;
133  ser_done=0;
134  /* TIMING */ timings[TIMINGS_WR_WRITE_SYNC] += MPI_Wtime()-starttime;
135 
136  for(ser_count=0;ser_count<communicators->local_size;ser_count+=ser_step) {
137  if ((!ser_done) && communicators->local_rank<(ser_count+ser_step)) {
138  ser_done=1;
139 
140  /* TIMING */ starttime = MPI_Wtime();
141  stats[STATS_BYTES_WR_WROTE]+=partest_write_chunk_to_sionfile(sid,communicators->all_rank,
142  localbuffer,options,do_debug&&options->verbose,
143  &checksum_fp,&chunkcnt);
144  stats[STATS_BYTES_WR_NUM_CHUNKS]+=chunkcnt;
145  /* TIMING */ timings[TIMINGS_WR_WRITE] += MPI_Wtime()-starttime;
146 
147  }
148 
149  /* TIMING */ starttime = MPI_Wtime();
150  if(options->serialize_blocknum==-2) sion_endof_transaction_mpi(sid);
151  /* TIMING */ timings[TIMINGS_WR_WRITE_SYNC] += MPI_Wtime()-starttime;
152 
153  /* TIMING */ starttime = MPI_Wtime();
154  barrier_after_write(communicators->local);
155  /* TIMING */ timings[TIMINGS_WR_WRITE_BARR_FILE] += MPI_Wtime()-starttime;
156 
157  }
158 
159  /* TIMING */ starttime = MPI_Wtime();
160  barrier_after_write(communicators->work);
161  /* TIMING */ timings[TIMINGS_WR_WRITE_BARR_GLOBAL] = MPI_Wtime()-starttime;
162 
163  /* TIMING */ starttime = MPI_Wtime();
164  sion_parclose_mpi(sid);
165  /* TIMING */ timings[TIMINGS_WR_CLOSE] = MPI_Wtime()-starttime;
166 
167  /* TIMING */ starttime = MPI_Wtime();
168  barrier_after_close(communicators->local);
169  /* TIMING */ timings[TIMINGS_WR_CLOSE_BARR_FILE] = MPI_Wtime()-starttime;
170 
171  /* TIMING */ starttime = MPI_Wtime();
172  barrier_after_close(communicators->work);
173  /* TIMING */ timings[TIMINGS_WR_CLOSE_BARR_GLOBAL] = MPI_Wtime()-starttime;
174  /* TIMING */ timings[TIMINGS_WR_TOTAL] = MPI_Wtime()-write_starttime;
175 
176  if (timings[TIMINGS_WR_TOTAL] == 0) timings[TIMINGS_WR_TOTAL] = -1;
177 
178 
179  /* TIMING */ starttime = MPI_Wtime();
180  if ( (communicators->work_size>0) && (communicators->work_rank==0) ) {
181  fprintf(stderr, "partest filespec: ( ) using_hints = %ld\n", (long) using_hints);
182  fprintf(stderr, "partest filespec: ( ) fsblksize = %ld\n", (long) options->fsblksize);
183  }
184 
185  if (options->verbose) {
186  write_timings("TASK",TIMINGS_METHOD_WRITE,timings,stats,communicators,options,1);
187  }
188  if (do_debug) {
189  write_timings("TASK",TIMINGS_METHOD_WRITE,timings,stats,communicators,options,0);
190  }
191 
192  /* TIMING */ timings[TIMINGS_MSGS] += MPI_Wtime()-starttime;
193 
194  if (options->numfiles > 1) {
195 
196  MPI_Reduce(timings, ftimings, TIMINGS_MAX_NUM, MPI_DOUBLE, MPI_MAX, 0, communicators->local);
197  MPI_Reduce(stats, fstats, STATS_MAX_NUM, SION_MPI_INT64, MPI_SUM, 0, communicators->local);
198 
199  if (communicators->local_rank == 0) {
200  write_timings("FILE",TIMINGS_METHOD_WRITE,ftimings,fstats,communicators,options,0);
201  }
202 
203  }
204 
205  MPI_Reduce(timings, gtimings, TIMINGS_MAX_NUM, MPI_DOUBLE, MPI_MAX, 0, communicators->work);
206  MPI_Reduce(stats, gstats, STATS_MAX_NUM, SION_MPI_INT64, MPI_SUM, 0, communicators->work);
207 
208  if (communicators->work_rank == 0) {
209  fprintf(stderr, "------------------------------------------------------------------------------------------\n");
210  write_timings("TOTAL",TIMINGS_METHOD_WRITE,gtimings,gstats,communicators,options,0);
211  fprintf(stderr, "------------------------------------------------------------------------------------------\n");
212  }
213 
214  if(newfname) {free(newfname);newfname=NULL;}
215 
216 
217  } /* do_write */
218 
219  /* to synchronize after write */
220  barrier_after_close(communicators->work);
221 
222  if(options->do_read) {
223  /****************************** READ *****************************/
224 
225  /* reset localbuffer */
226  for (i = 0; i < ((options->totalsize < options->bufsize) ? options->totalsize : options->bufsize); i++) {
227  localbuffer[i] = ' ';
228  }
229  /* to synchronize start */
230  barrier_after_start(communicators->local);
231 
232  /* TIMING */ read_starttime = starttime = MPI_Wtime();
233  strcpy(file_mode, "br");
234  if(options->use_posix) {
235  strcat(file_mode, ",posix");
236  } else {
237  strcat(file_mode, ",ansi");
238  }
239  if (options->collmsa) {
240  strcat(file_mode, ",collmsa");
241  }
242 
243  /* TIMING */ starttime = MPI_Wtime();
244  if (options->collectiveopenforread) {
245  /* commlocal and numfiles will be read from sion file */
246  sid = sion_paropen_mpi(filename,file_mode, &options->numfiles, communicators->workread,
247  &communicators->local, &options->chunksize, &options->fsblksize, &globalrank, NULL, &newfname);
248  stats[STATS_RD_NUM_FILES]=options->numfiles;
249  }
250  else {
251  /* there is some work to for multifile sion file */
252  sid = sion_open_rank(filename, file_mode, &rchunksize, &rfsblksize, &communicators->workread_rank, NULL);
253  stats[STATS_RD_NUM_FILES]=-1;
254  }
255  using_hints=sion_using_hints(sid);
256  /* TIMING */ timings[TIMINGS_RD_OPEN] = MPI_Wtime()-starttime;
257 
258  /* TIMING */ starttime = MPI_Wtime();
259  barrier_after_open(communicators->local);
260  /* TIMING */ timings[TIMINGS_RD_OPEN_BARR_FILE] += MPI_Wtime()-starttime;
261 
262  /* TIMING */ starttime = MPI_Wtime();
263  barrier_after_open(communicators->workread);
264  /* TIMING */ timings[TIMINGS_RD_OPEN_BARR_GLOBAL] = MPI_Wtime()-starttime;
265 
266 
267  /* TIMING */ starttime = MPI_Wtime();
268  /* local is computed again by sion_paropen_mpi if numfiles >=1 */
269  MPI_Comm_size(communicators->local, &communicators->local_size);
270  MPI_Comm_rank(communicators->local, &communicators->local_rank);
271 
272  if(options->serialize_blocknum==-2) sion_startof_transaction_mpi(sid);
273  if(options->serialize_blocknum>0) ser_step=options->serialize_blocknum;
274  else ser_step=communicators->local_size;
275  ser_done=0;
276 
277  /* TIMING */ timings[TIMINGS_RD_READ_SYNC] += MPI_Wtime()-starttime;
278 
279  for(ser_count=0;ser_count<communicators->local_size;ser_count+=ser_step) {
280 
281  if ((!ser_done) && communicators->local_rank<(ser_count+ser_step)) {
282  ser_done=1;
283 
284  /* TIMING */ starttime = MPI_Wtime();
285  stats[STATS_BYTES_RD_READ]+=partest_read_chunk_from_sionfile(sid,communicators->all_rank,
286  localbuffer,options,do_debug&&options->verbose,
287  &checksum_read_fp,&chunkcnt);
288  stats[STATS_BYTES_RD_NUM_CHUNKS]+=chunkcnt;
289  /* TIMING */ timings[TIMINGS_RD_READ] += MPI_Wtime()-starttime;
290 
291  }
292  /* TIMING */ starttime = MPI_Wtime();
293  if(options->serialize_blocknum==-2) sion_endof_transaction_mpi(sid);
294  /* TIMING */ timings[TIMINGS_RD_READ_SYNC] += MPI_Wtime()-starttime;
295 
296  /* TIMING */ starttime = MPI_Wtime();
297  barrier_after_read(communicators->local);
298  /* TIMING */ timings[TIMINGS_RD_READ_BARR_FILE] += MPI_Wtime()-starttime;
299 
300  }
301 
302  /* TIMING */ starttime = MPI_Wtime();
303  barrier_after_read(communicators->workread);
304  /* TIMING */ timings[TIMINGS_RD_READ_BARR_GLOBAL] = MPI_Wtime()-starttime;
305 
306 
307  /* TIMING */ starttime = MPI_Wtime();
308  if (options->collectiveopenforread) {
309  sion_parclose_mpi(sid);
310  }
311  else {
312  sion_close(sid);
313  }
314  /* TIMING */ timings[TIMINGS_RD_CLOSE] = MPI_Wtime()-starttime;
315 
316  /* TIMING */ starttime = MPI_Wtime();
317  barrier_after_close(communicators->local);
318  /* TIMING */ timings[TIMINGS_RD_CLOSE_BARR_FILE] = MPI_Wtime()-starttime;
319 
320  /* TIMING */ starttime = MPI_Wtime();
321  barrier_after_close(communicators->workread);
322  /* TIMING */ timings[TIMINGS_RD_CLOSE_BARR_GLOBAL] = MPI_Wtime()-starttime;
323  /* TIMING */ timings[TIMINGS_RD_TOTAL] = MPI_Wtime()-read_starttime;
324 
325 
326  /* TIMING */ starttime = MPI_Wtime();
327  if (timings[TIMINGS_RD_TOTAL] == 0) timings[TIMINGS_RD_TOTAL] = -1;
328 
329  if ( (communicators->work_size>0) && (communicators->workread_rank==0) ) {
330  fprintf(stderr, "partest filespec: ( ) using_hints = %ld\n", (long) using_hints);
331  fprintf(stderr, "partest filespec: ( ) fsblksize = %ld\n", (long) options->fsblksize);
332  }
333 
334  if (options->verbose) {
335  write_timings("TASK",TIMINGS_METHOD_READ,timings,stats,communicators,options,1);
336  }
337 
338  if (do_debug) {
339  write_timings("TASK",TIMINGS_METHOD_READ,timings,stats,communicators,options,0);
340  }
341 
342  /* TIMING */ timings[TIMINGS_MSGS] += MPI_Wtime()-starttime;
343 
344  if (options->numfiles > 1) {
345 
346  MPI_Reduce(timings, ftimings, TIMINGS_MAX_NUM, MPI_DOUBLE, MPI_MAX, 0, communicators->local);
347  MPI_Reduce(stats, fstats, STATS_MAX_NUM, SION_MPI_INT64, MPI_SUM, 0, communicators->local);
348 
349  if (communicators->local_rank == 0) {
350  write_timings("FILE",TIMINGS_METHOD_READ,ftimings,fstats,communicators,options,0);
351  }
352 
353  }
354 
355  MPI_Reduce(timings, gtimings, TIMINGS_MAX_NUM, MPI_DOUBLE, MPI_MAX, 0, communicators->workread);
356  MPI_Reduce(stats, gstats, STATS_MAX_NUM, SION_MPI_INT64, MPI_SUM, 0, communicators->workread);
357 
358  /* */ DPRINTFTS(communicators->all_rank, "after red.");
359  if (communicators->workread_rank == 0) {
360  fprintf(stderr, "------------------------------------------------------------------------------------------\n");
361  write_timings("TOTAL",TIMINGS_METHOD_READ,gtimings,gstats,communicators,options,0);
362  fprintf(stderr, "------------------------------------------------------------------------------------------\n");
363  }
364 
365 #ifdef CHECKSUM
366  if(!options->suppress_checksum) {
367  if (fabs(checksum_fp - checksum_read_fp) > 1e-5) {
368  fprintf(stderr, "timings[%06d] ERROR in double checksum %14.10f==%14.10f, diff=%14.10f\n", communicators->local_rank,
369  checksum_fp, checksum_read_fp, checksum_fp - checksum_read_fp);
370  }
371  }
372 #endif
373 
374  } /* do_read */
375 
376  if(options->unlink_files) {
377  /* */ starttime = MPI_Wtime();
378  barrier_before_unlink(communicators->workread);
379  if (communicators->local_rank == 0) {
380  fprintf(stderr, "partest result: unlink file %s ...\n", newfname);
381  unlink(newfname);
382  }
383  barrier_after_unlink(communicators->workread);
384  /* */ unlinktime = MPI_Wtime() - starttime;
385  MPI_Reduce(&unlinktime, &gunlinktime, 1, MPI_DOUBLE, MPI_MAX, 0, communicators->work);
386  if (communicators->work_rank == 0) {
387  fprintf(stderr, "partest result: ultime=%10.6fs unlink %s\n", gunlinktime, newfname);
388  }
389  }
390 
391  if(newfname) {free(newfname);newfname=NULL;}
392 
393  return (1);
394 }
395 
396 sion_int64 partest_write_chunk_to_sionfile( int sid,
397  int rank,
398  char *localbuffer,
399  _test_options *options,
400  int do_debug,
401  double *checksum_fp,
402  int *chunkcnt) {
403  sion_int64 left;
404  sion_int64 bsumwrote;
405  size_t bytes_in_chunk;
406  size_t bwrite, bwrote;
407  int i;
408 
409  sion_int64 bufsize = (sion_int64) options->bufsize;
410  sion_int64 totalsize = (sion_int64) options->totalsize;
411  sion_int64 startoffset = options->startoffset;
412 
413  *checksum_fp=0.0;
414  left = totalsize;
415  bsumwrote = 0;
416  *chunkcnt = 0;
417  bytes_in_chunk=0;
418 
419  /* Write until total size of the data is reached */
420  while (left > 0) {
421  if(startoffset==0) bwrite = bufsize;
422  else {
423  bwrite = startoffset; startoffset=0;
424  }
425  if (bwrite > left)
426  bwrite = left;
427 
428  if (0) {
429  fprintf(stderr, "timings[%06d] write %lld bytes\n", rank, (sion_int64) bwrite);
430  }
431 
432  bytes_in_chunk+=bwrite;
433  if(bytes_in_chunk>options->chunksize) {
434  sion_ensure_free_space(sid, bwrite);
435  bytes_in_chunk=bwrite;
436  }
437  if(options->collectivewrite) {
438  bwrote = sion_coll_fwrite_mpi(localbuffer, 1, bwrite, sid);
439  } else {
440  bwrote = sion_fwrite(localbuffer, 1, bwrite, sid);
441  }
442 
443 #ifdef CHECKSUM
444  if(!options->suppress_checksum) {
445  for (i = 0; i < bwrote; i++)
446  *checksum_fp += (double) localbuffer[i];
447  }
448 #endif
449  left -= bwrote;
450  bsumwrote += bwrote;
451  (*chunkcnt)++;
452 
453  if (do_debug) {
454  fprintf(stderr, "timings[%06d] wrote %10lld bytes total: wrote %14lld bytes (%10.4f MB) left %14lld bytes (%10.4f MB)\n", rank,
455  (sion_int64) bwrote,
456  bsumwrote, bsumwrote / 1024.0 / 1024.0,
457  (sion_int64) left,
458  left / 1024.0 / 1024.0 );
459  }
460  }
461  return(bsumwrote);
462 }
463 
464 
465 sion_int64 partest_read_chunk_from_sionfile( int sid,
466  int rank,
467  char *localbuffer,
468  _test_options *options,
469  int do_debug,
470  double *checksum_read_fp,
471  int *chunkcnt) {
472 
473  sion_int64 left;
474  sion_int64 bsumread;
475  size_t bytes_in_chunk;
476  size_t btoread, bread;
477  int myfeof;
478  int i;
479 
480  sion_int64 bufsize = (sion_int64) options->bufsize;
481  sion_int64 totalsize = (sion_int64) options->totalsize;
482  sion_int64 startoffset = options->startoffset;
483 
484  *checksum_read_fp = 0;
485  left = totalsize;
486  bsumread = 0;
487  *chunkcnt = 0;
488  bytes_in_chunk = 0;
489 
490 
491  myfeof=sion_feof(sid);
492  while ((left > 0) && (!myfeof)) {
493 
494  if(startoffset==0) btoread = bufsize;
495  else {
496  btoread = startoffset; startoffset=0;
497  }
498  if (btoread > left)
499  btoread = left;
500 
501  bytes_in_chunk+=btoread;
502  if(bytes_in_chunk>options->chunksize) {
503  myfeof=sion_feof(sid);
504  }
505  if(!myfeof) {
506  if(options->collectiveread) {
507  bread = sion_coll_fread_mpi(localbuffer, 1, btoread, sid);
508  } else {
509  bread = sion_fread(localbuffer, 1, btoread, sid);
510  }
511 
512 #ifdef CHECKSUM
513  if(!options->suppress_checksum) {
514  for (i = 0; i < bread; i++)
515  *checksum_read_fp += (double) localbuffer[i];
516  }
517 #endif
518 
519  left -= bread;
520  bsumread += bread;
521  (*chunkcnt)++;
522 
523  if (do_debug) {
524  fprintf(stderr, "timings[%06d] read %10lld bytes total: read %14lld bytes (%10.4f MB) left %14lld bytes (%10.4f MB)\n", rank,
525  (sion_int64) bread,
526  bsumread, bsumread / 1024.0 / 1024.0,
527  (sion_int64) left,
528  left / 1024.0 / 1024.0 );
529  }
530  }
531  }
532 
533  return(bsumread);
534 }
535 
536 
sion_parclose_mpi
int sion_parclose_mpi(int sid)
Close a sion file using MPI.
Definition: sion_mpi_gen.c:229
_test_communicators_struct
Definition: ompi_partest.h:24
sion_fwrite
size_t sion_fwrite(const void *data, size_t size, size_t nitems, int sid)
Write data to sion file.
Definition: sion_common.c:470
sion_ensure_free_space
int sion_ensure_free_space(int sid, sion_int64 bytes)
Funtion to ensure that enough space is available for writing.
Definition: sion_common.c:1053
sion_paropen_mpi
int sion_paropen_mpi(const char *fname, const char *file_mode, int *numFiles, MPI_Comm gComm, const MPI_Comm *lComm, sion_int64 *chunksize, sion_int32 *fsblksize, int *globalrank, FILE **fileptr, char **newfname)
Open a sion file using MPI.
Definition: sion_mpi_gen.c:84
sion.h
_test_communicators_struct::local
MPI_Comm local
Definition: ompi_partest.h:28
sion_debug.h
sion_close
int sion_close(int sid)
Close a sion file.
Definition: sion_serial.c:105
_test_options_struct
Definition: partest_opts.h:14
_test_communicators_struct::work
MPI_Comm work
Definition: ompi_partest.h:26
sion_feof
int sion_feof(int sid)
Function that indicates whether the end of file is reached for this task.
Definition: sion_common.c:809
sion_fread
size_t sion_fread(void *data, size_t size, size_t nitems, int sid)
Read data from sion file.
Definition: sion_common.c:609
sion_open_rank
int sion_open_rank(char *fname, const char *file_mode, sion_int64 *chunksize, sion_int32 *fsblksize, int *rank, FILE **fileptr)
Open a sion file for a specific rank.
Definition: sion_serial.c:82
_test_communicators_struct::workread
MPI_Comm workread
Definition: ompi_partest.h:27
sion_printts.h
Sion Time Stamp Header.
Generated by   doxygen 1.8.16