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;
191: PetscAssertPointer(off, 2);
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;
246: PetscAssertPointer(fdes, 2);
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 - <true or false> 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;
314: PetscAssertPointer(use, 2);
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 be 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 be 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;
382: PetscAssertPointer(fc, 2);
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 processes that have the file. If MPI rank 0 does not
413: have the file it generates an error even if another MPI process 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;
423: PetscAssertPointer(fdes, 2);
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` files 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: Notes:
478: This must be called after `PetscViewerSetType()`. If you use `PetscViewerBinaryOpen()` then
479: you can only skip the info file with the `-viewer_binary_skip_info` flag. To use the function you must open the
480: viewer with `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinarySkipInfo()`.
482: The `.info` file contains meta information about the data in the binary file, for example the block size if it was
483: set for a vector or matrix.
485: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySetSkipOptions()`,
486: `PetscViewerBinaryGetSkipOptions()`, `PetscViewerBinaryGetSkipInfo()`, `PetscViewerBinaryGetInfoPointer()`
487: @*/
488: PetscErrorCode PetscViewerBinarySetSkipInfo(PetscViewer viewer, PetscBool skip)
489: {
490: PetscFunctionBegin;
493: PetscTryMethod(viewer, "PetscViewerBinarySetSkipInfo_C", (PetscViewer, PetscBool), (viewer, skip));
494: PetscFunctionReturn(PETSC_SUCCESS);
495: }
497: static PetscErrorCode PetscViewerBinarySetSkipInfo_Binary(PetscViewer viewer, PetscBool skip)
498: {
499: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
501: PetscFunctionBegin;
502: vbinary->skipinfo = skip;
503: PetscFunctionReturn(PETSC_SUCCESS);
504: }
506: /*@
507: PetscViewerBinaryGetSkipInfo - check if viewer wrote a `.info` file
509: Not Collective
511: Input Parameter:
512: . viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
514: Output Parameter:
515: . skip - `PETSC_TRUE` implies the `.info` file was not generated
517: Level: advanced
519: Note:
520: This must be called after `PetscViewerSetType()`
522: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`,
523: `PetscViewerBinarySetSkipOptions()`, `PetscViewerBinarySetSkipInfo()`, `PetscViewerBinaryGetInfoPointer()`
524: @*/
525: PetscErrorCode PetscViewerBinaryGetSkipInfo(PetscViewer viewer, PetscBool *skip)
526: {
527: PetscFunctionBegin;
529: PetscAssertPointer(skip, 2);
530: PetscUseMethod(viewer, "PetscViewerBinaryGetSkipInfo_C", (PetscViewer, PetscBool *), (viewer, skip));
531: PetscFunctionReturn(PETSC_SUCCESS);
532: }
534: static PetscErrorCode PetscViewerBinaryGetSkipInfo_Binary(PetscViewer viewer, PetscBool *skip)
535: {
536: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
538: PetscFunctionBegin;
539: *skip = vbinary->skipinfo;
540: PetscFunctionReturn(PETSC_SUCCESS);
541: }
543: /*@
544: PetscViewerBinarySetSkipOptions - do not use values in the PETSc options database when loading objects
546: Not Collective
548: Input Parameters:
549: + viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
550: - skip - `PETSC_TRUE` means do not use the options from the options database
552: Options Database Key:
553: . -viewer_binary_skip_options <true or false> - true means do not use the options from the options database
555: Level: advanced
557: Note:
558: This must be called after `PetscViewerSetType()`
560: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
561: `PetscViewerBinaryGetSkipOptions()`
562: @*/
563: PetscErrorCode PetscViewerBinarySetSkipOptions(PetscViewer viewer, PetscBool skip)
564: {
565: PetscFunctionBegin;
568: PetscTryMethod(viewer, "PetscViewerBinarySetSkipOptions_C", (PetscViewer, PetscBool), (viewer, skip));
569: PetscFunctionReturn(PETSC_SUCCESS);
570: }
572: static PetscErrorCode PetscViewerBinarySetSkipOptions_Binary(PetscViewer viewer, PetscBool skip)
573: {
574: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
576: PetscFunctionBegin;
577: vbinary->skipoptions = skip;
578: PetscFunctionReturn(PETSC_SUCCESS);
579: }
581: /*@
582: PetscViewerBinaryGetSkipOptions - checks if viewer uses the PETSc options database when loading objects
584: Not Collective
586: Input Parameter:
587: . viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
589: Output Parameter:
590: . skip - `PETSC_TRUE` means do not use
592: Level: advanced
594: Note:
595: This must be called after `PetscViewerSetType()`
597: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
598: `PetscViewerBinarySetSkipOptions()`
599: @*/
600: PetscErrorCode PetscViewerBinaryGetSkipOptions(PetscViewer viewer, PetscBool *skip)
601: {
602: PetscFunctionBegin;
604: PetscAssertPointer(skip, 2);
605: PetscUseMethod(viewer, "PetscViewerBinaryGetSkipOptions_C", (PetscViewer, PetscBool *), (viewer, skip));
606: PetscFunctionReturn(PETSC_SUCCESS);
607: }
609: static PetscErrorCode PetscViewerBinaryGetSkipOptions_Binary(PetscViewer viewer, PetscBool *skip)
610: {
611: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
613: PetscFunctionBegin;
614: *skip = vbinary->skipoptions;
615: PetscFunctionReturn(PETSC_SUCCESS);
616: }
618: /*@
619: PetscViewerBinarySetSkipHeader - do not write a header with size information on output, just raw data
621: Not Collective
623: Input Parameters:
624: + viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
625: - skip - `PETSC_TRUE` means do not write header
627: Options Database Key:
628: . -viewer_binary_skip_header <true or false> - true means do not write header
630: Level: advanced
632: Notes:
633: This must be called after `PetscViewerSetType()`
635: If this option is selected, the output file cannot be read with the `XXXLoad()` such as `VecLoad()`
637: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
638: `PetscViewerBinaryGetSkipHeader()`
639: @*/
640: PetscErrorCode PetscViewerBinarySetSkipHeader(PetscViewer viewer, PetscBool skip)
641: {
642: PetscFunctionBegin;
645: PetscTryMethod(viewer, "PetscViewerBinarySetSkipHeader_C", (PetscViewer, PetscBool), (viewer, skip));
646: PetscFunctionReturn(PETSC_SUCCESS);
647: }
649: static PetscErrorCode PetscViewerBinarySetSkipHeader_Binary(PetscViewer viewer, PetscBool skip)
650: {
651: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
653: PetscFunctionBegin;
654: vbinary->skipheader = skip;
655: PetscFunctionReturn(PETSC_SUCCESS);
656: }
658: /*@
659: PetscViewerBinaryGetSkipHeader - checks whether to write a header with size information on output, or just raw data
661: Not Collective
663: Input Parameter:
664: . viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
666: Output Parameter:
667: . skip - `PETSC_TRUE` means do not write header
669: Level: advanced
671: Notes:
672: This must be called after PetscViewerSetType()
674: Returns `PETSC_FALSE` for `PETSCSOCKETVIEWER`, you cannot skip the header for it.
676: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinarySkipInfo()`,
677: `PetscViewerBinarySetSkipHeader()`
678: @*/
679: PetscErrorCode PetscViewerBinaryGetSkipHeader(PetscViewer viewer, PetscBool *skip)
680: {
681: PetscFunctionBegin;
683: PetscAssertPointer(skip, 2);
684: PetscUseMethod(viewer, "PetscViewerBinaryGetSkipHeader_C", (PetscViewer, PetscBool *), (viewer, skip));
685: PetscFunctionReturn(PETSC_SUCCESS);
686: }
688: static PetscErrorCode PetscViewerBinaryGetSkipHeader_Binary(PetscViewer viewer, PetscBool *skip)
689: {
690: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
692: PetscFunctionBegin;
693: *skip = vbinary->skipheader;
694: PetscFunctionReturn(PETSC_SUCCESS);
695: }
697: /*@C
698: PetscViewerBinaryGetInfoPointer - Extracts the file pointer for the ASCII
699: `.info` file associated with a binary file.
701: Not Collective; No Fortran Support
703: Input Parameter:
704: . viewer - `PetscViewer` context, obtained from `PetscViewerBinaryOpen()`
706: Output Parameter:
707: . file - file pointer Always returns `NULL` if not a binary viewer
709: Level: advanced
711: Note:
712: For writable binary `PetscViewer`s, the file pointer will only be valid for the
713: first processor in the MPI communicator that shares the `PetscViewer`.
715: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinaryGetDescriptor()`, `PetscViewerBinaryGetSkipInfo()`,
716: `PetscViewerBinarySetSkipInfo()`
717: @*/
718: PetscErrorCode PetscViewerBinaryGetInfoPointer(PetscViewer viewer, FILE **file)
719: {
720: PetscFunctionBegin;
722: PetscAssertPointer(file, 2);
723: *file = NULL;
724: PetscTryMethod(viewer, "PetscViewerBinaryGetInfoPointer_C", (PetscViewer, FILE **), (viewer, file));
725: PetscFunctionReturn(PETSC_SUCCESS);
726: }
728: static PetscErrorCode PetscViewerBinaryGetInfoPointer_Binary(PetscViewer viewer, FILE **file)
729: {
730: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
732: PetscFunctionBegin;
733: PetscCall(PetscViewerSetUp(viewer));
734: *file = vbinary->fdes_info;
735: if (viewer->format == PETSC_VIEWER_BINARY_MATLAB && !vbinary->matlabheaderwritten) {
736: if (vbinary->fdes_info) {
737: FILE *info = vbinary->fdes_info;
738: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- begin code written by PetscViewerBinary for MATLAB format ---#\n"));
739: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ Set.filename = '%s';\n", vbinary->filename));
740: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ fd = PetscOpenFile(Set.filename);\n"));
741: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n"));
742: }
743: vbinary->matlabheaderwritten = PETSC_TRUE;
744: }
745: PetscFunctionReturn(PETSC_SUCCESS);
746: }
748: #if defined(PETSC_HAVE_MPIIO)
749: static PetscErrorCode PetscViewerFileClose_BinaryMPIIO(PetscViewer v)
750: {
751: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
753: PetscFunctionBegin;
754: if (vbinary->mfdes != MPI_FILE_NULL) PetscCallMPI(MPI_File_close(&vbinary->mfdes));
755: if (vbinary->mfsub != MPI_FILE_NULL) PetscCallMPI(MPI_File_close(&vbinary->mfsub));
756: vbinary->moff = 0;
757: PetscFunctionReturn(PETSC_SUCCESS);
758: }
759: #endif
761: static PetscErrorCode PetscViewerFileClose_BinarySTDIO(PetscViewer v)
762: {
763: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
765: PetscFunctionBegin;
766: if (vbinary->fdes != -1) {
767: PetscCall(PetscBinaryClose(vbinary->fdes));
768: vbinary->fdes = -1;
769: if (vbinary->storecompressed) {
770: char cmd[8 + PETSC_MAX_PATH_LEN], out[64 + PETSC_MAX_PATH_LEN] = "";
771: const char *gzfilename = vbinary->ogzfilename ? vbinary->ogzfilename : vbinary->filename;
772: /* compress the file */
773: PetscCall(PetscStrncpy(cmd, "gzip -f ", sizeof(cmd)));
774: PetscCall(PetscStrlcat(cmd, gzfilename, sizeof(cmd)));
775: #if defined(PETSC_HAVE_POPEN)
776: {
777: FILE *fp;
778: PetscCall(PetscPOpen(PETSC_COMM_SELF, NULL, cmd, "r", &fp));
779: PetscCheck(!fgets(out, (int)(sizeof(out) - 1), fp), PETSC_COMM_SELF, PETSC_ERR_LIB, "Error from command %s\n%s", cmd, out);
780: PetscCall(PetscPClose(PETSC_COMM_SELF, fp));
781: }
782: #endif
783: }
784: }
785: PetscCall(PetscFree(vbinary->ogzfilename));
786: PetscFunctionReturn(PETSC_SUCCESS);
787: }
789: static PetscErrorCode PetscViewerFileClose_BinaryInfo(PetscViewer v)
790: {
791: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
793: PetscFunctionBegin;
794: if (v->format == PETSC_VIEWER_BINARY_MATLAB && vbinary->matlabheaderwritten) {
795: if (vbinary->fdes_info) {
796: FILE *info = vbinary->fdes_info;
797: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- begin code written by PetscViewerBinary for MATLAB format ---#\n"));
798: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#$$ close(fd);\n"));
799: PetscCall(PetscFPrintf(PETSC_COMM_SELF, info, "#--- end code written by PetscViewerBinary for MATLAB format ---#\n\n"));
800: }
801: }
802: if (vbinary->fdes_info) {
803: FILE *info = vbinary->fdes_info;
804: vbinary->fdes_info = NULL;
805: PetscCheck(!fclose(info), PETSC_COMM_SELF, PETSC_ERR_SYS, "fclose() failed on file");
806: }
807: PetscFunctionReturn(PETSC_SUCCESS);
808: }
810: static PetscErrorCode PetscViewerFileClose_Binary(PetscViewer v)
811: {
812: PetscFunctionBegin;
813: #if defined(PETSC_HAVE_MPIIO)
814: PetscCall(PetscViewerFileClose_BinaryMPIIO(v));
815: #endif
816: PetscCall(PetscViewerFileClose_BinarySTDIO(v));
817: PetscCall(PetscViewerFileClose_BinaryInfo(v));
818: PetscFunctionReturn(PETSC_SUCCESS);
819: }
821: static PetscErrorCode PetscViewerDestroy_Binary(PetscViewer v)
822: {
823: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
825: PetscFunctionBegin;
826: PetscCall(PetscViewerFileClose_Binary(v));
827: PetscCall(PetscFree(vbinary->filename));
828: PetscCall(PetscFree(vbinary));
829: PetscCall(PetscViewerBinaryClearFunctionList(v));
830: PetscFunctionReturn(PETSC_SUCCESS);
831: }
833: /*@C
834: PetscViewerBinaryOpen - Opens a file for binary input/output.
836: Collective
838: Input Parameters:
839: + comm - MPI communicator
840: . name - name of file
841: - mode - open mode of file
842: .vb
843: FILE_MODE_WRITE - create new file for binary output
844: FILE_MODE_READ - open existing file for binary input
845: FILE_MODE_APPEND - open existing file for binary output
846: .ve
848: Output Parameter:
849: . viewer - PetscViewer for binary input/output to use with the specified file
851: Options Database Keys:
852: + -viewer_binary_filename <name> - name of file to use
853: . -viewer_binary_skip_info - true to skip opening an info file
854: . -viewer_binary_skip_options - true to not use options database while creating viewer
855: . -viewer_binary_skip_header - true to skip output object headers to the file
856: - -viewer_binary_mpiio - true to use MPI-IO for input and output to the file (more scalable for large problems)
858: Level: beginner
860: Note:
861: This `PetscViewer` should be destroyed with `PetscViewerDestroy()`.
863: For reading files, the filename may begin with ftp:// or http:// and/or
864: end with .gz; in this case file is brought over and uncompressed.
866: For creating files, if the file name ends with .gz it is automatically
867: compressed when closed.
869: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
870: `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
871: `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`, `PetscViewerBinarySetUseMPIIO()`,
872: `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinaryGetMPIIOOffset()`
873: @*/
874: PetscErrorCode PetscViewerBinaryOpen(MPI_Comm comm, const char name[], PetscFileMode mode, PetscViewer *viewer)
875: {
876: PetscFunctionBegin;
877: PetscCall(PetscViewerCreate(comm, viewer));
878: PetscCall(PetscViewerSetType(*viewer, PETSCVIEWERBINARY));
879: PetscCall(PetscViewerFileSetMode(*viewer, mode));
880: PetscCall(PetscViewerFileSetName(*viewer, name));
881: PetscCall(PetscViewerSetFromOptions(*viewer));
882: PetscFunctionReturn(PETSC_SUCCESS);
883: }
885: #if defined(PETSC_HAVE_MPIIO)
886: static PetscErrorCode PetscViewerBinaryWriteReadMPIIO(PetscViewer viewer, void *data, PetscInt num, PetscInt *count, PetscDataType dtype, PetscBool write)
887: {
888: MPI_Comm comm = PetscObjectComm((PetscObject)viewer);
889: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
890: MPI_File mfdes = vbinary->mfdes;
891: MPI_Datatype mdtype;
892: PetscMPIInt rank, cnt;
893: MPI_Status status;
894: MPI_Aint ul, dsize;
896: PetscFunctionBegin;
897: PetscCallMPI(MPI_Comm_rank(comm, &rank));
898: PetscCall(PetscMPIIntCast(num, &cnt));
899: PetscCall(PetscDataTypeToMPIDataType(dtype, &mdtype));
900: if (write) {
901: if (rank == 0) PetscCall(MPIU_File_write_at(mfdes, vbinary->moff, data, cnt, mdtype, &status));
902: } else {
903: if (rank == 0) {
904: PetscCall(MPIU_File_read_at(mfdes, vbinary->moff, data, cnt, mdtype, &status));
905: if (cnt > 0) PetscCallMPI(MPI_Get_count(&status, mdtype, &cnt));
906: }
907: PetscCallMPI(MPI_Bcast(&cnt, 1, MPI_INT, 0, comm));
908: PetscCallMPI(MPI_Bcast(data, cnt, mdtype, 0, comm));
909: }
910: PetscCallMPI(MPI_Type_get_extent(mdtype, &ul, &dsize));
911: vbinary->moff += dsize * cnt;
912: if (count) *count = cnt;
913: PetscFunctionReturn(PETSC_SUCCESS);
914: }
915: #endif
917: /*@C
918: PetscViewerBinaryRead - Reads from a binary file, all processors get the same result
920: Collective; No Fortran Support
922: Input Parameters:
923: + viewer - the `PETSCVIEWERBINARY` viewer
924: . num - number of items of data to read
925: - dtype - type of data to read
927: Output Parameters:
928: + data - location of the read data, treated as an array of the type indicated by `dtype`
929: - count - number of items of data actually read, or `NULL`.
931: Level: beginner
933: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
934: `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
935: `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`
936: @*/
937: PetscErrorCode PetscViewerBinaryRead(PetscViewer viewer, void *data, PetscInt num, PetscInt *count, PetscDataType dtype)
938: {
939: PetscViewer_Binary *vbinary;
941: PetscFunctionBegin;
944: PetscCall(PetscViewerSetUp(viewer));
945: vbinary = (PetscViewer_Binary *)viewer->data;
946: #if defined(PETSC_HAVE_MPIIO)
947: if (vbinary->usempiio) {
948: PetscCall(PetscViewerBinaryWriteReadMPIIO(viewer, data, num, count, dtype, PETSC_FALSE));
949: } else {
950: #endif
951: PetscCall(PetscBinarySynchronizedRead(PetscObjectComm((PetscObject)viewer), vbinary->fdes, data, num, count, dtype));
952: #if defined(PETSC_HAVE_MPIIO)
953: }
954: #endif
955: PetscFunctionReturn(PETSC_SUCCESS);
956: }
958: /*@C
959: PetscViewerBinaryWrite - writes to a binary file, only from the first MPI rank
961: Collective; No Fortran Support
963: Input Parameters:
964: + viewer - the `PETSCVIEWERBINARY` viewer
965: . data - location of data, treated as an array of the type indicated by `dtype`
966: . count - number of items of data to write
967: - dtype - type of data to write
969: Level: beginner
971: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
972: `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`, `PetscDataType`
973: `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
974: @*/
975: PetscErrorCode PetscViewerBinaryWrite(PetscViewer viewer, const void *data, PetscInt count, PetscDataType dtype)
976: {
977: PetscViewer_Binary *vbinary;
979: PetscFunctionBegin;
982: PetscCall(PetscViewerSetUp(viewer));
983: vbinary = (PetscViewer_Binary *)viewer->data;
984: #if defined(PETSC_HAVE_MPIIO)
985: if (vbinary->usempiio) {
986: PetscCall(PetscViewerBinaryWriteReadMPIIO(viewer, (void *)data, count, NULL, dtype, PETSC_TRUE));
987: } else {
988: #endif
989: PetscCall(PetscBinarySynchronizedWrite(PetscObjectComm((PetscObject)viewer), vbinary->fdes, data, count, dtype));
990: #if defined(PETSC_HAVE_MPIIO)
991: }
992: #endif
993: PetscFunctionReturn(PETSC_SUCCESS);
994: }
996: static PetscErrorCode PetscViewerBinaryWriteReadAll(PetscViewer viewer, PetscBool write, void *data, PetscInt count, PetscInt64 start, PetscInt64 total, PetscDataType dtype)
997: {
998: MPI_Comm comm = PetscObjectComm((PetscObject)viewer);
999: PetscMPIInt size, rank;
1000: MPI_Datatype mdtype;
1001: PETSC_UNUSED MPI_Aint lb;
1002: MPI_Aint dsize;
1003: PetscBool useMPIIO;
1005: PetscFunctionBegin;
1010: PetscCall(PetscViewerSetUp(viewer));
1012: PetscCall(PetscDataTypeToMPIDataType(dtype, &mdtype));
1013: PetscCallMPI(MPI_Type_get_extent(mdtype, &lb, &dsize));
1014: PetscCallMPI(MPI_Comm_rank(comm, &rank));
1015: PetscCallMPI(MPI_Comm_size(comm, &size));
1017: PetscCall(PetscViewerBinaryGetUseMPIIO(viewer, &useMPIIO));
1018: #if defined(PETSC_HAVE_MPIIO)
1019: if (useMPIIO) {
1020: MPI_File mfdes;
1021: MPI_Offset off;
1022: PetscMPIInt cnt;
1024: if (start == PETSC_DETERMINE) {
1025: PetscInt64 pcnt = count;
1026: PetscCallMPI(MPI_Scan(&pcnt, &start, 1, MPIU_INT64, MPI_SUM, comm));
1027: start -= count;
1028: }
1029: if (total == PETSC_DETERMINE) {
1030: total = start + count;
1031: PetscCallMPI(MPI_Bcast(&total, 1, MPIU_INT64, size - 1, comm));
1032: }
1033: PetscCall(PetscMPIIntCast(count, &cnt));
1034: PetscCall(PetscViewerBinaryGetMPIIODescriptor(viewer, &mfdes));
1035: PetscCall(PetscViewerBinaryGetMPIIOOffset(viewer, &off));
1036: off += (MPI_Offset)(start * dsize);
1037: if (write) {
1038: PetscCall(MPIU_File_write_at_all(mfdes, off, data, cnt, mdtype, MPI_STATUS_IGNORE));
1039: } else {
1040: PetscCall(MPIU_File_read_at_all(mfdes, off, data, cnt, mdtype, MPI_STATUS_IGNORE));
1041: }
1042: off = (MPI_Offset)(total * dsize);
1043: PetscCall(PetscViewerBinaryAddMPIIOOffset(viewer, off));
1044: PetscFunctionReturn(PETSC_SUCCESS);
1045: }
1046: #endif
1047: {
1048: int fdes;
1049: char *workbuf = NULL;
1050: PetscInt tcount = rank == 0 ? 0 : count, maxcount = 0, message_count, flowcontrolcount;
1051: PetscMPIInt tag, cnt, maxcnt, scnt = 0, rcnt = 0, j;
1052: MPI_Status status;
1054: PetscCall(PetscCommGetNewTag(comm, &tag));
1055: PetscCallMPI(MPI_Reduce(&tcount, &maxcount, 1, MPIU_INT, MPI_MAX, 0, comm));
1056: PetscCall(PetscMPIIntCast(maxcount, &maxcnt));
1057: PetscCall(PetscMPIIntCast(count, &cnt));
1059: PetscCall(PetscViewerBinaryGetDescriptor(viewer, &fdes));
1060: PetscCall(PetscViewerFlowControlStart(viewer, &message_count, &flowcontrolcount));
1061: if (rank == 0) {
1062: PetscCall(PetscMalloc(maxcnt * dsize, &workbuf));
1063: if (write) {
1064: PetscCall(PetscBinaryWrite(fdes, data, cnt, dtype));
1065: } else {
1066: PetscCall(PetscBinaryRead(fdes, data, cnt, NULL, dtype));
1067: }
1068: for (j = 1; j < size; j++) {
1069: PetscCall(PetscViewerFlowControlStepMain(viewer, j, &message_count, flowcontrolcount));
1070: if (write) {
1071: PetscCallMPI(MPI_Recv(workbuf, maxcnt, mdtype, j, tag, comm, &status));
1072: PetscCallMPI(MPI_Get_count(&status, mdtype, &rcnt));
1073: PetscCall(PetscBinaryWrite(fdes, workbuf, rcnt, dtype));
1074: } else {
1075: PetscCallMPI(MPI_Recv(&scnt, 1, MPI_INT, j, tag, comm, MPI_STATUS_IGNORE));
1076: PetscCall(PetscBinaryRead(fdes, workbuf, scnt, NULL, dtype));
1077: PetscCallMPI(MPI_Send(workbuf, scnt, mdtype, j, tag, comm));
1078: }
1079: }
1080: PetscCall(PetscFree(workbuf));
1081: PetscCall(PetscViewerFlowControlEndMain(viewer, &message_count));
1082: } else {
1083: PetscCall(PetscViewerFlowControlStepWorker(viewer, rank, &message_count));
1084: if (write) {
1085: PetscCallMPI(MPI_Send(data, cnt, mdtype, 0, tag, comm));
1086: } else {
1087: PetscCallMPI(MPI_Send(&cnt, 1, MPI_INT, 0, tag, comm));
1088: PetscCallMPI(MPI_Recv(data, cnt, mdtype, 0, tag, comm, MPI_STATUS_IGNORE));
1089: }
1090: PetscCall(PetscViewerFlowControlEndWorker(viewer, &message_count));
1091: }
1092: }
1093: PetscFunctionReturn(PETSC_SUCCESS);
1094: }
1096: /*@C
1097: PetscViewerBinaryReadAll - reads from a binary file from all MPI processes, each rank receives its own portion of the data
1099: Collective; No Fortran Support
1101: Input Parameters:
1102: + viewer - the `PETSCVIEWERBINARY` viewer
1103: . count - local number of items of data to read
1104: . start - local start, can be `PETSC_DETERMINE`
1105: . total - global number of items of data to read, can be `PETSC_DETERMINE`
1106: - dtype - type of data to read
1108: Output Parameter:
1109: . data - location of data, treated as an array of type indicated by `dtype`
1111: Level: advanced
1113: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryRead()`, `PetscViewerBinaryWriteAll()`
1114: @*/
1115: PetscErrorCode PetscViewerBinaryReadAll(PetscViewer viewer, void *data, PetscInt count, PetscInt64 start, PetscInt64 total, PetscDataType dtype)
1116: {
1117: PetscFunctionBegin;
1118: PetscCall(PetscViewerBinaryWriteReadAll(viewer, PETSC_FALSE, data, count, start, total, dtype));
1119: PetscFunctionReturn(PETSC_SUCCESS);
1120: }
1122: /*@C
1123: PetscViewerBinaryWriteAll - writes to a binary file from all MPI processes, each rank writes its own portion of the data
1125: Collective; No Fortran Support
1127: Input Parameters:
1128: + viewer - the `PETSCVIEWERBINARY` viewer
1129: . data - location of data
1130: . count - local number of items of data to write, treated as an array of type indicated by `dtype`
1131: . start - local start, can be `PETSC_DETERMINE`
1132: . total - global number of items of data to write, can be `PETSC_DETERMINE`
1133: - dtype - type of data to write
1135: Level: advanced
1137: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerBinaryOpen()`, `PetscViewerBinarySetUseMPIIO()`, `PetscViewerBinaryReadAll()`
1138: @*/
1139: PetscErrorCode PetscViewerBinaryWriteAll(PetscViewer viewer, const void *data, PetscInt count, PetscInt64 start, PetscInt64 total, PetscDataType dtype)
1140: {
1141: PetscFunctionBegin;
1142: PetscCall(PetscViewerBinaryWriteReadAll(viewer, PETSC_TRUE, (void *)data, count, start, total, dtype));
1143: PetscFunctionReturn(PETSC_SUCCESS);
1144: }
1146: /*@C
1147: PetscViewerBinaryWriteStringArray - writes to a binary file, only from the first MPI rank, an array of strings
1149: Collective; No Fortran Support
1151: Input Parameters:
1152: + viewer - the `PETSCVIEWERBINARY` viewer
1153: - data - location of the array of strings
1155: Level: intermediate
1157: Note:
1158: The array of strings must be `NULL` terminated
1160: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
1161: `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
1162: `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
1163: @*/
1164: PetscErrorCode PetscViewerBinaryWriteStringArray(PetscViewer viewer, const char *const *data)
1165: {
1166: PetscInt i, n = 0, *sizes;
1167: size_t len;
1169: PetscFunctionBegin;
1170: PetscCall(PetscViewerSetUp(viewer));
1171: /* count number of strings */
1172: while (data[n++])
1173: ;
1174: n--;
1175: PetscCall(PetscMalloc1(n + 1, &sizes));
1176: sizes[0] = n;
1177: for (i = 0; i < n; i++) {
1178: PetscCall(PetscStrlen(data[i], &len));
1179: sizes[i + 1] = (PetscInt)len + 1; /* size includes space for the null terminator */
1180: }
1181: PetscCall(PetscViewerBinaryWrite(viewer, sizes, n + 1, PETSC_INT));
1182: for (i = 0; i < n; i++) PetscCall(PetscViewerBinaryWrite(viewer, (void *)data[i], sizes[i + 1], PETSC_CHAR));
1183: PetscCall(PetscFree(sizes));
1184: PetscFunctionReturn(PETSC_SUCCESS);
1185: }
1187: /*@C
1188: PetscViewerBinaryReadStringArray - reads a binary file an array of strings to all MPI processes
1190: Collective; No Fortran Support
1192: Input Parameter:
1193: . viewer - the `PETSCVIEWERBINARY` viewer
1195: Output Parameter:
1196: . data - location of the array of strings
1198: Level: intermediate
1200: Note:
1201: The array of strings must `NULL` terminated
1203: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PetscViewerASCIIOpen()`, `PetscViewerPushFormat()`, `PetscViewerDestroy()`,
1204: `VecView()`, `MatView()`, `VecLoad()`, `MatLoad()`, `PetscViewerBinaryGetDescriptor()`,
1205: `PetscViewerBinaryGetInfoPointer()`, `PetscFileMode`, `PetscViewer`, `PetscViewerBinaryRead()`
1206: @*/
1207: PetscErrorCode PetscViewerBinaryReadStringArray(PetscViewer viewer, char ***data)
1208: {
1209: PetscInt i, n, *sizes, N = 0;
1211: PetscFunctionBegin;
1212: PetscCall(PetscViewerSetUp(viewer));
1213: /* count number of strings */
1214: PetscCall(PetscViewerBinaryRead(viewer, &n, 1, NULL, PETSC_INT));
1215: PetscCall(PetscMalloc1(n, &sizes));
1216: PetscCall(PetscViewerBinaryRead(viewer, sizes, n, NULL, PETSC_INT));
1217: for (i = 0; i < n; i++) N += sizes[i];
1218: PetscCall(PetscMalloc((n + 1) * sizeof(char *) + N * sizeof(char), data));
1219: (*data)[0] = (char *)((*data) + n + 1);
1220: for (i = 1; i < n; i++) (*data)[i] = (*data)[i - 1] + sizes[i - 1];
1221: PetscCall(PetscViewerBinaryRead(viewer, (*data)[0], N, NULL, PETSC_CHAR));
1222: (*data)[n] = NULL;
1223: PetscCall(PetscFree(sizes));
1224: PetscFunctionReturn(PETSC_SUCCESS);
1225: }
1227: /*@C
1228: PetscViewerFileSetMode - Sets the open mode of file
1230: Logically Collective
1232: Input Parameters:
1233: + viewer - the `PetscViewer`; must be a a `PETSCVIEWERBINARY`, `PETSCVIEWERMATLAB`, `PETSCVIEWERHDF5`, or `PETSCVIEWERASCII` `PetscViewer`
1234: - mode - open mode of file
1235: .vb
1236: FILE_MODE_WRITE - create new file for output
1237: FILE_MODE_READ - open existing file for input
1238: FILE_MODE_APPEND - open existing file for output
1239: .ve
1241: Level: advanced
1243: .seealso: [](sec_viewers), `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinaryOpen()`
1244: @*/
1245: PetscErrorCode PetscViewerFileSetMode(PetscViewer viewer, PetscFileMode mode)
1246: {
1247: PetscFunctionBegin;
1250: PetscCheck(mode != FILE_MODE_UNDEFINED, PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Cannot set FILE_MODE_UNDEFINED");
1251: PetscCheck(mode >= FILE_MODE_UNDEFINED && mode <= FILE_MODE_APPEND_UPDATE, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ARG_OUTOFRANGE, "Invalid file mode %d", (int)mode);
1252: PetscTryMethod(viewer, "PetscViewerFileSetMode_C", (PetscViewer, PetscFileMode), (viewer, mode));
1253: PetscFunctionReturn(PETSC_SUCCESS);
1254: }
1256: static PetscErrorCode PetscViewerFileSetMode_Binary(PetscViewer viewer, PetscFileMode mode)
1257: {
1258: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1260: PetscFunctionBegin;
1261: PetscCheck(!viewer->setupcalled || vbinary->filemode == mode, PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Cannot change mode to %s after setup", PetscFileModes[mode]);
1262: vbinary->filemode = mode;
1263: PetscFunctionReturn(PETSC_SUCCESS);
1264: }
1266: /*@C
1267: PetscViewerFileGetMode - Gets the open mode of a file associated with a `PetscViewer`
1269: Not Collective
1271: Input Parameter:
1272: . viewer - the `PetscViewer`; must be a `PETSCVIEWERBINARY`, `PETSCVIEWERMATLAB`, `PETSCVIEWERHDF5`, or `PETSCVIEWERASCII` `PetscViewer`
1274: Output Parameter:
1275: . mode - open mode of file
1276: .vb
1277: FILE_MODE_WRITE - create new file for binary output
1278: FILE_MODE_READ - open existing file for binary input
1279: FILE_MODE_APPEND - open existing file for binary output
1280: .ve
1282: Level: advanced
1284: .seealso: [](sec_viewers), `PetscViewerFileSetMode()`, `PetscViewerCreate()`, `PetscViewerSetType()`, `PetscViewerBinaryOpen()`
1285: @*/
1286: PetscErrorCode PetscViewerFileGetMode(PetscViewer viewer, PetscFileMode *mode)
1287: {
1288: PetscFunctionBegin;
1290: PetscAssertPointer(mode, 2);
1291: PetscUseMethod(viewer, "PetscViewerFileGetMode_C", (PetscViewer, PetscFileMode *), (viewer, mode));
1292: PetscFunctionReturn(PETSC_SUCCESS);
1293: }
1295: static PetscErrorCode PetscViewerFileGetMode_Binary(PetscViewer viewer, PetscFileMode *mode)
1296: {
1297: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1299: PetscFunctionBegin;
1300: *mode = vbinary->filemode;
1301: PetscFunctionReturn(PETSC_SUCCESS);
1302: }
1304: static PetscErrorCode PetscViewerFileSetName_Binary(PetscViewer viewer, const char name[])
1305: {
1306: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1308: PetscFunctionBegin;
1309: if (viewer->setupcalled && vbinary->filename) {
1310: /* gzip can be run after the file with the previous filename has been closed */
1311: PetscCall(PetscFree(vbinary->ogzfilename));
1312: PetscCall(PetscStrallocpy(vbinary->filename, &vbinary->ogzfilename));
1313: }
1314: PetscCall(PetscFree(vbinary->filename));
1315: PetscCall(PetscStrallocpy(name, &vbinary->filename));
1316: viewer->setupcalled = PETSC_FALSE;
1317: PetscFunctionReturn(PETSC_SUCCESS);
1318: }
1320: static PetscErrorCode PetscViewerFileGetName_Binary(PetscViewer viewer, const char **name)
1321: {
1322: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1324: PetscFunctionBegin;
1325: *name = vbinary->filename;
1326: PetscFunctionReturn(PETSC_SUCCESS);
1327: }
1329: #if defined(PETSC_HAVE_MPIIO)
1330: static PetscErrorCode PetscViewerFileSetUp_BinaryMPIIO(PetscViewer viewer)
1331: {
1332: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1333: int amode;
1335: PetscFunctionBegin;
1336: vbinary->storecompressed = PETSC_FALSE;
1338: vbinary->moff = 0;
1339: switch (vbinary->filemode) {
1340: case FILE_MODE_READ:
1341: amode = MPI_MODE_RDONLY;
1342: break;
1343: case FILE_MODE_WRITE:
1344: amode = MPI_MODE_WRONLY | MPI_MODE_CREATE;
1345: break;
1346: case FILE_MODE_APPEND:
1347: amode = MPI_MODE_WRONLY | MPI_MODE_CREATE | MPI_MODE_APPEND;
1348: break;
1349: case FILE_MODE_UNDEFINED:
1350: SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode() before PetscViewerSetUp()");
1351: default:
1352: SETERRQ(PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP, "Unsupported file mode %s", PetscFileModes[vbinary->filemode]);
1353: }
1354: PetscCallMPI(MPI_File_open(PetscObjectComm((PetscObject)viewer), vbinary->filename, amode, MPI_INFO_NULL, &vbinary->mfdes));
1355: /*
1356: The MPI standard does not have MPI_MODE_TRUNCATE. We emulate this behavior by setting the file size to zero.
1357: */
1358: if (vbinary->filemode == FILE_MODE_WRITE) PetscCallMPI(MPI_File_set_size(vbinary->mfdes, 0));
1359: /*
1360: Initially, all processes view the file as a linear byte stream. Therefore, for files opened with MPI_MODE_APPEND,
1361: MPI_File_get_position[_shared](fh, &offset) returns the absolute byte position at the end of file.
1362: Otherwise, we would need to call MPI_File_get_byte_offset(fh, offset, &byte_offset) to convert
1363: the offset in etype units to an absolute byte position.
1364: */
1365: if (vbinary->filemode == FILE_MODE_APPEND) PetscCallMPI(MPI_File_get_position(vbinary->mfdes, &vbinary->moff));
1366: PetscFunctionReturn(PETSC_SUCCESS);
1367: }
1368: #endif
1370: static PetscErrorCode PetscViewerFileSetUp_BinarySTDIO(PetscViewer viewer)
1371: {
1372: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1373: const char *fname;
1374: char bname[PETSC_MAX_PATH_LEN], *gz = NULL;
1375: PetscBool found;
1376: PetscMPIInt rank;
1378: PetscFunctionBegin;
1379: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));
1381: /* if file name ends in .gz strip that off and note user wants file compressed */
1382: vbinary->storecompressed = PETSC_FALSE;
1383: if (vbinary->filemode == FILE_MODE_WRITE) {
1384: PetscCall(PetscStrstr(vbinary->filename, ".gz", &gz));
1385: if (gz && gz[3] == 0) {
1386: *gz = 0;
1387: vbinary->storecompressed = PETSC_TRUE;
1388: }
1389: }
1390: #if !defined(PETSC_HAVE_POPEN)
1391: PetscCheck(!vbinary->storecompressed, PetscObjectComm((PetscObject)viewer), PETSC_ERR_SUP_SYS, "Cannot run gzip on this machine");
1392: #endif
1394: fname = vbinary->filename;
1395: if (vbinary->filemode == FILE_MODE_READ) { /* possibly get the file from remote site or compressed file */
1396: PetscCall(PetscFileRetrieve(PetscObjectComm((PetscObject)viewer), fname, bname, PETSC_MAX_PATH_LEN, &found));
1397: PetscCheck(found, PetscObjectComm((PetscObject)viewer), PETSC_ERR_FILE_OPEN, "Cannot locate file: %s", fname);
1398: fname = bname;
1399: }
1401: vbinary->fdes = -1;
1402: if (rank == 0) { /* only first processor opens file*/
1403: PetscFileMode mode = vbinary->filemode;
1404: if (mode == FILE_MODE_APPEND) {
1405: /* check if asked to append to a non-existing file */
1406: PetscCall(PetscTestFile(fname, '\0', &found));
1407: if (!found) mode = FILE_MODE_WRITE;
1408: }
1409: PetscCall(PetscBinaryOpen(fname, mode, &vbinary->fdes));
1410: }
1411: PetscFunctionReturn(PETSC_SUCCESS);
1412: }
1414: #include <errno.h>
1415: static PetscErrorCode PetscViewerFileSetUp_BinaryInfo(PetscViewer viewer)
1416: {
1417: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1418: PetscMPIInt rank;
1419: PetscBool found;
1421: PetscFunctionBegin;
1422: vbinary->fdes_info = NULL;
1423: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)viewer), &rank));
1424: if (!vbinary->skipinfo && (vbinary->filemode == FILE_MODE_READ || rank == 0)) {
1425: char infoname[PETSC_MAX_PATH_LEN], iname[PETSC_MAX_PATH_LEN], *gz;
1427: PetscCall(PetscStrncpy(infoname, vbinary->filename, sizeof(infoname)));
1428: /* remove .gz if it ends file name */
1429: PetscCall(PetscStrstr(infoname, ".gz", &gz));
1430: if (gz && gz[3] == 0) *gz = 0;
1432: PetscCall(PetscStrlcat(infoname, ".info", sizeof(infoname)));
1433: if (vbinary->filemode == FILE_MODE_READ) {
1434: PetscCall(PetscFixFilename(infoname, iname));
1435: PetscCall(PetscFileRetrieve(PetscObjectComm((PetscObject)viewer), iname, infoname, PETSC_MAX_PATH_LEN, &found));
1436: if (found) PetscCall(PetscOptionsInsertFile(PetscObjectComm((PetscObject)viewer), ((PetscObject)viewer)->options, infoname, PETSC_FALSE));
1437: } else if (rank == 0) { /* write or append */
1438: const char *omode = (vbinary->filemode == FILE_MODE_APPEND) ? "a" : "w";
1439: vbinary->fdes_info = fopen(infoname, omode);
1440: PetscCheck(vbinary->fdes_info, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open .info file %s for writing due to \"%s\"", infoname, strerror(errno));
1441: }
1442: }
1443: PetscFunctionReturn(PETSC_SUCCESS);
1444: }
1446: static PetscErrorCode PetscViewerSetUp_Binary(PetscViewer viewer)
1447: {
1448: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)viewer->data;
1449: PetscBool usempiio;
1451: PetscFunctionBegin;
1452: if (!vbinary->setfromoptionscalled) PetscCall(PetscViewerSetFromOptions(viewer));
1453: PetscCheck(vbinary->filename, PETSC_COMM_SELF, PETSC_ERR_ORDER, "Must call PetscViewerFileSetName()");
1454: PetscCheck(vbinary->filemode != (PetscFileMode)-1, PETSC_COMM_SELF, PETSC_ERR_ORDER, "Must call PetscViewerFileSetMode()");
1455: PetscCall(PetscViewerFileClose_Binary(viewer));
1457: PetscCall(PetscViewerBinaryGetUseMPIIO(viewer, &usempiio));
1458: if (usempiio) {
1459: #if defined(PETSC_HAVE_MPIIO)
1460: PetscCall(PetscViewerFileSetUp_BinaryMPIIO(viewer));
1461: #endif
1462: } else {
1463: PetscCall(PetscViewerFileSetUp_BinarySTDIO(viewer));
1464: }
1465: PetscCall(PetscViewerFileSetUp_BinaryInfo(viewer));
1467: PetscCall(PetscLogObjectState((PetscObject)viewer, "File: %s", vbinary->filename));
1468: PetscFunctionReturn(PETSC_SUCCESS);
1469: }
1471: static PetscErrorCode PetscViewerView_Binary(PetscViewer v, PetscViewer viewer)
1472: {
1473: PetscViewer_Binary *vbinary = (PetscViewer_Binary *)v->data;
1474: const char *fname = vbinary->filename ? vbinary->filename : "not yet set";
1475: const char *fmode = vbinary->filemode != (PetscFileMode)-1 ? PetscFileModes[vbinary->filemode] : "not yet set";
1476: PetscBool usempiio;
1478: PetscFunctionBegin;
1479: PetscCall(PetscViewerBinaryGetUseMPIIO(v, &usempiio));
1480: PetscCall(PetscViewerASCIIPrintf(viewer, "Filename: %s\n", fname));
1481: PetscCall(PetscViewerASCIIPrintf(viewer, "Mode: %s (%s)\n", fmode, usempiio ? "mpiio" : "stdio"));
1482: PetscFunctionReturn(PETSC_SUCCESS);
1483: }
1485: static PetscErrorCode PetscViewerSetFromOptions_Binary(PetscViewer viewer, PetscOptionItems *PetscOptionsObject)
1486: {
1487: PetscViewer_Binary *binary = (PetscViewer_Binary *)viewer->data;
1488: char defaultname[PETSC_MAX_PATH_LEN];
1489: PetscBool flg;
1491: PetscFunctionBegin;
1492: if (viewer->setupcalled) PetscFunctionReturn(PETSC_SUCCESS);
1493: PetscOptionsHeadBegin(PetscOptionsObject, "Binary PetscViewer Options");
1494: PetscCall(PetscSNPrintf(defaultname, PETSC_MAX_PATH_LEN - 1, "binaryoutput"));
1495: PetscCall(PetscOptionsString("-viewer_binary_filename", "Specify filename", "PetscViewerFileSetName", defaultname, defaultname, sizeof(defaultname), &flg));
1496: if (flg) PetscCall(PetscViewerFileSetName_Binary(viewer, defaultname));
1497: PetscCall(PetscOptionsBool("-viewer_binary_skip_info", "Skip writing/reading .info file", "PetscViewerBinarySetSkipInfo", binary->skipinfo, &binary->skipinfo, NULL));
1498: PetscCall(PetscOptionsBool("-viewer_binary_skip_options", "Skip parsing Vec/Mat load options", "PetscViewerBinarySetSkipOptions", binary->skipoptions, &binary->skipoptions, NULL));
1499: PetscCall(PetscOptionsBool("-viewer_binary_skip_header", "Skip writing/reading header information", "PetscViewerBinarySetSkipHeader", binary->skipheader, &binary->skipheader, NULL));
1500: #if defined(PETSC_HAVE_MPIIO)
1501: PetscCall(PetscOptionsBool("-viewer_binary_mpiio", "Use MPI-IO functionality to write/read binary file", "PetscViewerBinarySetUseMPIIO", binary->usempiio, &binary->usempiio, NULL));
1502: #else
1503: PetscCall(PetscOptionsBool("-viewer_binary_mpiio", "Use MPI-IO functionality to write/read binary file (NOT AVAILABLE)", "PetscViewerBinarySetUseMPIIO", PETSC_FALSE, &flg, NULL));
1504: #endif
1505: PetscOptionsHeadEnd();
1506: binary->setfromoptionscalled = PETSC_TRUE;
1507: PetscFunctionReturn(PETSC_SUCCESS);
1508: }
1510: /*MC
1511: PETSCVIEWERBINARY - A viewer that saves to binary files
1513: Level: beginner
1515: .seealso: [](sec_viewers), `PetscViewerBinaryOpen()`, `PETSC_VIEWER_STDOUT_()`, `PETSC_VIEWER_STDOUT_SELF`, `PETSC_VIEWER_STDOUT_WORLD`, `PetscViewerCreate()`, `PetscViewerASCIIOpen()`,
1516: `PetscViewerMatlabOpen()`, `VecView()`, `DMView()`, `PetscViewerMatlabPutArray()`, `PETSCVIEWERASCII`, `PETSCVIEWERMATLAB`, `PETSCVIEWERDRAW`, `PETSCVIEWERSOCKET`
1517: `PetscViewerFileSetName()`, `PetscViewerFileSetMode()`, `PetscViewerFormat`, `PetscViewerType`, `PetscViewerSetType()`,
1518: `PetscViewerBinaryGetUseMPIIO()`, `PetscViewerBinarySetUseMPIIO()`
1519: M*/
1521: PETSC_EXTERN PetscErrorCode PetscViewerCreate_Binary(PetscViewer v)
1522: {
1523: PetscViewer_Binary *vbinary;
1525: PetscFunctionBegin;
1526: PetscCall(PetscNew(&vbinary));
1527: v->data = (void *)vbinary;
1529: v->ops->setfromoptions = PetscViewerSetFromOptions_Binary;
1530: v->ops->destroy = PetscViewerDestroy_Binary;
1531: v->ops->view = PetscViewerView_Binary;
1532: v->ops->setup = PetscViewerSetUp_Binary;
1533: v->ops->flush = NULL; /* Should we support Flush() ? */
1534: v->ops->getsubviewer = PetscViewerGetSubViewer_Binary;
1535: v->ops->restoresubviewer = PetscViewerRestoreSubViewer_Binary;
1536: v->ops->read = PetscViewerBinaryRead;
1538: vbinary->fdes = -1;
1539: #if defined(PETSC_HAVE_MPIIO)
1540: vbinary->usempiio = PETSC_FALSE;
1541: vbinary->mfdes = MPI_FILE_NULL;
1542: vbinary->mfsub = MPI_FILE_NULL;
1543: #endif
1544: vbinary->filename = NULL;
1545: vbinary->filemode = FILE_MODE_UNDEFINED;
1546: vbinary->fdes_info = NULL;
1547: vbinary->skipinfo = PETSC_FALSE;
1548: vbinary->skipoptions = PETSC_TRUE;
1549: vbinary->skipheader = PETSC_FALSE;
1550: vbinary->storecompressed = PETSC_FALSE;
1551: vbinary->ogzfilename = NULL;
1552: vbinary->flowcontrol = 256; /* seems a good number for Cray XT-5 */
1554: vbinary->setfromoptionscalled = PETSC_FALSE;
1556: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetFlowControl_C", PetscViewerBinaryGetFlowControl_Binary));
1557: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetFlowControl_C", PetscViewerBinarySetFlowControl_Binary));
1558: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipHeader_C", PetscViewerBinaryGetSkipHeader_Binary));
1559: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipHeader_C", PetscViewerBinarySetSkipHeader_Binary));
1560: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipOptions_C", PetscViewerBinaryGetSkipOptions_Binary));
1561: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipOptions_C", PetscViewerBinarySetSkipOptions_Binary));
1562: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetSkipInfo_C", PetscViewerBinaryGetSkipInfo_Binary));
1563: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetSkipInfo_C", PetscViewerBinarySetSkipInfo_Binary));
1564: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetInfoPointer_C", PetscViewerBinaryGetInfoPointer_Binary));
1565: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetName_C", PetscViewerFileGetName_Binary));
1566: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetName_C", PetscViewerFileSetName_Binary));
1567: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileGetMode_C", PetscViewerFileGetMode_Binary));
1568: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerFileSetMode_C", PetscViewerFileSetMode_Binary));
1569: #if defined(PETSC_HAVE_MPIIO)
1570: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinaryGetUseMPIIO_C", PetscViewerBinaryGetUseMPIIO_Binary));
1571: PetscCall(PetscObjectComposeFunction((PetscObject)v, "PetscViewerBinarySetUseMPIIO_C", PetscViewerBinarySetUseMPIIO_Binary));
1572: #endif
1573: PetscFunctionReturn(PETSC_SUCCESS);
1574: }
1576: /*
1577: The variable Petsc_Viewer_Binary_keyval is used to indicate an MPI attribute that
1578: is attached to a communicator, in this case the attribute is a PetscViewer.
1579: */
1580: PetscMPIInt Petsc_Viewer_Binary_keyval = MPI_KEYVAL_INVALID;
1582: /*@C
1583: PETSC_VIEWER_BINARY_ - Creates a `PETSCVIEWERBINARY` `PetscViewer` shared by all processors
1584: in a communicator.
1586: Collective
1588: Input Parameter:
1589: . comm - the MPI communicator to share the `PETSCVIEWERBINARY`
1591: Level: intermediate
1593: Options Database Keys:
1594: + -viewer_binary_filename <name> - filename in which to store the binary data, defaults to binaryoutput
1595: . -viewer_binary_skip_info - true means do not create .info file for this viewer
1596: . -viewer_binary_skip_options - true means do not use the options database for this viewer
1597: . -viewer_binary_skip_header - true means do not store the usual header information in the binary file
1598: - -viewer_binary_mpiio - true means use the file via MPI-IO, maybe faster for large files and many MPI ranks
1600: Environmental variable:
1601: - PETSC_VIEWER_BINARY_FILENAME - filename in which to store the binary data, defaults to binaryoutput
1603: Notes:
1604: This object is destroyed in `PetscFinalize()`, `PetscViewerDestroy()` should never be called on it
1606: Unlike almost all other PETSc routines, `PETSC_VIEWER_BINARY_` does not return
1607: an error code. The binary PetscViewer is usually used in the form
1608: $ XXXView(XXX object, PETSC_VIEWER_BINARY_(comm));
1610: .seealso: [](sec_viewers), `PETSCVIEWERBINARY`, `PETSC_VIEWER_BINARY_WORLD`, `PETSC_VIEWER_BINARY_SELF`, `PetscViewerBinaryOpen()`, `PetscViewerCreate()`,
1611: `PetscViewerDestroy()`
1612: @*/
1613: PetscViewer PETSC_VIEWER_BINARY_(MPI_Comm comm)
1614: {
1615: PetscErrorCode ierr;
1616: PetscMPIInt mpi_ierr;
1617: PetscBool flg;
1618: PetscViewer viewer;
1619: char fname[PETSC_MAX_PATH_LEN];
1620: MPI_Comm ncomm;
1622: PetscFunctionBegin;
1623: ierr = PetscCommDuplicate(comm, &ncomm, NULL);
1624: if (ierr) {
1625: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1626: PetscFunctionReturn(NULL);
1627: }
1628: if (Petsc_Viewer_Binary_keyval == MPI_KEYVAL_INVALID) {
1629: mpi_ierr = MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, MPI_COMM_NULL_DELETE_FN, &Petsc_Viewer_Binary_keyval, NULL);
1630: if (mpi_ierr) {
1631: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1632: PetscFunctionReturn(NULL);
1633: }
1634: }
1635: mpi_ierr = MPI_Comm_get_attr(ncomm, Petsc_Viewer_Binary_keyval, (void **)&viewer, (int *)&flg);
1636: if (mpi_ierr) {
1637: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1638: PetscFunctionReturn(NULL);
1639: }
1640: if (!flg) { /* PetscViewer not yet created */
1641: ierr = PetscOptionsGetenv(ncomm, "PETSC_VIEWER_BINARY_FILENAME", fname, PETSC_MAX_PATH_LEN, &flg);
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: if (!flg) {
1647: ierr = PetscStrncpy(fname, "binaryoutput", sizeof(fname));
1648: if (ierr) {
1649: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1650: PetscFunctionReturn(NULL);
1651: }
1652: }
1653: ierr = PetscViewerBinaryOpen(ncomm, fname, FILE_MODE_WRITE, &viewer);
1654: ((PetscObject)viewer)->persistent = PETSC_TRUE;
1655: if (ierr) {
1656: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1657: PetscFunctionReturn(NULL);
1658: }
1659: ierr = PetscObjectRegisterDestroy((PetscObject)viewer);
1660: if (ierr) {
1661: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1662: PetscFunctionReturn(NULL);
1663: }
1664: mpi_ierr = MPI_Comm_set_attr(ncomm, Petsc_Viewer_Binary_keyval, (void *)viewer);
1665: if (mpi_ierr) {
1666: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_INITIAL, " ");
1667: PetscFunctionReturn(NULL);
1668: }
1669: }
1670: ierr = PetscCommDestroy(&ncomm);
1671: if (ierr) {
1672: ierr = PetscError(PETSC_COMM_SELF, __LINE__, "PETSC_VIEWER_BINARY_", __FILE__, PETSC_ERR_PLIB, PETSC_ERROR_REPEAT, " ");
1673: PetscFunctionReturn(NULL);
1674: }
1675: PetscFunctionReturn(viewer);
1676: }