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