Actual source code: binv.c

  1: #include <petsc/private/viewerimpl.h>

  3: /*
  4:    This needs to start the same as PetscViewer_Socket.
  5: */
  6: typedef struct {
  7:   int       fdes;        /* file descriptor, ignored if using MPI IO */
  8:   PetscInt  flowcontrol; /* allow only <flowcontrol> messages outstanding at a time while doing IO */
  9:   PetscBool skipheader;  /* don't write header, only raw data */
 10: #if defined(PETSC_HAVE_MPIIO)
 11:   PetscBool  usempiio;
 12:   MPI_File   mfdes; /* ignored unless using MPI IO */
 13:   MPI_File   mfsub; /* subviewer support */
 14:   MPI_Offset moff;
 15: #endif
 16:   char         *filename;            /* file name */
 17:   PetscFileMode filemode;            /* read/write/append mode */
 18:   FILE         *fdes_info;           /* optional file containing info on binary file*/
 19:   PetscBool     storecompressed;     /* gzip the write binary file when closing it*/
 20:   char         *ogzfilename;         /* gzip can be run after the filename has been updated */
 21:   PetscBool     skipinfo;            /* Don't create info file for writing; don't use for reading */
 22:   PetscBool     skipoptions;         /* don't use PETSc options database when loading */
 23:   PetscBool     matlabheaderwritten; /* if format is PETSC_VIEWER_BINARY_MATLAB has the MATLAB .info header been written yet */
 24:   PetscBool     setfromoptionscalled;
 25: } PetscViewer_Binary;

 27: static PetscErrorCode PetscViewerBinaryClearFunctionList(PetscViewer v)
 28: {
 29:   PetscFunctionBegin;
 30:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetFlowControl_C", NULL));
 31:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetFlowControl_C", NULL));
 32:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipHeader_C", NULL));
 33:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipHeader_C", NULL));
 34:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipOptions_C", NULL));
 35:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipOptions_C", NULL));
 36:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipInfo_C", NULL));
 37:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipInfo_C", NULL));
 38:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetInfoPointer_C", NULL));
 39:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetName_C", NULL));
 40:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetName_C", NULL));
 41:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetMode_C", NULL));
 42:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetMode_C", NULL));
 43: #if defined(PETSC_HAVE_MPIIO)
 44:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetUseMPIIO_C", NULL));
 45:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetUseMPIIO_C", NULL));
 46: #endif
 47:   PetscFunctionReturn(PETSC_SUCCESS);
 48: }

 50: #if defined(PETSC_HAVE_MPIIO)
 51: static PetscErrorCode PetscViewerBinarySyncMPIIO(PetscViewer viewer)
 52: {
 53:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

 55:   PetscFunctionBegin;
 56:   if (vbinary->filemode == FILE_MODE_READ) PetscFunctionReturn(PETSC_SUCCESS);
 57:   if (vbinary->mfsub != MPI_FILE_NULL) PetscCallMPI(MPI_File_sync(vbinary->mfsub));
 58:   if (vbinary->mfdes != MPI_FILE_NULL) {
 59:     PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)viewer)));
 60:     PetscCallMPI(MPI_File_sync(vbinary->mfdes));
 61:   }
 62:   PetscFunctionReturn(PETSC_SUCCESS);
 63: }
 64: #endif

 66: static PetscErrorCode PetscViewerGetSubViewer_Binary(PetscViewer viewer, MPI_Comm comm, PetscViewer *outviewer)
 67: {
 68:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
 69:   PetscMPIInt         rank;

 71:   PetscFunctionBegin;
 72:   PetscCall(PetscViewerSetUp(viewer));

 74:   /* Return subviewer in process zero */
 75:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));
 76:   if (rank == 0) {
 77:     PetscMPIInt flg;

 79:     PetscCallMPI(MPI_Comm_compare(PETSC_COMM_SELF, comm, &flg));
 80:     PetscCheck(flg == MPI_IDENT || flg == MPI_CONGRUENT, PETSC_COMM_SELF, PETSC_ERR_SUP, "PetscViewerGetSubViewer() for PETSCVIEWERBINARY requires a singleton MPI_Comm");
 81:     PetscCall(PetscViewerCreate(comm, outviewer));
 82:     PetscCall(PetscViewerSetType(*outviewer, PETSCVIEWERBINARY));
 83:     PetscCall(PetscMemcpy((*outviewer)->data, vbinary, sizeof(PetscViewer_Binary)));
 84:     (*outviewer)->setupcalled = PETSC_TRUE;
 85:   } else {
 86:     *outviewer = NULL;
 87:   }

 89: #if defined(PETSC_HAVE_MPIIO)
 90:   if (vbinary->usempiio && *outviewer) {
 91:     PetscViewer_Binary *obinary = (PetscViewer_Binary *)(*outviewer)->data;
 92:     /* Parent viewer opens a new MPI file handle on PETSC_COMM_SELF and keeps track of it for future reuse */
 93:     if (vbinary->mfsub == MPI_FILE_NULL) {
 94:       int amode;
 95:       switch (vbinary->filemode) {
 96:       case FILE_MODE_READ:
 97:         amode = MPI_MODE_RDONLY;
 98:         break;
 99:       case FILE_MODE_WRITE:
100:         amode = MPI_MODE_WRONLY;
101:         break;
102:       case FILE_MODE_APPEND:
103:         amode = MPI_MODE_WRONLY;
104:         break;
105:       default:
106:         SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unsupported file mode %s", PetscFileModes[vbinary->filemode]);
107:       }
108:       PetscCallMPI(MPI_File_open(PETSC_COMM_SELF, vbinary->filename, amode, MPI_INFO_NULL, &vbinary->mfsub));
109:     }
110:     /* Subviewer gets the MPI file handle on PETSC_COMM_SELF */
111:     obinary->mfdes = vbinary->mfsub;
112:     obinary->mfsub = MPI_FILE_NULL;
113:     obinary->moff  = vbinary->moff;
114:   }
115: #endif

117: #if defined(PETSC_HAVE_MPIIO)
118:   PetscCall(PetscViewerBinarySyncMPIIO(viewer));
119: #endif
120:   PetscFunctionReturn(PETSC_SUCCESS);
121: }

