Actual source code: verboseinfo.c
petsc-3.13.6 2020-09-29
1: /*
2: PetscInfo() is contained in a different file from the other profiling to
3: allow it to be replaced at link time by an alternative routine.
4: */
5: #include <petsc/private/petscimpl.h>
7: /*
8: The next set of variables determine which, if any, PetscInfo() calls are used.
9: If PetscLogPrintInfo is false, no info messages are printed.
11: If PetscInfoFlags[OBJECT_CLASSID - PETSC_SMALLEST_CLASSID] is zero, no messages related
12: to that object are printed. OBJECT_CLASSID is, for example, MAT_CLASSID.
13: Note for developers: the PetscInfoFlags array is currently 160 entries large, to ensure headroom. Perhaps it is worth
14: dynamically allocating this array intelligently rather than just some big number.
16: PetscInfoFilename determines where PetscInfo() output is piped.
17: PetscInfoClassnames holds a char array of classes which are filtered out/for in PetscInfo() calls.
18: */
19: const char * const PetscInfoCommFlags[] = {"all", "no_self", "only_self", "PetscInfoCommFlag", "PETSC_INFO_COMM_", 0};
20: static PetscBool PetscInfoClassnamesLocked = PETSC_FALSE, PetscInfoInvertClasses = PETSC_FALSE;
21: static char **PetscInfoClassnames = NULL;
22: static char *PetscInfoFilename = NULL;
23: static PetscInt PetscInfoNumClasses = -1;
24: static PetscInfoCommFlag PetscInfoCommFilter = PETSC_INFO_COMM_ALL;
25: static int PetscInfoFlags[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
26: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
27: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
28: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
29: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
30: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
31: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
32: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
33: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
34: 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
35: PetscBool PetscLogPrintInfo = PETSC_FALSE, PetscInfoSetUp = PETSC_FALSE;
36: FILE *PetscInfoFile = NULL;
38: /*@
39: PetscInfoEnabled - Checks whether a given OBJECT_CLASSID is allowed to print using PetscInfo()
41: Not Collective
43: Input Parameters:
44: . classid - PetscClassid retrieved from a PetscObject e.g. VEC_CLASSID
46: Output Parameter:
47: . enabled - PetscBool indicating whether this classid is allowed to print
49: Notes:
50: Use PETSC_SMALLEST_CLASSID to check if "sys" PetscInfo() calls are enabled. When PETSc is configured with debugging
51: support this function checks if classid >= PETSC_SMALLEST_CLASSID, otherwise it assumes valid classid.
53: Level: advanced
55: .seealso: PetscInfo(), PetscInfoAllow(), PetscInfoGetInfo(), PetscObjectGetClassid()
56: @*/
57: PetscErrorCode PetscInfoEnabled(PetscClassId classid, PetscBool *enabled)
58: {
60: #if defined(PETSC_USE_DEBUG)
61: if (classid < PETSC_SMALLEST_CLASSID) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Classid (current: %d) must be equal to or greater than PETSC_SMALLEST_CLASSID", classid);
62: #endif
63: *enabled = (PetscBool) (PetscLogPrintInfo && PetscInfoFlags[classid - PETSC_SMALLEST_CLASSID]);
64: return(0);
65: }
67: /*@
68: PetscInfoAllow - Enables/disables PetscInfo() messages
70: Not Collective
72: Input Parameter:
73: . flag - PETSC_TRUE or PETSC_FALSE
75: Level: advanced
77: .seealso: PetscInfo(), PetscInfoEnabled(), PetscInfoGetInfo(), PetscInfoSetFromOptions()
78: @*/
79: PetscErrorCode PetscInfoAllow(PetscBool flag)
80: {
82: PetscLogPrintInfo = flag;
83: return(0);
84: }
86: /*@C
87: PetscInfoSetFile - Sets the printing destination for all PetscInfo() calls
89: Not Collective
91: Input Parameter:
92: + filename - Name of the file where PetscInfo() will print to
93: - mode - Write mode passed to PetscFOpen()
95: Notes:
96: Use filename=NULL to set PetscInfo() to write to PETSC_STDOUT.
98: Level: advanced
100: .seealso: PetscInfo(), PetscInfoSetFile(), PetscInfoSetFromOptions(), PetscFOpen()
101: @*/
102: PetscErrorCode PetscInfoSetFile(const char filename[], const char mode[])
103: {
104: char fname[PETSC_MAX_PATH_LEN], tname[11];
105: PetscMPIInt rank;
106: PetscErrorCode ierr;
109: if (!PetscInfoFile) PetscInfoFile = PETSC_STDOUT;
110: PetscFree(PetscInfoFilename);
111: if (filename) {
112: PetscBool oldflag;
114: PetscFixFilename(filename, fname);
115: PetscStrallocpy(fname, &PetscInfoFilename);
116: MPI_Comm_rank(MPI_COMM_WORLD, &rank);
117: sprintf(tname, ".%d", rank);
118: PetscStrcat(fname, tname);
119: oldflag = PetscLogPrintInfo; PetscLogPrintInfo = PETSC_FALSE;
120: PetscFOpen(MPI_COMM_SELF, fname, mode, &PetscInfoFile);
121: PetscLogPrintInfo = oldflag;
122: /* PetscFOpen will write to PETSC_STDOUT and not PetscInfoFile here, so we disable the PetscInfo call inside it, and
123: call it afterwards so that it actually writes to file */
124: PetscInfo1(NULL, "Opened PetscInfo file %s\n", fname);
125: }
126: return(0);
127: }
129: /*@C
130: PetscInfoGetFile - Gets the name and FILE pointer of the file where PetscInfo() prints to
132: Not Collective
134: Output Parameters:
135: + filename - The name of the output file
136: - InfoFile - The FILE pointer for the output file
138: Level: advanced
140: Note:
141: This routine allocates and copies the filename so that the filename survives PetscInfoDestroy(). The user is
142: therefore responsible for freeing the allocated filename pointer afterwards.
144: Fortran Note:
145: This routine is not supported in Fortran.
147: .seealso: PetscInfo(), PetscInfoSetFile(), PetscInfoSetFromOptions(), PetscInfoDestroy()
148: @*/
149: PetscErrorCode PetscInfoGetFile(char **filename, FILE **InfoFile)
150: {
151: PetscErrorCode ierr;
156: PetscStrallocpy(PetscInfoFilename, filename);
157: *InfoFile = PetscInfoFile;
158: return(0);
159: }
161: /*@C
162: PetscInfoSetClasses - Sets the classes which PetscInfo() is filtered for/against
164: Not Collective
166: Input Parameters:
167: + exclude - Whether or not to invert the filter, i.e. if exclude is true, PetscInfo() will print from every class that
168: is NOT one of the classes specified
169: . N - Number of classes to filter for (size of classnames)
170: - classnames - String array containing the names of classes to filter for, e.g. "vec"
172: Notes:
173: Not for use in Fortran
175: This function CANNOT be called after PetscInfoGetClass() or PetscInfoProcessClass() has been called.
177: Names in the classnames list should correspond to the names returned by PetscObjectGetClassName().
179: This function only sets the list of class names.
180: The actual filtering is deferred to PetscInfoProcessClass(), except of sys which is processed right away.
181: The reason for this is that we need to set the list of included/excluded classes before their classids are known.
182: Typically the classid is assigned and PetscInfoProcessClass() called in <Class>InitializePackage() (e.g. VecInitializePackage()).
184: Level: developer
186: .seealso: PetscInfo(), PetscInfoGetClass(), PetscInfoProcessClass(), PetscInfoSetFromOptions(), PetscStrToArray(), PetscObjectGetName()
187: @*/
188: PetscErrorCode PetscInfoSetClasses(PetscBool exclude, PetscInt N, const char *const *classnames)
189: {
190: PetscErrorCode ierr;
193: if (PetscInfoClassnamesLocked) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "PetscInfoSetClasses() cannot be called after PetscInfoGetClass() or PetscInfoProcessClass()");
194: PetscStrNArrayDestroy(PetscInfoNumClasses, &PetscInfoClassnames);
195: PetscStrNArrayallocpy(N, classnames, &PetscInfoClassnames);
196: PetscInfoNumClasses = N;
197: PetscInfoInvertClasses = exclude;
198: {
199: /* Process sys class right away */
200: PetscClassId sysclassid = PETSC_SMALLEST_CLASSID;
201: PetscInfoProcessClass("sys", 1, &sysclassid);
202: }
203: PetscInfoSetUp = PETSC_TRUE;
204: return(0);
205: }
207: /*@C
208: PetscInfoGetClass - Indicates whether the provided classname is marked as a filter in PetscInfo() as set by PetscInfoSetClasses()
210: Not Collective
212: Input Paramater:
213: . classname - Name of the class to search for
215: Output Parameter:
216: . found - PetscBool indicating whether the classname was found
218: Notes:
219: Use PetscObjectGetName() to retrieve an appropriate classname
221: Level: developer
223: .seealso: PetscInfo(), PetscInfoSetClasses(), PetscInfoSetFromOptions(), PetscObjectGetName()
224: @*/
225: PetscErrorCode PetscInfoGetClass(const char *classname, PetscBool *found)
226: {
227: PetscInt idx;
228: PetscErrorCode ierr;
232: PetscEListFind(PetscInfoNumClasses, (const char *const *) PetscInfoClassnames, classname ? classname : "sys", &idx, found);
233: PetscInfoClassnamesLocked = PETSC_TRUE;
234: return(0);
235: }
237: /*@
238: PetscInfoGetInfo - Returns the current state of several important flags for PetscInfo()
240: Not Collective
242: Output Parameters:
243: + infoEnabled - PETSC_TRUE if PetscInfoAllow(PETSC_TRUE) has been called
244: . classesSet - PETSC_TRUE if the list of classes to filter for has been set
245: . exclude - PETSC_TRUE if the class filtering for PetscInfo() is inverted
246: . locked - PETSC_TRUE if the list of classes to filter for has been locked
247: - commSelfFlag - Enum indicating whether PetscInfo() will print for communicators of size 1, any size != 1, or all
248: communicators
250: Notes:
251: Initially commSelfFlag = PETSC_INFO_COMM_ALL
253: Level: developer
255: .seealso: PetscInfo(), PetscInfoAllow(), PetscInfoSetFilterCommSelf, PetscInfoSetFromOptions()
256: @*/
257: PetscErrorCode PetscInfoGetInfo(PetscBool *infoEnabled, PetscBool *classesSet, PetscBool *exclude, PetscBool *locked, PetscInfoCommFlag *commSelfFlag)
258: {
260: if (infoEnabled) *infoEnabled = PetscLogPrintInfo;
261: if (classesSet) *classesSet = PetscInfoSetUp;
262: if (exclude) *exclude = PetscInfoInvertClasses;
263: if (locked) *locked = PetscInfoClassnamesLocked;
264: if (commSelfFlag) *commSelfFlag = PetscInfoCommFilter;
265: return(0);
266: }
268: /*@C
269: PetscInfoProcessClass - Activates or deactivates a class based on the filtering status of PetscInfo()
271: Not Collective
273: Input Parameters:
274: + classname - Name of the class to activate/deactivate PetscInfo() for
275: . numClassID - Number of entries in classIDs
276: - classIDs - Array containing all of the PetscClassids associated with classname
278: Level: developer
280: .seealso: PetscInfo(), PetscInfoActivateClass(), PetscInfoDeactivateClass(), PetscInfoSetFromOptions()
281: @*/
282: PetscErrorCode PetscInfoProcessClass(const char classname[], PetscInt numClassID, PetscClassId classIDs[])
283: {
284: PetscInt i;
285: PetscBool enabled, exclude, found, opt, pkg;
286: char logList[256];
287: PetscErrorCode ierr;
291: PetscInfoGetInfo(&enabled, NULL, &exclude, NULL, NULL);
292: /* -info_exclude is DEPRECATED */
293: PetscOptionsGetString(NULL,NULL,"-info_exclude",logList,sizeof(logList),&opt);
294: if (opt) {
295: PetscStrInList(classname,logList,',',&pkg);
296: if (pkg) {
297: for (i = 0; i < numClassID; ++i) {
298: PetscInfoDeactivateClass(classIDs[i]);
299: }
300: }
301: }
302: PetscInfoGetClass(classname, &found);
303: if ((found && exclude) || (!found && !exclude)) {
304: if (PetscInfoNumClasses > 0) {
305: /* Check if -info was called empty */
306: for (i = 0; i < numClassID; ++i) {
307: PetscInfoDeactivateClass(classIDs[i]);
308: }
309: }
310: } else {
311: for (i = 0; i < numClassID; ++i) {
312: PetscInfoActivateClass(classIDs[i]);
313: }
314: }
315: return(0);
316: }
318: /*@
319: PetscInfoSetFilterCommSelf - Sets PetscInfoCommFlag enum to determine communicator filtering for PetscInfo()
321: Not Collective
323: Input Parameter:
324: . commSelfFlag - Enum value indicating method with which to filter PetscInfo() based on the size of the communicator of the object calling PetscInfo()
326: Level: advanced
328: .seealso: PetscInfo(), PetscInfoGetInfo()
329: @*/
330: PetscErrorCode PetscInfoSetFilterCommSelf(PetscInfoCommFlag commSelfFlag)
331: {
333: PetscInfoCommFilter = commSelfFlag;
334: return(0);
335: }
337: /*@
338: PetscInfoSetFromOptions - Configure PetscInfo() using command line options, enabling or disabling various calls to PetscInfo()
340: Not Collective
342: Input Parameter:
343: . options - Options database, use NULL for default global database
345: Options Database Keys:
346: . -info [filename][:[~]<list,of,classnames>[:[~]self]] - specify which informative messages are printed, See PetscInfo().
348: Notes:
349: This function is called automatically during PetscInitialize() so users usually do not need to call it themselves.
351: Level: advanced
353: .seealso: PetscInfo(), PetscInfoAllow(), PetscInfoSetFile(), PetscInfoSetClasses(), PetscInfoSetFilterCommSelf(), PetscInfoDestroy()
354: @*/
355: PetscErrorCode PetscInfoSetFromOptions(PetscOptions options)
356: {
357: char optstring[PETSC_MAX_PATH_LEN], *loc0_ = NULL, *loc1_ = NULL, *loc2_ = NULL;
358: char **loc1_array = NULL;
359: PetscBool set, loc1_invert = PETSC_FALSE, loc2_invert = PETSC_FALSE, foundSelf = PETSC_FALSE;
360: size_t size_loc0_ = 0, size_loc1_ = 0, size_loc2_ = 0;
361: int nLoc1_ = 0;
362: PetscInfoCommFlag commSelfFlag = PETSC_INFO_COMM_ALL;
363: PetscErrorCode ierr;
366: PetscOptionsDeprecated_Private(NULL,"-info_exclude", NULL, "3.13", "Use -info instead");
367: PetscOptionsGetString(options, NULL, "-info", optstring, PETSC_MAX_PATH_LEN, &set);
368: if (set) {
369: PetscInfoSetUp = PETSC_TRUE;
370: PetscInfoAllow(PETSC_TRUE);
371: PetscStrallocpy(optstring,&loc0_);
372: PetscStrchr(loc0_,':',&loc1_);
373: if (loc1_) {
374: *loc1_++ = 0;
375: if (*loc1_ == '~') {
376: loc1_invert = PETSC_TRUE;
377: ++loc1_;
378: }
379: PetscStrchr(loc1_,':',&loc2_);
380: }
381: if (loc2_) {
382: *loc2_++ = 0;
383: if (*loc2_ == '~') {
384: loc2_invert = PETSC_TRUE;
385: ++loc2_;
386: }
387: }
388: PetscStrlen(loc0_, &size_loc0_);
389: PetscStrlen(loc1_, &size_loc1_);
390: PetscStrlen(loc2_, &size_loc2_);
391: if (size_loc1_) {
392: PetscStrtolower(loc1_);
393: PetscStrToArray((const char *) loc1_, ',',(int *) &nLoc1_, &loc1_array);
394: }
395: if (size_loc2_) {
396: PetscStrtolower(loc2_);
397: PetscStrcmp("self", (const char *) loc2_, &foundSelf);
398: if (foundSelf) {
399: if (loc2_invert) {
400: commSelfFlag = PETSC_INFO_COMM_NO_SELF;
401: } else {
402: commSelfFlag = PETSC_INFO_COMM_ONLY_SELF;
403: }
404: }
405: }
406: PetscInfoSetFile((const char *) size_loc0_ ? loc0_ : NULL, "w");
407: PetscInfoSetClasses(loc1_invert,(PetscInt) nLoc1_, (const char *const *) loc1_array);
408: PetscInfoSetFilterCommSelf(commSelfFlag);
409: PetscStrToArrayDestroy(nLoc1_, loc1_array);
410: PetscFree(loc0_);
411: }
412: return(0);
413: }
415: /*@
416: PetscInfoDestroy - Destroys and resets internal PetscInfo() data structures.
418: Not Collective
420: Notes:
421: This is automatically called in PetscFinalize(). Useful for changing filters mid-program, or culling subsequent
422: PetscInfo() calls down the line.
424: Level: developer
426: .seealso: PetscInfo(), PetscInfoSetFromOptions()
427: @*/
428: PetscErrorCode PetscInfoDestroy(void)
429: {
430: PetscErrorCode ierr;
431: int err, i;
434: PetscInfoAllow(PETSC_FALSE);
435: PetscStrNArrayDestroy(PetscInfoNumClasses, &PetscInfoClassnames);
436: err = fflush(PetscInfoFile);
437: if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
438: if (PetscInfoFilename) {
439: PetscFClose(MPI_COMM_SELF, PetscInfoFile);
440: }
441: PetscFree(PetscInfoFilename);
442: for (i=0; i<160; i++) PetscInfoFlags[i] = 1;
443: PetscInfoClassnamesLocked = PETSC_FALSE;
444: PetscInfoInvertClasses = PETSC_FALSE;
445: PetscInfoNumClasses = -1;
446: PetscInfoCommFilter = PETSC_INFO_COMM_ALL;
447: PetscInfoSetUp = PETSC_FALSE;
448: return(0);
449: }
451: /*@
452: PetscInfoDeactivateClass - Deactivates PetscInfo() messages for a PETSc object class.
454: Not Collective
456: Input Parameter:
457: . classid - The object class, e.g., MAT_CLASSID, SNES_CLASSID, etc.
459: Notes:
460: One can pass 0 to deactivate all messages that are not associated with an object.
462: Level: developer
464: .seealso: PetscInfoActivateClass(), PetscInfo(), PetscInfoAllow(), PetscInfoSetFromOptions()
465: @*/
466: PetscErrorCode PetscInfoDeactivateClass(PetscClassId classid)
467: {
469: if (!classid) classid = PETSC_SMALLEST_CLASSID;
470: PetscInfoFlags[classid - PETSC_SMALLEST_CLASSID] = 0;
471: return(0);
472: }
474: /*@
475: PetscInfoActivateClass - Activates PetscInfo() messages for a PETSc object class.
477: Not Collective
479: Input Parameter:
480: . classid - The object class, e.g., MAT_CLASSID, SNES_CLASSID, etc.
482: Notes:
483: One can pass 0 to activate all messages that are not associated with an object.
485: Level: developer
487: .seealso: PetscInfoDeactivateClass(), PetscInfo(), PetscInfoAllow(), PetscInfoSetFromOptions()
488: @*/
489: PetscErrorCode PetscInfoActivateClass(PetscClassId classid)
490: {
492: if (!classid) classid = PETSC_SMALLEST_CLASSID;
493: PetscInfoFlags[classid - PETSC_SMALLEST_CLASSID] = 1;
494: return(0);
495: }
497: /*
498: If the option -history was used, then all printed PetscInfo()
499: messages are also printed to the history file, called by default
500: .petschistory in ones home directory.
501: */
502: PETSC_INTERN FILE *petsc_history;
504: /*MC
505: PetscInfo - Logs informative data
507: Synopsis:
508: #include <petscsys.h>
509: PetscErrorCode PetscInfo(PetscObject obj, const char message[])
510: PetscErrorCode PetscInfo1(PetscObject obj, const char formatmessage[],arg1)
511: PetscErrorCode PetscInfo2(PetscObject obj, const char formatmessage[],arg1,arg2)
512: ...
514: Collective on obj
516: Input Parameter:
517: + obj - object most closely associated with the logging statement or NULL
518: . message - logging message
519: . formatmessage - logging message using standard "printf" format
520: - arg1, arg2, ... - arguments of the format
522: Notes:
523: PetscInfo() prints only from the first processor in the communicator of obj.
524: If obj is NULL, the PETSC_COMM_SELF communicator is used, i.e. every rank of PETSC_COMM_WORLD prints the message.
526: Extent of the printed messages can be controlled using the option database key -info as follows.
528: $ -info [filename][:[~]<list,of,classnames>[:[~]self]]
530: No filename means standard output PETSC_STDOUT is used.
532: The optional <list,of,classnames> is a comma separated list of enabled classes, e.g. vec,mat,ksp.
533: If this list is not specified, all classes are enabled.
534: Prepending the list with ~ means inverted selection, i.e. all classes except the listed are enabled.
535: A special classname sys relates to PetscInfo() with obj being NULL.
537: The optional self keyword specifies that PetscInfo() is enabled only for communicator size = 1 (e.g. PETSC_COMM_SELF), i.e. only PetscInfo() calls which print from every rank of PETSC_COMM_WORLD are enabled.
538: By contrast, ~self means that PetscInfo() is enabled only for communicator size > 1 (e.g. PETSC_COMM_WORLD), i.e. those PetscInfo() calls which print from every rank of PETSC_COMM_WORLD are disabled.
540: All classname/self matching is case insensitive. Filename is case sensitive.
542: Example of Usage:
543: $ Mat A;
544: $ PetscInt alpha;
545: $ ...
546: $ PetscInfo1(A,"Matrix uses parameter alpha=%D\n",alpha);
548: Options Examples:
549: Each call of the form
550: $ PetscInfo(obj, msg);
551: $ PetscInfo1(obj, msg, arg1);
552: $ PetscInfo2(obj, msg, arg1, arg2);
553: is evaluated as follows.
554: $ -info or -info :: prints msg to PETSC_STDOUT, for any obj regardless class or communicator
555: $ -info :mat:self prints msg to PETSC_STDOUT only if class of obj is Mat, and its communicator has size = 1
556: $ -info myInfoFileName:~vec:~self prints msg to file named myInfoFileName, only if the obj's class is NULL or other than Vec, and obj's communicator has size > 1
557: $ -info :sys prints to PETSC_STDOUT only if obj is NULL
558: Note that
559: $ -info :sys:~self
560: deactivates all info messages because sys means obj = NULL which implies PETSC_COMM_SELF but ~self filters out everything on PETSC_COMM_SELF.
562: Fortran Note:
563: This function does not take the obj argument, there is only the PetscInfo()
564: version, not PetscInfo1() etc.
566: Level: intermediate
568: .seealso: PetscInfoAllow(), PetscInfoSetFromOptions()
569: M*/
570: PetscErrorCode PetscInfo_Private(const char func[],PetscObject obj, const char message[], ...)
571: {
572: va_list Argp;
573: PetscMPIInt rank = 0,urank,size = 1;
574: PetscClassId classid;
575: PetscBool enabled = PETSC_FALSE, oldflag;
576: char string[8*1024];
578: size_t fullLength,len;
579: int err;
583: classid = obj ? obj->classid : PETSC_SMALLEST_CLASSID;
584: PetscInfoEnabled(classid, &enabled);
585: if (!enabled) return(0);
587: if (obj) {
588: MPI_Comm_rank(obj->comm, &rank);
589: MPI_Comm_size(obj->comm, &size);
590: }
591: /* rank > 0 always jumps out */
592: if (rank) return(0);
593: if (!PetscInfoCommFilter && (size < 2)) {
594: /* If no self printing is allowed, and size too small get out */
595: return(0);
596: } else if ((PetscInfoCommFilter == PETSC_INFO_COMM_ONLY_SELF) && (size > 1)) {
597: /* If ONLY self printing, and size too big, get out */
598: return(0);
599: }
600: /* Mute info messages within this function */
601: oldflag = PetscLogPrintInfo; PetscLogPrintInfo = PETSC_FALSE;
602: MPI_Comm_rank(MPI_COMM_WORLD, &urank);
603: va_start(Argp, message);
604: sprintf(string, "[%d] %s(): ",urank,func);
605: PetscStrlen(string, &len);
606: PetscVSNPrintf(string+len, 8*1024-len,message,&fullLength, Argp);
607: PetscFPrintf(PETSC_COMM_SELF,PetscInfoFile, "%s", string);
608: err = fflush(PetscInfoFile);
609: if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
610: if (petsc_history) {
611: va_start(Argp, message);
612: (*PetscVFPrintf)(petsc_history, message, Argp);
613: }
614: va_end(Argp);
615: PetscLogPrintInfo = oldflag;
616: return(0);
617: }