123: static PetscErrorCode PetscViewerRestoreSubViewer_Binary(PetscViewer viewer, MPI_Comm comm, PetscViewer *outviewer)
124: {
125:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
126:   PetscMPIInt         rank;
127: #if defined(PETSC_HAVE_MPIIO)
128:   MPI_Offset moff = 0;
129: #endif

131:   PetscFunctionBegin;
132:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));
133:   PetscCheck(rank == 0 || !*outviewer, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Subviewer not obtained from viewer");

135: #if defined(PETSC_HAVE_MPIIO)
136:   if (vbinary->usempiio && *outviewer) {
137:     PetscViewer_Binary *obinary = (PetscViewer_Binary *)(*outviewer)->data;
138:     PetscCheck(obinary->mfdes == vbinary->mfsub, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Subviewer not obtained from viewer");
139:     if (obinary->mfsub != MPI_FILE_NULL) PetscCallMPI(MPI_File_close(&obinary->mfsub));
140:     moff = obinary->moff;
141:   }
142: #endif

144:   if (*outviewer) {
145:     PetscViewer_Binary *obinary = (PetscViewer_Binary *)(*outviewer)->data;
146:     PetscCheck(obinary->fdes == vbinary->fdes, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Subviewer not obtained from viewer");
147:     PetscCall(PetscFree((*outviewer)->data));
148:     PetscCall(PetscViewerBinaryClearFunctionList(*outviewer));
149:     PetscCall(PetscHeaderDestroy(outviewer));
150:   }

152: #if defined(PETSC_HAVE_MPIIO)
153:   if (vbinary->usempiio) {
154:     PetscInt64 ioff = (PetscInt64)moff; /* We could use MPI_OFFSET datatype (requires MPI 2.2) */
155:     PetscCallMPI(MPI_Bcast(&ioff, 1, MPIU_INT64, 0, PetscObjectComm((PetscObject)viewer)));
156:     vbinary->moff = (MPI_Offset)ioff;
157:   }
158: #endif

160: #if defined(PETSC_HAVE_MPIIO)
161:   PetscCall(PetscViewerBinarySyncMPIIO(viewer));
162: #endif
163:   PetscFunctionReturn(PETSC_SUCCESS);
164: }

166: #if defined(PETSC_HAVE_MPIIO)
167: /*@C
168:     PetscViewerBinaryGetMPIIOOffset - Gets the current global offset that should be passed to `MPI_File_set_view()` or `MPI_File_{write|read}_at[_all]()`

170:     Not Collective; No Fortran Support

172:     Input Parameter:
173: .   viewer - PetscViewer context, obtained from `PetscViewerBinaryOpen()`

175:     Output Parameter:
176: .   off - the current global offset

178:     Level: advanced

180:     Note:
181:     Use `PetscViewerBinaryAddMPIIOOffset()` to increase this value after you have written a view.

183: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryAddMPIIOOffset()`
184: @*/
185: PetscErrorCode PetscViewerBinaryGetMPIIOOffset(PetscViewer viewer, MPI_Offset *off)
186: {
187:   PetscViewer_Binary *vbinary;

189:   PetscFunctionBegin;
192:   vbinary = (PetscViewer_Binary *)viewer->data;
193:   *off    = vbinary->moff;
194:   PetscFunctionReturn(PETSC_SUCCESS);
195: }

197: /*@C
198:     PetscViewerBinaryAddMPIIOOffset - Adds to the current global offset

200:     Logically Collective; No Fortran Support

202:     Input Parameters:
203: +   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
204: -   off - the addition to the global offset

206:     Level: advanced

208:     Note:
209:     Use `PetscViewerBinaryGetMPIIOOffset()` to get the value that you should pass to `MPI_File_set_view()` or `MPI_File_{write|read}_at[_all]()`

211: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryGetMPIIOOffset()`
212: @*/
213: PetscErrorCode PetscViewerBinaryAddMPIIOOffset(PetscViewer viewer, MPI_Offset off)
214: {
215:   PetscViewer_Binary *vbinary;

217:   PetscFunctionBegin;
220:   vbinary = (PetscViewer_Binary *)viewer->data;
221:   vbinary->moff += off;
222:   PetscFunctionReturn(PETSC_SUCCESS);
223: }

225: /*@C
226:     PetscViewerBinaryGetMPIIODescriptor - Extracts the MPI IO file descriptor from a `PetscViewer`.

228:     Not Collective; No Fortran Support

230:     Input Parameter:
231: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

233:     Output Parameter:
234: .   fdes - file descriptor

236:     Level: advanced

238: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryGetMPIIOOffset()`
239: @*/
240: PetscErrorCode PetscViewerBinaryGetMPIIODescriptor(PetscViewer viewer, MPI_File *fdes)
241: {
242:   PetscViewer_Binary *vbinary;

244:   PetscFunctionBegin;
247:   PetscCall(PetscViewerSetUp(viewer));
248:   vbinary = (PetscViewer_Binary *)viewer->data;
249:   *fdes   = vbinary->mfdes;
250:   PetscFunctionReturn(PETSC_SUCCESS);
251: }
252: #endif

254: /*@
255:     PetscViewerBinarySetUseMPIIO - Sets a binary viewer to use MPI-IO for reading/writing. Must be called
256:         before `PetscViewerFileSetName()`

258:     Logically Collective

260:     Input Parameters:
261: +   viewer - the `PetscViewer`; must be a `PETSCVIEWERBINARY`
262: -   use - `PETSC_TRUE` means MPI-IO will be used

264:     Options Database Key:
265:     -viewer_binary_mpiio : Flag for using MPI-IO

267:     Level: advanced

269: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerFileSetMode()`, `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinaryOpen()`,
270:           `PetscViewerBinaryGetUseMPIIO()`
271: @*/
272: PetscErrorCode PetscViewerBinarySetUseMPIIO(PetscViewer viewer, PetscBool use)
273: {
274:   PetscFunctionBegin;
277:   PetscTryMethod(viewer, "PetscViewerBinarySetUseMPIIO_C", (PetscViewer, PetscBool), (viewer, use));
278:   PetscFunctionReturn(PETSC_SUCCESS);
279: }

281: #if defined(PETSC_HAVE_MPIIO)
282: static PetscErrorCode PetscViewerBinarySetUseMPIIO_Binary(PetscViewer viewer, PetscBool use)
283: {
284:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
285:   PetscFunctionBegin;
286:   PetscCheck(!viewer->setupcalled || vbinary->usempiio == use, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Cannot change MPIIO to %s after setup", PetscBools[use]);
287:   vbinary->usempiio = use;
288:   PetscFunctionReturn(PETSC_SUCCESS);
289: }
290: #endif

292: /*@
293:     PetscViewerBinaryGetUseMPIIO - Returns `PETSC_TRUE` if the binary viewer uses MPI-IO.

295:     Not Collective

297:     Input Parameter:
298: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`; must be a `PETSCVIEWERBINARY`

300:     Output Parameter:
301: .   use - `PETSC_TRUE` if MPI-IO is being used

303:     Level: advanced

305:     Note:
306:     If MPI-IO is not available, this function will always return `PETSC_FALSE`

308: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryGetMPIIOOffset()`
309: @*/
310: PetscErrorCode PetscViewerBinaryGetUseMPIIO(PetscViewer viewer, PetscBool *use)
311: {
312:   PetscFunctionBegin;
315:   *use = PETSC_FALSE;
316:   PetscTryMethod(viewer, "PetscViewerBinaryGetUseMPIIO_C", (PetscViewer, PetscBool *), (viewer, use));
317:   PetscFunctionReturn(PETSC_SUCCESS);
318: }

320: #if defined(PETSC_HAVE_MPIIO)
321: static PetscErrorCode PetscViewerBinaryGetUseMPIIO_Binary(PetscViewer viewer, PetscBool *use)
322: {
323:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

325:   PetscFunctionBegin;
326:   *use = vbinary->usempiio;
327:   PetscFunctionReturn(PETSC_SUCCESS);
328: }
329: #endif

331: /*@
332:     PetscViewerBinarySetFlowControl - Sets how many messages are allowed to outstanding at the same time during parallel IO reads/writes

334:     Not Collective

336:     Input Parameters:
337: +   viewer - PetscViewer context, obtained from `PetscViewerBinaryOpen()`
338: -   fc - the number of messages, defaults to 256 if this function was not called

340:     Level: advanced

342: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinaryGetFlowControl()`
343: @*/
344: PetscErrorCode PetscViewerBinarySetFlowControl(PetscViewer viewer, PetscInt fc)
345: {
346:   PetscFunctionBegin;
349:   PetscTryMethod(viewer, "PetscViewerBinarySetFlowControl_C", (PetscViewer, PetscInt), (viewer, fc));
350:   PetscFunctionReturn(PETSC_SUCCESS);
351: }

353: static PetscErrorCode PetscViewerBinarySetFlowControl_Binary(PetscViewer viewer, PetscInt fc)
354: {
355:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

357:   PetscFunctionBegin;
358:   PetscCheck(fc > 1, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ARG_OUTOFRANGE, "Flow control count must be greater than 1, %" PetscInt_FMT " was set", fc);
359:   vbinary->flowcontrol = fc;
360:   PetscFunctionReturn(PETSC_SUCCESS);
361: }

363: /*@
364:     PetscViewerBinaryGetFlowControl - Returns how many messages are allowed to outstanding at the same time during parallel IO reads/writes

366:     Not Collective

368:     Input Parameter:
369: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

371:     Output Parameter:
372: .   fc - the number of messages

374:     Level: advanced

376: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`, `PetscViewerBinarySetFlowControl()`
377: @*/
378: PetscErrorCode PetscViewerBinaryGetFlowControl(PetscViewer viewer, PetscInt *fc)
379: {
380:   PetscFunctionBegin;
383:   PetscUseMethod(viewer, "PetscViewerBinaryGetFlowControl_C", (PetscViewer, PetscInt *), (viewer, fc));
384:   PetscFunctionReturn(PETSC_SUCCESS);
385: }

387: PETSC_INTERN PetscErrorCode PetscViewerBinaryGetFlowControl_Binary(PetscViewer viewer, PetscInt *fc)
388: {
389:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

391:   PetscFunctionBegin;
392:   *fc = vbinary->flowcontrol;
393:   PetscFunctionReturn(PETSC_SUCCESS);
394: }

396: /*@C
397:     PetscViewerBinaryGetDescriptor - Extracts the file descriptor from a `PetscViewer` of `PetscViewerType` `PETSCVIEWERBINARY`.

399:     Collective because it may trigger a `PetscViewerSetUp()` call; No Fortran Support

401:     Input Parameter:
402: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

404:     Output Parameter:
405: .   fdes - file descriptor

407:     Level: advanced

409:     Note:
410:       For writable binary `PetscViewer`s, the descriptor will only be valid for the
411:     first processor in the communicator that shares the `PetscViewer`. For readable
412:     files it will only be valid on nodes that have the file. If node 0 does not
413:     have the file it generates an error even if another node does have the file.

415: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetInfoPointer()`
416: @*/
417: PetscErrorCode PetscViewerBinaryGetDescriptor(PetscViewer viewer, int *fdes)
418: {
419:   PetscViewer_Binary *vbinary;

421:   PetscFunctionBegin;
424:   PetscCall(PetscViewerSetUp(viewer));
425:   vbinary = (PetscViewer_Binary *)viewer->data;
426:   *fdes   = vbinary->fdes;
427:   PetscFunctionReturn(PETSC_SUCCESS);
428: }

430: /*@
431:     PetscViewerBinarySkipInfo - Binary file will not have .info file created with it

433:     Not Collective

435:     Input Parameter:
436: .   viewer - `PetscViewer` context, obtained from `PetscViewerCreate()`

438:     Options Database Key:
439: .   -viewer_binary_skip_info - true indicates do not generate .info file

441:     Level: advanced

443:     Notes:
444:     This must be called after `PetscViewerSetType()`. If you use `PetscViewerBinaryOpen()` then
445:     you can only skip the info file with the `-viewer_binary_skip_info` flag. To use the function you must open the
446:     viewer with `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinarySkipInfo()`.

448:     The .info contains meta information about the data in the binary file, for example the block size if it was
449:     set for a vector or matrix.

451:     This routine is deprecated, use `PetscViewerBinarySetSkipInfo()`

453: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySetSkipOptions()`,
454:           `PetscViewerBinaryGetSkipOptions()`, `PetscViewerBinaryGetSkipInfo()`
455: @*/
456: PetscErrorCode PetscViewerBinarySkipInfo(PetscViewer viewer)
457: {
458:   PetscFunctionBegin;
459:   PetscCall(PetscViewerBinarySetSkipInfo(viewer, PETSC_TRUE));
460:   PetscFunctionReturn(PETSC_SUCCESS);
461: }

463: /*@
464:     PetscViewerBinarySetSkipInfo - Binary file will not have .info file created with it

466:     Not Collective

468:     Input Parameters:
469: +   viewer - PetscViewer context, obtained from `PetscViewerCreate()`
470: -   skip - `PETSC_TRUE` implies the .info file will not be generated

472:     Options Database Key:
473: .   -viewer_binary_skip_info - true indicates do not generate .info file

475:     Level: advanced

477: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySetSkipOptions()`,
478:           `PetscViewerBinaryGetSkipOptions()`, `PetscViewerBinaryGetSkipInfo()`
479: @*/
480: PetscErrorCode PetscViewerBinarySetSkipInfo(PetscViewer viewer, PetscBool skip)
481: {
482:   PetscFunctionBegin;
485:   PetscTryMethod(viewer, "PetscViewerBinarySetSkipInfo_C", (PetscViewer, PetscBool), (viewer, skip));
486:   PetscFunctionReturn(PETSC_SUCCESS);
487: }

489: static PetscErrorCode PetscViewerBinarySetSkipInfo_Binary(PetscViewer viewer, PetscBool skip)
490: {
491:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

493:   PetscFunctionBegin;
494:   vbinary->skipinfo = skip;
495:   PetscFunctionReturn(PETSC_SUCCESS);
496: }

498: /*@
499:     PetscViewerBinaryGetSkipInfo - check if viewer wrote a .info file

501:     Not Collective

503:     Input Parameter:
504: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

506:     Output Parameter:
507: .   skip - `PETSC_TRUE` implies the .info file was not generated

509:     Level: advanced

511:     Note:
512:     This must be called after `PetscViewerSetType()`

514: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`,
515:           `PetscViewerBinarySetSkipOptions()`, `PetscViewerBinarySetSkipInfo()`
516: @*/
517: PetscErrorCode PetscViewerBinaryGetSkipInfo(PetscViewer viewer, PetscBool *skip)
518: {
519:   PetscFunctionBegin;
522:   PetscUseMethod(viewer, "PetscViewerBinaryGetSkipInfo_C", (PetscViewer, PetscBool *), (viewer, skip));
523:   PetscFunctionReturn(PETSC_SUCCESS);
524: }

526: static PetscErrorCode PetscViewerBinaryGetSkipInfo_Binary(PetscViewer viewer, PetscBool *skip)
527: {
528:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

530:   PetscFunctionBegin;
531:   *skip = vbinary->skipinfo;
532:   PetscFunctionReturn(PETSC_SUCCESS);
533: }

535: /*@
536:     PetscViewerBinarySetSkipOptions - do not use the PETSc options database when loading objects

538:     Not Collective

540:     Input Parameters:
541: +   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
542: -   skip - `PETSC_TRUE` means do not use the options from the options database

544:     Options Database Key:
545: .   -viewer_binary_skip_options <true or false> - true means do not use the options from the options database

547:     Level: advanced

549:     Note:
550:     This must be called after `PetscViewerSetType()`

552: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
553:           `PetscViewerBinaryGetSkipOptions()`
554: @*/
555: PetscErrorCode PetscViewerBinarySetSkipOptions(PetscViewer viewer, PetscBool skip)
556: {
557:   PetscFunctionBegin;
560:   PetscTryMethod(viewer, "PetscViewerBinarySetSkipOptions_C", (PetscViewer, PetscBool), (viewer, skip));
561:   PetscFunctionReturn(PETSC_SUCCESS);
562: }

564: static PetscErrorCode PetscViewerBinarySetSkipOptions_Binary(PetscViewer viewer, PetscBool skip)
565: {
566:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

568:   PetscFunctionBegin;
569:   vbinary->skipoptions = skip;
570:   PetscFunctionReturn(PETSC_SUCCESS);
571: }

573: /*@
574:     PetscViewerBinaryGetSkipOptions - checks if viewer uses the PETSc options database when loading objects

576:     Not Collective

578:     Input Parameter:
579: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

581:     Output Parameter:
582: .   skip - `PETSC_TRUE` means do not use

584:     Level: advanced

586:     Note:
587:     This must be called after `PetscViewerSetType()`

589: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
590:           `PetscViewerBinarySetSkipOptions()`
591: @*/
592: PetscErrorCode PetscViewerBinaryGetSkipOptions(PetscViewer viewer, PetscBool *skip)
593: {
594:   PetscFunctionBegin;
597:   PetscUseMethod(viewer, "PetscViewerBinaryGetSkipOptions_C", (PetscViewer, PetscBool *), (viewer, skip));
598:   PetscFunctionReturn(PETSC_SUCCESS);
599: }

601: static PetscErrorCode PetscViewerBinaryGetSkipOptions_Binary(PetscViewer viewer, PetscBool *skip)
602: {
603:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

605:   PetscFunctionBegin;
606:   *skip = vbinary->skipoptions;
607:   PetscFunctionReturn(PETSC_SUCCESS);
608: }

610: /*@
611:     PetscViewerBinarySetSkipHeader - do not write a header with size information on output, just raw data

613:     Not Collective

615:     Input Parameters:
616: +   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
617: -   skip - `PETSC_TRUE` means do not write header

619:     Options Database Key:
620: .   -viewer_binary_skip_header <true or false> - true means do not write header

622:     Level: advanced

624:     Note:
625:       This must be called after `PetscViewerSetType()`

627: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
628:           `PetscViewerBinaryGetSkipHeader()`
629: @*/
630: PetscErrorCode PetscViewerBinarySetSkipHeader(PetscViewer viewer, PetscBool skip)
631: {
632:   PetscFunctionBegin;
635:   PetscTryMethod(viewer, "PetscViewerBinarySetSkipHeader_C", (PetscViewer, PetscBool), (viewer, skip));
636:   PetscFunctionReturn(PETSC_SUCCESS);
637: }

639: static PetscErrorCode PetscViewerBinarySetSkipHeader_Binary(PetscViewer viewer, PetscBool skip)
640: {
641:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

643:   PetscFunctionBegin;
644:   vbinary->skipheader = skip;
645:   PetscFunctionReturn(PETSC_SUCCESS);
646: }

648: /*@
649:     PetscViewerBinaryGetSkipHeader - checks whether to write a header with size information on output, or just raw data

651:     Not Collective

653:     Input Parameter:
654: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

656:     Output Parameter:
657: .   skip - `PETSC_TRUE` means do not write header

659:     Level: advanced

661:     Notes:
662:     This must be called after PetscViewerSetType()

664:     Returns `PETSC_FALSE` for `PETSCSOCKETVIEWER`, you cannot skip the header for it.

666: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
667:           `PetscViewerBinarySetSkipHeader()`
668: @*/
669: PetscErrorCode PetscViewerBinaryGetSkipHeader(PetscViewer viewer, PetscBool *skip)
670: {
671:   PetscFunctionBegin;
674:   PetscUseMethod(viewer, "PetscViewerBinaryGetSkipHeader_C", (PetscViewer, PetscBool *), (viewer, skip));
675:   PetscFunctionReturn(PETSC_SUCCESS);
676: }

678: static PetscErrorCode PetscViewerBinaryGetSkipHeader_Binary(PetscViewer viewer, PetscBool *skip)
679: {
680:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

682:   PetscFunctionBegin;
683:   *skip = vbinary->skipheader;
684:   PetscFunctionReturn(PETSC_SUCCESS);
685: }

687: /*@C
688:     PetscViewerBinaryGetInfoPointer - Extracts the file pointer for the ASCII
689:           info file associated with a binary file.

691:     Not Collective; No Fortran Support

693:     Input Parameter:
694: .   viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`

696:     Output Parameter:
697: .   file - file pointer  Always returns NULL if not a binary viewer

699:     Level: advanced

701:     Note:
702:       For writable binary `PetscViewer`s, the file pointer will only be valid for the
703:     first processor in the communicator that shares the `PetscViewer`.

705: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`
706: @*/
707: PetscErrorCode PetscViewerBinaryGetInfoPointer(PetscViewer viewer, FILE **file)
708: {
709:   PetscFunctionBegin;
712:   *file = NULL;
713:   PetscTryMethod(viewer, "PetscViewerBinaryGetInfoPointer_C", (PetscViewer, FILE **), (viewer, file));
714:   PetscFunctionReturn(PETSC_SUCCESS);
715: }

717: static PetscErrorCode PetscViewerBinaryGetInfoPointer_Binary(PetscViewer viewer, FILE **file)
718: {
719:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

721:   PetscFunctionBegin;
722:   PetscCall(PetscViewerSetUp(viewer));
723:   *file = vbinary->fdes_info;
724:   if (viewer->format == PETSC_VIEWER_BINARY_MATLAB && !vbinary->matlabheaderwritten) {
725:     if (vbinary->fdes_info) {
726:       FILE *info = vbinary->fdes_info;
727:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- begin code written by PetscViewerBinary for MATLAB format ---#\n"));
728:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ Set.filename = '%s';\n", vbinary->filename));
729:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ fd = PetscOpenFile(Set.filename);\n"));
730:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n"));
731:     }
732:     vbinary->matlabheaderwritten = PETSC_TRUE;
733:   }
734:   PetscFunctionReturn(PETSC_SUCCESS);
735: }

737: #if defined(PETSC_HAVE_MPIIO)
738: static PetscErrorCode PetscViewerFileClose_BinaryMPIIO(PetscViewer v)
739: {
740:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;

742:   PetscFunctionBegin;
743:   if (vbinary->mfdes != MPI_FILE_NULL) PetscCallMPI(MPI_File_close(&vbinary->mfdes));
744:   if (vbinary->mfsub != MPI_FILE_NULL) PetscCallMPI(MPI_File_close(&vbinary->mfsub));
745:   vbinary->moff = 0;
746:   PetscFunctionReturn(PETSC_SUCCESS);
747: }
748: #endif

750: static PetscErrorCode PetscViewerFileClose_BinarySTDIO(PetscViewer v)
751: {
752:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;

754:   PetscFunctionBegin;
755:   if (vbinary->fdes != -1) {
756:     PetscCall(PetscBinaryClose(vbinary->fdes));
757:     vbinary->fdes = -1;
758:     if (vbinary->storecompressed) {
759:       char        cmd[8 + PETSC_MAX_PATH_LEN], out[64 + PETSC_MAX_PATH_LEN] = "";
760:       const char *gzfilename = vbinary->ogzfilename ? vbinary->ogzfilename : vbinary->filename;
761:       /* compress the file */
762:       PetscCall(PetscStrncpy(cmd, "gzip -f ", sizeof(cmd)));
763:       PetscCall(PetscStrlcat(cmd, gzfilename, sizeof(cmd)));
764: #if defined(PETSC_HAVE_POPEN)
765:       {
766:         FILE *fp;
767:         PetscCall(PetscPOpen(PETSC_COMM_SELF, NULL, cmd, "r", &fp));
768:         PetscCheck(!fgets(out, (int)(sizeof(out) - 1), fp), PETSC_COMM_SELF, PETSC_ERR_LIB, "Error from command %s\n%s", cmd, out);
769:         PetscCall(PetscPClose(PETSC_COMM_SELF, fp));
770:       }
771: #endif
772:     }
773:   }
774:   PetscCall(PetscFree(vbinary->ogzfilename));
775:   PetscFunctionReturn(PETSC_SUCCESS);
776: }

778: static PetscErrorCode PetscViewerFileClose_BinaryInfo(PetscViewer v)
779: {
780:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;

782:   PetscFunctionBegin;
783:   if (v->format == PETSC_VIEWER_BINARY_MATLAB && vbinary->matlabheaderwritten) {
784:     if (vbinary->fdes_info) {
785:       FILE *info = vbinary->fdes_info;
786:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- begin code written by PetscViewerBinary for MATLAB format ---#\n"));
787:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ close(fd);\n"));
788:       PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n"));
789:     }
790:   }
791:   if (vbinary->fdes_info) {
792:     FILE *info         = vbinary->fdes_info;
793:     vbinary->fdes_info = NULL;
794:     PetscCheck(!fclose(info), PETSC_COMM_SELF, PETSC_ERR_SYS, "fclose() failed on file");
795:   }
796:   PetscFunctionReturn(PETSC_SUCCESS);
797: }

799: static PetscErrorCode PetscViewerFileClose_Binary(PetscViewer v)
800: {
801:   PetscFunctionBegin;
802: #if defined(PETSC_HAVE_MPIIO)
803:   PetscCall(PetscViewerFileClose_BinaryMPIIO(v));
804: #endif
805:   PetscCall(PetscViewerFileClose_BinarySTDIO(v));
806:   PetscCall(PetscViewerFileClose_BinaryInfo(v));
807:   PetscFunctionReturn(PETSC_SUCCESS);
808: }

810: static PetscErrorCode PetscViewerDestroy_Binary(PetscViewer v)
811: {
812:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;

814:   PetscFunctionBegin;
815:   PetscCall(PetscViewerFileClose_Binary(v));
816:   PetscCall(PetscFree(vbinary->filename));
817:   PetscCall(PetscFree(vbinary));
818:   PetscCall(PetscViewerBinaryClearFunctionList(v));
819:   PetscFunctionReturn(PETSC_SUCCESS);
820: }

822: /*@C
823:    PetscViewerBinaryOpen - Opens a file for binary input/output.

825:    Collective

827:    Input Parameters:
828: +  comm - MPI communicator
829: .  name - name of file
830: -  mode - open mode of file
831: .vb
832:     FILE_MODE_WRITE - create new file for binary output
833:     FILE_MODE_READ - open existing file for binary input
834:     FILE_MODE_APPEND - open existing file for binary output
835: .ve

837:    Output Parameter:
838: .  viewer - PetscViewer for binary input/output to use with the specified file

840:     Options Database Keys:
841: +    -viewer_binary_filename <name> - name of file to use
842: .    -viewer_binary_skip_info - true to skip opening an info file
843: .    -viewer_binary_skip_options - true to not use options database while creating viewer
844: .    -viewer_binary_skip_header - true to skip output object headers to the file
845: -    -viewer_binary_mpiio - true to use MPI-IO for input and output to the file (more scalable for large problems)

847:    Level: beginner

849:    Note:
850:    This `PetscViewer` should be destroyed with `PetscViewerDestroy()`.

852:     For reading files, the filename may begin with ftp:// or http:// and/or
853:     end with .gz; in this case file is brought over and uncompressed.

855:     For creating files, if the file name ends with .gz it is automatically
856:     compressed when closed.

858: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
859:           `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
860:           `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`, `PetscViewerBinarySetUseMPIIO()`,
861:           `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinaryGetMPIIOOffset()`
862: @*/
863: PetscErrorCode PetscViewerBinaryOpen(MPI_Comm comm, const char name[], PetscFileMode mode, PetscViewer *viewer)
864: {
865:   PetscFunctionBegin;
866:   PetscCall(PetscViewerCreate(comm, viewer));
867:   PetscCall(PetscViewerSetType(*viewer, PETSCVIEWERBINARY));
868:   PetscCall(PetscViewerFileSetMode(*viewer, mode));
869:   PetscCall(PetscViewerFileSetName(*viewer, name));
870:   PetscCall(PetscViewerSetFromOptions(*viewer));
871:   PetscFunctionReturn(PETSC_SUCCESS);
872: }

874: #if defined(PETSC_HAVE_MPIIO)
875: static PetscErrorCode PetscViewerBinaryWriteReadMPIIO(PetscViewer viewer, void *data, PetscInt num, PetscInt *count, PetscDataType dtype, PetscBool write)
876: {
877:   MPI_Comm            comm    = PetscObjectComm((PetscObject)viewer);
878:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
879:   MPI_File            mfdes   = vbinary->mfdes;
880:   MPI_Datatype        mdtype;
881:   PetscMPIInt         rank, cnt;
882:   MPI_Status          status;
883:   MPI_Aint            ul, dsize;

885:   PetscFunctionBegin;
886:   PetscCallMPI(MPI_Comm_rank(comm, &rank));
887:   PetscCall(PetscMPIIntCast(num, &cnt));
888:   PetscCall(PetscDataTypeToMPIDataType(dtype, &mdtype));
889:   if (write) {
890:     if (rank == 0) PetscCall(MPIU_File_write_at(mfdes, vbinary->moff, data, cnt, mdtype, &status));
891:   } else {
892:     if (rank == 0) {
893:       PetscCall(MPIU_File_read_at(mfdes, vbinary->moff, data, cnt, mdtype, &status));
894:       if (cnt > 0) PetscCallMPI(MPI_Get_count(&status, mdtype, &cnt));
895:     }
896:     PetscCallMPI(MPI_Bcast(&cnt, 1, MPI_INT, 0, comm));
897:     PetscCallMPI(MPI_Bcast(data, cnt, mdtype, 0, comm));
898:   }
899:   PetscCallMPI(MPI_Type_get_extent(mdtype, &ul, &dsize));
900:   vbinary->moff += dsize * cnt;
901:   if (count) *count = cnt;
902:   PetscFunctionReturn(PETSC_SUCCESS);
903: }
904: #endif

906: /*@C
907:    PetscViewerBinaryRead - Reads from a binary file, all processors get the same result

909:    Collective

911:    Input Parameters:
912: +  viewer - the binary viewer
913: .  data - location of the data to be written
914: .  num - number of items of data to read
915: -  dtype - type of data to read

917:    Output Parameter:
918: .  count - number of items of data actually read, or `NULL`.

920:    Level: beginner

922: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
923:           `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
924:           `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
925: @*/
926: PetscErrorCode PetscViewerBinaryRead(PetscViewer viewer, void *data, PetscInt num, PetscInt *count, PetscDataType dtype)
927: {
928:   PetscViewer_Binary *vbinary;

930:   PetscFunctionBegin;
933:   PetscCall(PetscViewerSetUp(viewer));
934:   vbinary = (PetscViewer_Binary *)viewer->data;
935: #if defined(PETSC_HAVE_MPIIO)
936:   if (vbinary->usempiio) {
937:     PetscCall(PetscViewerBinaryWriteReadMPIIO(viewer, data, num, count, dtype, PETSC_FALSE));
938:   } else {
939: #endif
940:     PetscCall(PetscBinarySynchronizedRead(PetscObjectComm((PetscObject)viewer), vbinary->fdes, data, num, count, dtype));
941: #if defined(PETSC_HAVE_MPIIO)
942:   }
943: #endif
944:   PetscFunctionReturn(PETSC_SUCCESS);
945: }

947: /*@C
948:    PetscViewerBinaryWrite - writes to a binary file, only from the first MPI rank

950:    Collective

952:    Input Parameters:
953: +  viewer - the binary viewer
954: .  data - location of data
955: .  count - number of items of data to write
956: -  dtype - type of data to write

958:    Level: beginner

960: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
961:           `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`, `PetscDataType`
962:           `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
963: @*/
964: PetscErrorCode PetscViewerBinaryWrite(PetscViewer viewer, const void *data, PetscInt count, PetscDataType dtype)
965: {
966:   PetscViewer_Binary *vbinary;

968:   PetscFunctionBegin;
971:   PetscCall(PetscViewerSetUp(viewer));
972:   vbinary = (PetscViewer_Binary *)viewer->data;
973: #if defined(PETSC_HAVE_MPIIO)
974:   if (vbinary->usempiio) {
975:     PetscCall(PetscViewerBinaryWriteReadMPIIO(viewer, (void *)data, count, NULL, dtype, PETSC_TRUE));
976:   } else {
977: #endif
978:     PetscCall(PetscBinarySynchronizedWrite(PetscObjectComm((PetscObject)viewer), vbinary->fdes, data, count, dtype));
979: #if defined(PETSC_HAVE_MPIIO)
980:   }
981: #endif
982:   PetscFunctionReturn(PETSC_SUCCESS);
983: }

985: static PetscErrorCode PetscViewerBinaryWriteReadAll(PetscViewer viewer, PetscBool write, void *data, PetscInt count, PetscInt start, PetscInt total, PetscDataType dtype)
986: {
987:   MPI_Comm              comm = PetscObjectComm((PetscObject)viewer);
988:   PetscMPIInt           size, rank;
989:   MPI_Datatype          mdtype;
990:   PETSC_UNUSED MPI_Aint lb;
991:   MPI_Aint              dsize;
992:   PetscBool             useMPIIO;

994:   PetscFunctionBegin;
999:   PetscCall(PetscViewerSetUp(viewer));

1001:   PetscCall(PetscDataTypeToMPIDataType(dtype, &mdtype));
1002:   PetscCallMPI(MPI_Type_get_extent(mdtype, &lb, &dsize));
1003:   PetscCallMPI(MPI_Comm_rank(comm, &rank));
1004:   PetscCallMPI(MPI_Comm_size(comm, &size));

1006:   PetscCall(PetscViewerBinaryGetUseMPIIO(viewer, &useMPIIO));
1007: #if defined(PETSC_HAVE_MPIIO)
1008:   if (useMPIIO) {
1009:     MPI_File    mfdes;
1010:     MPI_Offset  off;
1011:     PetscMPIInt cnt;

1013:     if (start == PETSC_DETERMINE) {
1014:       PetscCallMPI(MPI_Scan(&count, &start, 1, MPIU_INT, MPI_SUM, comm));
1015:       start -= count;
1016:     }
1017:     if (total == PETSC_DETERMINE) {
1018:       total = start + count;
1019:       PetscCallMPI(MPI_Bcast(&total, 1, MPIU_INT, size - 1, comm));
1020:     }
1021:     PetscCall(PetscMPIIntCast(count, &cnt));
1022:     PetscCall(PetscViewerBinaryGetMPIIODescriptor(viewer, &mfdes));
1023:     PetscCall(PetscViewerBinaryGetMPIIOOffset(viewer, &off));
1024:     off += (MPI_Offset)(start * dsize);
1025:     if (write) {
1026:       PetscCall(MPIU_File_write_at_all(mfdes, off, data, cnt, mdtype, MPI_STATUS_IGNORE));
1027:     } else {
1028:       PetscCall(MPIU_File_read_at_all(mfdes, off, data, cnt, mdtype, MPI_STATUS_IGNORE));
1029:     }
1030:     off = (MPI_Offset)(total * dsize);
1031:     PetscCall(PetscViewerBinaryAddMPIIOOffset(viewer, off));
1032:     PetscFunctionReturn(PETSC_SUCCESS);
1033:   }
1034: #endif
1035:   {
1036:     int         fdes;
1037:     char       *workbuf = NULL;
1038:     PetscInt    tcount = rank == 0 ? 0 : count, maxcount = 0, message_count, flowcontrolcount;
1039:     PetscMPIInt tag, cnt, maxcnt, scnt = 0, rcnt = 0, j;
1040:     MPI_Status  status;

1042:     PetscCall(PetscCommGetNewTag(comm, &tag));
1043:     PetscCallMPI(MPI_Reduce(&tcount, &maxcount, 1, MPIU_INT, MPI_MAX, 0, comm));
1044:     PetscCall(PetscMPIIntCast(maxcount, &maxcnt));
1045:     PetscCall(PetscMPIIntCast(count, &cnt));

1047:     PetscCall(PetscViewerBinaryGetDescriptor(viewer, &fdes));
1048:     PetscCall(PetscViewerFlowControlStart(viewer, &message_count, &flowcontrolcount));
1049:     if (rank == 0) {
1050:       PetscCall(PetscMalloc(maxcnt * dsize, &workbuf));
1051:       if (write) {
1052:         PetscCall(PetscBinaryWrite(fdes, data, cnt, dtype));
1053:       } else {
1054:         PetscCall(PetscBinaryRead(fdes, data, cnt, NULL, dtype));
1055:       }
1056:       for (j = 1; j < size; j++) {
1057:         PetscCall(PetscViewerFlowControlStepMain(viewer, j, &message_count, flowcontrolcount));
1058:         if (write) {
1059:           PetscCallMPI(MPI_Recv(workbuf, maxcnt, mdtype, j, tag, comm, &status));
1060:           PetscCallMPI(MPI_Get_count(&status, mdtype, &rcnt));
1061:           PetscCall(PetscBinaryWrite(fdes, workbuf, rcnt, dtype));
1062:         } else {
1063:           PetscCallMPI(MPI_Recv(&scnt, 1, MPI_INT, j, tag, comm, MPI_STATUS_IGNORE));
1064:           PetscCall(PetscBinaryRead(fdes, workbuf, scnt, NULL, dtype));
1065:           PetscCallMPI(MPI_Send(workbuf, scnt, mdtype, j, tag, comm));
1066:         }
1067:       }
1068:       PetscCall(PetscFree(workbuf));
1069:       PetscCall(PetscViewerFlowControlEndMain(viewer, &message_count));
1070:     } else {
1071:       PetscCall(PetscViewerFlowControlStepWorker(viewer, rank, &message_count));
1072:       if (write) {
1073:         PetscCallMPI(MPI_Send(data, cnt, mdtype, 0, tag, comm));
1074:       } else {
1075:         PetscCallMPI(MPI_Send(&cnt, 1, MPI_INT, 0, tag, comm));
1076:         PetscCallMPI(MPI_Recv(data, cnt, mdtype, 0, tag, comm, MPI_STATUS_IGNORE));
1077:       }
1078:       PetscCall(PetscViewerFlowControlEndWorker(viewer, &message_count));
1079:     }
1080:   }
1081:   PetscFunctionReturn(PETSC_SUCCESS);
1082: }

1084: /*@C
1085:    PetscViewerBinaryReadAll - reads from a binary file from all MPI ranks, each rank receives its own portion of the data

1087:    Collective

1089:    Input Parameters:
1090: +  viewer - the binary viewer
1091: .  data - location of data
1092: .  count - local number of items of data to read
1093: .  start - local start, can be `PETSC_DETERMINE`
1094: .  total - global number of items of data to read, can be `PETSC_DETERMINE`
1095: -  dtype - type of data to read

1097:    Level: advanced

1099: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryRead()`, `PetscViewerBinaryWriteAll()`
1100: @*/
1101: PetscErrorCode PetscViewerBinaryReadAll(PetscViewer viewer, void *data, PetscInt count, PetscInt start, PetscInt total, PetscDataType dtype)
1102: {
1103:   PetscFunctionBegin;
1104:   PetscCall(PetscViewerBinaryWriteReadAll(viewer, PETSC_FALSE, data, count, start, total, dtype));
1105:   PetscFunctionReturn(PETSC_SUCCESS);
1106: }

1108: /*@C
1109:    PetscViewerBinaryWriteAll - writes to a binary file from all MPI ranks, each rank writes its own portion of the data

1111:    Collective

1113:    Input Parameters:
1114: +  viewer - the binary viewer
1115: .  data - location of data
1116: .  count - local number of items of data to write
1117: .  start - local start, can be `PETSC_DETERMINE`
1118: .  total - global number of items of data to write, can be `PETSC_DETERMINE`
1119: -  dtype - type of data to write

1121:    Level: advanced

1123: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryWriteAll()`, `PetscViewerBinaryReadAll()`
1124: @*/
1125: PetscErrorCode PetscViewerBinaryWriteAll(PetscViewer viewer, const void *data, PetscInt count, PetscInt start, PetscInt total, PetscDataType dtype)
1126: {
1127:   PetscFunctionBegin;
1128:   PetscCall(PetscViewerBinaryWriteReadAll(viewer, PETSC_TRUE, (void *)data, count, start, total, dtype));
1129:   PetscFunctionReturn(PETSC_SUCCESS);
1130: }

1132: /*@C
1133:    PetscViewerBinaryWriteStringArray - writes to a binary file, only from the first MPI rank, an array of strings

1135:    Collective

1137:    Input Parameters:
1138: +  viewer - the binary viewer
1139: -  data - location of the array of strings

1141:    Level: intermediate

1143:     Note:
1144:     The array of strings must be `NULL` terminated

1146: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
1147:           `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
1148:           `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
1149: @*/
1150: PetscErrorCode PetscViewerBinaryWriteStringArray(PetscViewer viewer, const char *const *data)
1151: {
1152:   PetscInt i, n = 0, *sizes;
1153:   size_t   len;

1155:   PetscFunctionBegin;
1156:   PetscCall(PetscViewerSetUp(viewer));
1157:   /* count number of strings */
1158:   while (data[n++])
1159:     ;
1160:   n--;
1161:   PetscCall(PetscMalloc1(n + 1, &sizes));
1162:   sizes[0] = n;
1163:   for (i = 0; i < n; i++) {
1164:     PetscCall(PetscStrlen(data[i], &len));
1165:     sizes[i + 1] = (PetscInt)len + 1; /* size includes space for the null terminator */
1166:   }
1167:   PetscCall(PetscViewerBinaryWrite(viewer, sizes, n + 1, PETSC_INT));
1168:   for (i = 0; i < n; i++) PetscCall(PetscViewerBinaryWrite(viewer, (void *)data[i], sizes[i + 1], PETSC_CHAR));
1169:   PetscCall(PetscFree(sizes));
1170:   PetscFunctionReturn(PETSC_SUCCESS);
1171: }

1173: /*@C
1174:    PetscViewerBinaryReadStringArray - reads a binary file an array of strings to all MPI ranks

1176:    Collective

1178:    Input Parameter:
1179: .  viewer - the binary viewer

1181:    Output Parameter:
1182: .  data - location of the array of strings

1184:    Level: intermediate

1186:     Note:
1187:     The array of strings must `NULL` terminated

1189: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
1190:           `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
1191:           `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
1192: @*/
1193: PetscErrorCode PetscViewerBinaryReadStringArray(PetscViewer viewer, char ***data)
1194: {
1195:   PetscInt i, n, *sizes, N = 0;

1197:   PetscFunctionBegin;
1198:   PetscCall(PetscViewerSetUp(viewer));
1199:   /* count number of strings */
1200:   PetscCall(PetscViewerBinaryRead(viewer, &n, 1, NULL, PETSC_INT));
1201:   PetscCall(PetscMalloc1(n, &sizes));
1202:   PetscCall(PetscViewerBinaryRead(viewer, sizes, n, NULL, PETSC_INT));
1203:   for (i = 0; i < n; i++) N += sizes[i];
1204:   PetscCall(PetscMalloc((n + 1) * sizeof(char *) + N * sizeof(char), data));
1205:   (*data)[0] = (char *)((*data) + n + 1);
1206:   for (i = 1; i < n; i++) (*data)[i] = (*data)[i - 1] + sizes[i - 1];
1207:   PetscCall(PetscViewerBinaryRead(viewer, (*data)[0], N, NULL, PETSC_CHAR));
1208:   (*data)[n] = NULL;
1209:   PetscCall(PetscFree(sizes));
1210:   PetscFunctionReturn(PETSC_SUCCESS);
1211: }

1213: /*@C
1214:      PetscViewerFileSetMode - Sets the open mode of file

1216:     Logically Collective

1218:   Input Parameters:
1219: +  viewer - the `PetscViewer`; must be a a `PETSCVIEWERBINARY`, `PETSCVIEWERMATLAB`, `PETSCVIEWERHDF5`, or `PETSCVIEWERASCII`  `PetscViewer`
1220: -  mode - open mode of file
1221: .vb
1222:     FILE_MODE_WRITE - create new file for output
1223:     FILE_MODE_READ - open existing file for input
1224:     FILE_MODE_APPEND - open existing file for output
1225: .ve

1227:   Level: advanced

1229: .seealso: [](sec_viewers), `PetscViewerFileSetMode()`, `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinaryOpen()`
1230: @*/
1231: PetscErrorCode PetscViewerFileSetMode(PetscViewer viewer, PetscFileMode mode)
1232: {
1233:   PetscFunctionBegin;
1236:   PetscCheck(mode != FILE_MODE_UNDEFINED, PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Cannot set FILE_MODE_UNDEFINED");
1237:   PetscCheck(mode >= FILE_MODE_UNDEFINED && mode <= FILE_MODE_APPEND_UPDATE, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ARG_OUTOFRANGE, "Invalid file mode %d", (int)mode);
1238:   PetscTryMethod(viewer, "PetscViewerFileSetMode_C", (PetscViewer, PetscFileMode), (viewer, mode));
1239:   PetscFunctionReturn(PETSC_SUCCESS);
1240: }

1242: static PetscErrorCode PetscViewerFileSetMode_Binary(PetscViewer viewer, PetscFileMode mode)
1243: {
1244:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

1246:   PetscFunctionBegin;
1247:   PetscCheck(!viewer->setupcalled || vbinary->filemode == mode, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Cannot change mode to %s after setup", PetscFileModes[mode]);
1248:   vbinary->filemode = mode;
1249:   PetscFunctionReturn(PETSC_SUCCESS);
1250: }

1252: /*@C
1253:      PetscViewerFileGetMode - Gets the open mode of file

1255:     Not Collective

1257:   Input Parameter:
1258: .  viewer - the `PetscViewer`; must be a `PETSCVIEWERBINARY`, `PETSCVIEWERMATLAB`, `PETSCVIEWERHDF5`, or `PETSCVIEWERASCII`  `PetscViewer`

1260:   Output Parameter:
1261: .  mode - open mode of file
1262: .vb
1263:     FILE_MODE_WRITE - create new file for binary output
1264:     FILE_MODE_READ - open existing file for binary input
1265:     FILE_MODE_APPEND - open existing file for binary output
1266: .ve

1268:   Level: advanced

1270: .seealso: [](sec_viewers), `PetscViewerFileSetMode()`, `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinaryOpen()`
1271: @*/
1272: PetscErrorCode PetscViewerFileGetMode(PetscViewer viewer, PetscFileMode *mode)
1273: {
1274:   PetscFunctionBegin;
1277:   PetscUseMethod(viewer, "PetscViewerFileGetMode_C", (PetscViewer, PetscFileMode *), (viewer, mode));
1278:   PetscFunctionReturn(PETSC_SUCCESS);
1279: }

1281: static PetscErrorCode PetscViewerFileGetMode_Binary(PetscViewer viewer, PetscFileMode *mode)
1282: {
1283:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

1285:   PetscFunctionBegin;
1286:   *mode = vbinary->filemode;
1287:   PetscFunctionReturn(PETSC_SUCCESS);
1288: }

1290: static PetscErrorCode PetscViewerFileSetName_Binary(PetscViewer viewer, const char name[])
1291: {
1292:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

1294:   PetscFunctionBegin;
1295:   if (viewer->setupcalled && vbinary->filename) {
1296:     /* gzip can be run after the file with the previous filename has been closed */
1297:     PetscCall(PetscFree(vbinary->ogzfilename));
1298:     PetscCall(PetscStrallocpy(vbinary->filename, &vbinary->ogzfilename));
1299:   }
1300:   PetscCall(PetscFree(vbinary->filename));
1301:   PetscCall(PetscStrallocpy(name, &vbinary->filename));
1302:   viewer->setupcalled = PETSC_FALSE;
1303:   PetscFunctionReturn(PETSC_SUCCESS);
1304: }

1306: static PetscErrorCode PetscViewerFileGetName_Binary(PetscViewer viewer, const char **name)
1307: {
1308:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;

1310:   PetscFunctionBegin;
1311:   *name = vbinary->filename;
1312:   PetscFunctionReturn(PETSC_SUCCESS);
1313: }

1315: #if defined(PETSC_HAVE_MPIIO)
1316: static PetscErrorCode PetscViewerFileSetUp_BinaryMPIIO(PetscViewer viewer)
1317: {
1318:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1319:   int                 amode;

1321:   PetscFunctionBegin;
1322:   vbinary->storecompressed = PETSC_FALSE;

1324:   vbinary->moff = 0;
1325:   switch (vbinary->filemode) {
1326:   case FILE_MODE_READ:
1327:     amode = MPI_MODE_RDONLY;
1328:     break;
1329:   case FILE_MODE_WRITE:
1330:     amode = MPI_MODE_WRONLY | MPI_MODE_CREATE;
1331:     break;
1332:   case FILE_MODE_APPEND:
1333:     amode = MPI_MODE_WRONLY | MPI_MODE_CREATE | MPI_MODE_APPEND;
1334:     break;
1335:   case FILE_MODE_UNDEFINED:
1336:     SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode() before PetscViewerSetUp()");
1337:   default:
1338:     SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Unsupported file mode %s", PetscFileModes[vbinary->filemode]);
1339:   }
1340:   PetscCallMPI(MPI_File_open(PetscObjectComm((PetscObject)viewer), vbinary->filename, amode, MPI_INFO_NULL, &vbinary->mfdes));
1341:   /*
1342:       The MPI standard does not have MPI_MODE_TRUNCATE. We emulate this behavior by setting the file size to zero.
1343:   */
1344:   if (vbinary->filemode == FILE_MODE_WRITE) PetscCallMPI(MPI_File_set_size(vbinary->mfdes, 0));
1345:   /*
1346:       Initially, all processes view the file as a linear byte stream. Therefore, for files opened with MPI_MODE_APPEND,
1347:       MPI_File_get_position[_shared](fh, &offset) returns the absolute byte position at the end of file.
1348:       Otherwise, we would need to call MPI_File_get_byte_offset(fh, offset, &byte_offset) to convert
1349:       the offset in etype units to an absolute byte position.
1350:    */
1351:   if (vbinary->filemode == FILE_MODE_APPEND) PetscCallMPI(MPI_File_get_position(vbinary->mfdes, &vbinary->moff));
1352:   PetscFunctionReturn(PETSC_SUCCESS);
1353: }
1354: #endif

1356: static PetscErrorCode PetscViewerFileSetUp_BinarySTDIO(PetscViewer viewer)
1357: {
1358:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1359:   const char         *fname;
1360:   char                bname[PETSC_MAX_PATH_LEN], *gz = NULL;
1361:   PetscBool           found;
1362:   PetscMPIInt         rank;

1364:   PetscFunctionBegin;
1365:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));

1367:   /* if file name ends in .gz strip that off and note user wants file compressed */
1368:   vbinary->storecompressed = PETSC_FALSE;
1369:   if (vbinary->filemode == FILE_MODE_WRITE) {
1370:     PetscCall(PetscStrstr(vbinary->filename, ".gz", &gz));
1371:     if (gz && gz[3] == 0) {
1372:       *gz                      = 0;
1373:       vbinary->storecompressed = PETSC_TRUE;
1374:     }
1375:   }
1376: #if !defined(PETSC_HAVE_POPEN)
1377:   PetscCheck(!vbinary->storecompressed, PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP_SYS, "Cannot run gzip on this machine");
1378: #endif

1380:   fname = vbinary->filename;
1381:   if (vbinary->filemode == FILE_MODE_READ) { /* possibly get the file from remote site or compressed file */
1382:     PetscCall(PetscFileRetrieve(PetscObjectComm((PetscObject)viewer), fname, bname, PETSC_MAX_PATH_LEN, &found));
1383:     PetscCheck(found, PetscObjectComm((PetscObject)viewer), PETSC_ERR_FILE_OPEN, "Cannot locate file: %s", fname);
1384:     fname = bname;
1385:   }

1387:   vbinary->fdes = -1;
1388:   if (rank == 0) { /* only first processor opens file*/
1389:     PetscFileMode mode = vbinary->filemode;
1390:     if (mode == FILE_MODE_APPEND) {
1391:       /* check if asked to append to a non-existing file */
1392:       PetscCall(PetscTestFile(fname, '\0', &found));
1393:       if (!found) mode = FILE_MODE_WRITE;
1394:     }
1395:     PetscCall(PetscBinaryOpen(fname, mode, &vbinary->fdes));
1396:   }
1397:   PetscFunctionReturn(PETSC_SUCCESS);
1398: }

1400: static PetscErrorCode PetscViewerFileSetUp_BinaryInfo(PetscViewer viewer)
1401: {
1402:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1403:   PetscMPIInt         rank;
1404:   PetscBool           found;

1406:   PetscFunctionBegin;
1407:   vbinary->fdes_info = NULL;
1408:   PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));
1409:   if (!vbinary->skipinfo && (vbinary->filemode == FILE_MODE_READ || rank == 0)) {
1410:     char infoname[PETSC_MAX_PATH_LEN], iname[PETSC_MAX_PATH_LEN], *gz;

1412:     PetscCall(PetscStrncpy(infoname, vbinary->filename, sizeof(infoname)));
1413:     /* remove .gz if it ends file name */
1414:     PetscCall(PetscStrstr(infoname, ".gz", &gz));
1415:     if (gz && gz[3] == 0) *gz = 0;

1417:     PetscCall(PetscStrlcat(infoname, ".info", sizeof(infoname)));
1418:     if (vbinary->filemode == FILE_MODE_READ) {
1419:       PetscCall(PetscFixFilename(infoname, iname));
1420:       PetscCall(PetscFileRetrieve(PetscObjectComm((PetscObject)viewer), iname, infoname, PETSC_MAX_PATH_LEN, &found));
1421:       if (found) PetscCall(PetscOptionsInsertFile(PetscObjectComm((PetscObject)viewer), ((PetscObject)viewer)->options, infoname, PETSC_FALSE));
1422:     } else if (rank == 0) { /* write or append */
1423:       const char *omode  = (vbinary->filemode == FILE_MODE_APPEND) ? "a" : "w";
1424:       vbinary->fdes_info = fopen(infoname, omode);
1425:       PetscCheck(vbinary->fdes_info, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open .info file %s for writing", infoname);
1426:     }
1427:   }
1428:   PetscFunctionReturn(PETSC_SUCCESS);
1429: }

1431: static PetscErrorCode PetscViewerSetUp_Binary(PetscViewer viewer)
1432: {
1433:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1434:   PetscBool           usempiio;

1436:   PetscFunctionBegin;
1437:   if (!vbinary->setfromoptionscalled) PetscCall(PetscViewerSetFromOptions(viewer));
1438:   PetscCheck(vbinary->filename, PETSC_COMM_SELF, PETSC_ERR_ORDER, "Must call PetscViewerFileSetName()");
1439:   PetscCheck(vbinary->filemode != (PetscFileMode)-1, PETSC_COMM_SELF, PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode()");
1440:   PetscCall(PetscViewerFileClose_Binary(viewer));

1442:   PetscCall(PetscViewerBinaryGetUseMPIIO(viewer, &usempiio));
1443:   if (usempiio) {
1444: #if defined(PETSC_HAVE_MPIIO)
1445:     PetscCall(PetscViewerFileSetUp_BinaryMPIIO(viewer));
1446: #endif
1447:   } else {
1448:     PetscCall(PetscViewerFileSetUp_BinarySTDIO(viewer));
1449:   }
1450:   PetscCall(PetscViewerFileSetUp_BinaryInfo(viewer));

1452:   PetscCall(PetscLogObjectState((PetscObject)viewer, "File: %s", vbinary->filename));
1453:   PetscFunctionReturn(PETSC_SUCCESS);
1454: }

1456: static PetscErrorCode PetscViewerView_Binary(PetscViewer v, PetscViewer viewer)
1457: {
1458:   PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
1459:   const char         *fname   = vbinary->filename ? vbinary->filename : "not yet set";
1460:   const char         *fmode   = vbinary->filemode != (PetscFileMode)-1 ? PetscFileModes[vbinary->filemode] : "not yet set";
1461:   PetscBool           usempiio;

1463:   PetscFunctionBegin;
1464:   PetscCall(PetscViewerBinaryGetUseMPIIO(v, &usempiio));
1465:   PetscCall(PetscViewerASCIIPrintf(viewer, "Filename: %s\n", fname));
1466:   PetscCall(PetscViewerASCIIPrintf(viewer, "Mode: %s (%s)\n", fmode, usempiio ? "mpiio" : "stdio"));
1467:   PetscFunctionReturn(PETSC_SUCCESS);
1468: }

1470: static PetscErrorCode PetscViewerSetFromOptions_Binary(PetscViewer viewer, PetscOptionItems *PetscOptionsObject)
1471: {
1472:   PetscViewer_Binary *binary = (PetscViewer_Binary *)viewer->data;
1473:   char                defaultname[PETSC_MAX_PATH_LEN];
1474:   PetscBool           flg;

1476:   PetscFunctionBegin;
1477:   if (viewer->setupcalled) PetscFunctionReturn(PETSC_SUCCESS);
1478:   PetscOptionsHeadBegin(PetscOptionsObject, "Binary PetscViewer Options");
1479:   PetscCall(PetscSNPrintf(defaultname, PETSC_MAX_PATH_LEN - 1, "binaryoutput"));
1480:   PetscCall(PetscOptionsString("-viewer_binary_filename", "Specify filename", "PetscViewerFileSetName", defaultname, defaultname, sizeof(defaultname), &flg));
1481:   if (flg) PetscCall(PetscViewerFileSetName_Binary(viewer, defaultname));
1482:   PetscCall(PetscOptionsBool("-viewer_binary_skip_info", "Skip writing/reading .info file", "PetscViewerBinarySetSkipInfo", binary->skipinfo, &binary->skipinfo, NULL));
1483:   PetscCall(PetscOptionsBool("-viewer_binary_skip_options", "Skip parsing Vec/Mat load options", "PetscViewerBinarySetSkipOptions", binary->skipoptions, &binary->skipoptions, NULL));
1484:   PetscCall(PetscOptionsBool("-viewer_binary_skip_header", "Skip writing/reading header information", "PetscViewerBinarySetSkipHeader", binary->skipheader, &binary->skipheader, NULL));
1485: #if defined(PETSC_HAVE_MPIIO)
1486:   PetscCall(PetscOptionsBool("-viewer_binary_mpiio", "Use MPI-IO functionality to write/read binary file", "PetscViewerBinarySetUseMPIIO", binary->usempiio, &binary->usempiio, NULL));
1487: #else
1488:   PetscCall(PetscOptionsBool("-viewer_binary_mpiio", "Use MPI-IO functionality to write/read binary file (NOT AVAILABLE)", "PetscViewerBinarySetUseMPIIO", PETSC_FALSE, NULL, NULL));
1489: #endif
1490:   PetscOptionsHeadEnd();
1491:   binary->setfromoptionscalled = PETSC_TRUE;
1492:   PetscFunctionReturn(PETSC_SUCCESS);
1493: }

1495: /*MC
1496:    PETSCVIEWERBINARY - A viewer that saves to binary files

1498:   Level: beginner

1500: .seealso: [](sec_viewers), `PetscViewerBinaryOpen()`, `PETSC_VIEWER_STDOUT_()`, `PETSC_VIEWER_STDOUT_SELF`, `PETSC_VIEWER_STDOUT_WORLD`, `PetscViewerCreate()`, `PetscViewerASCIIOpen()`,
1501:           `PetscViewerMatlabOpen()`, `VecView()`, `DMView()`, `PetscViewerMatlabPutArray()`, `PETSCVIEWERASCII`, `PETSCVIEWERMATLAB`, `PETSCVIEWERDRAW`, `PETSCVIEWERSOCKET`
1502:           `PetscViewerFileSetName()`, `PetscViewerFileSetMode()`, `PetscViewerFormat`, `PetscViewerType`, `PetscViewerSetType()`,
1503:           `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinarySetUseMPIIO()`
1504: M*/

1506: PETSC_EXTERN PetscErrorCode PetscViewerCreate_Binary(PetscViewer v)
1507: {
1508:   PetscViewer_Binary *vbinary;

1510:   PetscFunctionBegin;
1511:   PetscCall(PetscNew(&vbinary));
1512:   v->data = (void *)vbinary;

1514:   v->ops->setfromoptions   = PetscViewerSetFromOptions_Binary;
1515:   v->ops->destroy          = PetscViewerDestroy_Binary;
1516:   v->ops->view             = PetscViewerView_Binary;
1517:   v->ops->setup            = PetscViewerSetUp_Binary;
1518:   v->ops->flush            = NULL; /* Should we support Flush() ? */
1519:   v->ops->getsubviewer     = PetscViewerGetSubViewer_Binary;
1520:   v->ops->restoresubviewer = PetscViewerRestoreSubViewer_Binary;
1521:   v->ops->read             = PetscViewerBinaryRead;

1523:   vbinary->fdes = -1;
1524: #if defined(PETSC_HAVE_MPIIO)
1525:   vbinary->usempiio = PETSC_FALSE;
1526:   vbinary->mfdes    = MPI_FILE_NULL;
1527:   vbinary->mfsub    = MPI_FILE_NULL;
1528: #endif
1529:   vbinary->filename        = NULL;
1530:   vbinary->filemode        = FILE_MODE_UNDEFINED;
1531:   vbinary->fdes_info       = NULL;
1532:   vbinary->skipinfo        = PETSC_FALSE;
1533:   vbinary->skipoptions     = PETSC_TRUE;
1534:   vbinary->skipheader      = PETSC_FALSE;
1535:   vbinary->storecompressed = PETSC_FALSE;
1536:   vbinary->ogzfilename     = NULL;
1537:   vbinary->flowcontrol     = 256; /* seems a good number for Cray XT-5 */

1539:   vbinary->setfromoptionscalled = PETSC_FALSE;

1541:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetFlowControl_C", PetscViewerBinaryGetFlowControl_Binary));
1542:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetFlowControl_C", PetscViewerBinarySetFlowControl_Binary));
1543:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipHeader_C", PetscViewerBinaryGetSkipHeader_Binary));
1544:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipHeader_C", PetscViewerBinarySetSkipHeader_Binary));
1545:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipOptions_C", PetscViewerBinaryGetSkipOptions_Binary));
1546:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipOptions_C", PetscViewerBinarySetSkipOptions_Binary));
1547:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipInfo_C", PetscViewerBinaryGetSkipInfo_Binary));
1548:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipInfo_C", PetscViewerBinarySetSkipInfo_Binary));
1549:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetInfoPointer_C", PetscViewerBinaryGetInfoPointer_Binary));
1550:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetName_C", PetscViewerFileGetName_Binary));
1551:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetName_C", PetscViewerFileSetName_Binary));
1552:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetMode_C", PetscViewerFileGetMode_Binary));
1553:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetMode_C", PetscViewerFileSetMode_Binary));
1554: #if defined(PETSC_HAVE_MPIIO)
1555:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetUseMPIIO_C", PetscViewerBinaryGetUseMPIIO_Binary));
1556:   PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetUseMPIIO_C", PetscViewerBinarySetUseMPIIO_Binary));
1557: #endif
1558:   PetscFunctionReturn(PETSC_SUCCESS);
1559: }

1561: /*
1562:     The variable Petsc_Viewer_Binary_keyval is used to indicate an MPI attribute that
1563:   is attached to a communicator, in this case the attribute is a PetscViewer.
1564: */
1565: PetscMPIInt Petsc_Viewer_Binary_keyval = MPI_KEYVAL_INVALID;

1567: /*@C
1568:      PETSC_VIEWER_BINARY_ - Creates a `PETSCVIEWERBINARY` `PetscViewer` shared by all processors
1569:                      in a communicator.

1571:      Collective

1573:      Input Parameter:
1574: .    comm - the MPI communicator to share the `PETSCVIEWERBINARY`

1576:      Level: intermediate

1578:    Options Database Keys:
1579: +    -viewer_binary_filename <name> - filename in which to store the binary data, defaults to binaryoutput
1580: .    -viewer_binary_skip_info - true means do not create .info file for this viewer
1581: .    -viewer_binary_skip_options - true means do not use the options database for this viewer
1582: .    -viewer_binary_skip_header - true means do not store the usual header information in the binary file
1583: -    -viewer_binary_mpiio - true means use the file via MPI-IO, maybe faster for large files and many MPI ranks

1585:    Environmental variable:
1586: -   PETSC_VIEWER_BINARY_FILENAME - filename in which to store the binary data, defaults to binaryoutput

1588:      Note:
1589:      Unlike almost all other PETSc routines, `PETSC_VIEWER_BINARY_` does not return
1590:      an error code.  The binary PetscViewer is usually used in the form
1591: $       XXXView(XXX object,PETSC_VIEWER_BINARY_(comm));

1593: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PETSC_VIEWER_BINARY_WORLD`, `PETSC_VIEWER_BINARY_SELF`, `PetscViewerBinaryOpen()`, `PetscViewerCreate()`,
1594:           `PetscViewerDestroy()`
1595: @*/
1596: PetscViewer PETSC_VIEWER_BINARY_(MPI_Comm comm)
1597: {
1598:   PetscErrorCode ierr;
1599:   PetscMPIInt    mpi_ierr;
1600:   PetscBool      flg;
1601:   PetscViewer    viewer;
1602:   char           fname[PETSC_MAX_PATH_LEN];
1603:   MPI_Comm       ncomm;

1605:   PetscFunctionBegin;
1606:   ierr = PetscCommDuplicate(comm, &ncomm, NULL);
1607:   if (ierr) {
1608:     ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1609:     PetscFunctionReturn(NULL);
1610:   }
1611:   if (Petsc_Viewer_Binary_keyval == MPI_KEYVAL_INVALID) {
1612:     mpi_ierr = MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, MPI_COMM_NULL_DELETE_FN, &Petsc_Viewer_Binary_keyval, NULL);
1613:     if (mpi_ierr) {
1614:       ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1615:       PetscFunctionReturn(NULL);
1616:     }
1617:   }
1618:   mpi_ierr = MPI_Comm_get_attr(ncomm, Petsc_Viewer_Binary_keyval, (void **)&viewer, (int *)&flg);
1619:   if (mpi_ierr) {
1620:     ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1621:     PetscFunctionReturn(NULL);
1622:   }
1623:   if (!flg) { /* PetscViewer not yet created */
1624:     ierr = PetscOptionsGetenv(ncomm, "PETSC_VIEWER_BINARY_FILENAME", fname, PETSC_MAX_PATH_LEN, &flg);
1625:     if (ierr) {
1626:       ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1627:       PetscFunctionReturn(NULL);
1628:     }
1629:     if (!flg) {
1630:       ierr = PetscStrncpy(fname, "binaryoutput", sizeof(fname));
1631:       if (ierr) {
1632:         ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1633:         PetscFunctionReturn(NULL);
1634:       }
1635:     }
1636:     ierr = PetscViewerBinaryOpen(ncomm, fname, FILE_MODE_WRITE, &viewer);
1637:     if (ierr) {
1638:       ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1639:       PetscFunctionReturn(NULL);
1640:     }
1641:     ierr = PetscObjectRegisterDestroy((PetscObject)viewer);
1642:     if (ierr) {
1643:       ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1644:       PetscFunctionReturn(NULL);
1645:     }
1646:     mpi_ierr = MPI_Comm_set_attr(ncomm, Petsc_Viewer_Binary_keyval, (void *)viewer);
1647:     if (mpi_ierr) {
1648:       ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1649:       PetscFunctionReturn(NULL);
1650:     }
1651:   }
1652:   ierr = PetscCommDestroy(&ncomm);
1653:   if (ierr) {
1654:     ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1655:     PetscFunctionReturn(NULL);
1656:   }
1657:   PetscFunctionReturn(viewer);
1658: }