Actual source code: errtrace.c

  1: #define PETSC_DESIRE_FEATURE_TEST_MACROS /* for fileno() */
  2: #include <petscsys.h>
  3: #include <petsc/private/petscimpl.h>
  4: #include <petscconfiginfo.h>
  5: #if defined(PETSC_HAVE_UNISTD_H)
  6:   #include <unistd.h>
  7: #endif

  9: /*@C
 10:    PetscIgnoreErrorHandler - Deprecated, use `PetscReturnErrorHandler()`. Ignores the error, allows program to continue as if error did not occure

 12:    Not Collective

 14:    Input Parameters:
 15: +  comm - communicator over which error occurred
 16: .  line - the line number of the error (indicated by __LINE__)
 17: .  file - the file in which the error was detected (indicated by __FILE__)
 18: .  mess - an error text string, usually just printed to the screen
 19: .  n - the generic error number
 20: .  p - specific error number
 21: -  ctx - error handler context

 23:    Level: developer

 25:    Note:
 26:    Users do not directly call this routine

 28: .seealso: `PetscReturnErrorHandler()`
 29:  @*/
 30: PetscErrorCode PetscIgnoreErrorHandler(MPI_Comm comm, int line, const char *fun, const char *file, PetscErrorCode n, PetscErrorType p, const char *mess, void *ctx)
 31: {
 32:   return n;
 33: }

 35: /* ---------------------------------------------------------------------------------------*/

 37: static char      arch[128], hostname[128], username[128], pname[PETSC_MAX_PATH_LEN], date[128];
 38: static PetscBool PetscErrorPrintfInitializeCalled = PETSC_FALSE;
 39: static char      version[256];

 41: /*
 42:    Initializes arch, hostname, username, date so that system calls do NOT need
 43:    to be made during the error handler.
 44: */
 45: PetscErrorCode PetscErrorPrintfInitialize(void)
 46: {
 47:   PetscBool use_stdout = PETSC_FALSE, use_none = PETSC_FALSE;

 49:   PetscGetArchType(arch, sizeof(arch));
 50:   PetscGetHostName(hostname, sizeof(hostname));
 51:   PetscGetUserName(username, sizeof(username));
 52:   PetscGetProgramName(pname, sizeof(pname));
 53:   PetscGetDate(date, sizeof(date));
 54:   PetscGetVersion(version, sizeof(version));

 56:   PetscOptionsGetBool(NULL, NULL, "-error_output_stdout", &use_stdout, NULL);
 57:   if (use_stdout) PETSC_STDERR = PETSC_STDOUT;
 58:   PetscOptionsGetBool(NULL, NULL, "-error_output_none", &use_none, NULL);
 59:   if (use_none) PetscErrorPrintf = PetscErrorPrintfNone;
 60:   PetscErrorPrintfInitializeCalled = PETSC_TRUE;
 61:   return 0;
 62: }

 64: PetscErrorCode PetscErrorPrintfNone(const char format[], ...)
 65: {
 66:   return 0;
 67: }

 69: PetscErrorCode PetscErrorPrintfDefault(const char format[], ...)
 70: {
 71:   va_list          Argp;
 72:   static PetscBool PetscErrorPrintfCalled = PETSC_FALSE;

 74:   /*
 76:     it may be called by PetscStackView().

 78:       This function does not do error checking because it is called by the error handlers.
 79:   */

 81:   if (!PetscErrorPrintfCalled) {
 82:     PetscErrorPrintfCalled = PETSC_TRUE;

 84:     /*
 85:         On the SGI machines and Cray T3E, if errors are generated  "simultaneously" by
 86:       different processors, the messages are printed all jumbled up; to try to
 87:       prevent this we have each processor wait based on their rank
 88:     */
 89: #if defined(PETSC_CAN_SLEEP_AFTER_ERROR)
 90:     {
 91:       PetscMPIInt rank;
 92:       if (PetscGlobalRank > 8) rank = 8;
 93:       else rank = PetscGlobalRank;
 94:       PetscSleep((PetscReal)rank);
 95:     }
 96: #endif
 97:   }

 99:   PetscFPrintf(PETSC_COMM_SELF, PETSC_STDERR, "[%d]PETSC ERROR: ", PetscGlobalRank);
100:   va_start(Argp, format);
101:   (*PetscVFPrintf)(PETSC_STDERR, format, Argp);
102:   va_end(Argp);
103:   return 0;
104: }

106: /*
107:    On some systems when the stderr is nested through several levels of shell script
108:    before being passed to a file the isatty() falsely returns true resulting in
109:    the screen highlight variables being passed through the test harness. Therefore
110:    simply do not highlight when the PETSC_STDERR is PETSC_STDOUT.
111: */
112: static void PetscErrorPrintfHilight(void)
113: {
114: #if defined(PETSC_HAVE_UNISTD_H) && defined(PETSC_USE_ISATTY)
115:   if (PetscErrorPrintf == PetscErrorPrintfDefault && PETSC_STDERR != PETSC_STDOUT) {
116:     if (isatty(fileno(PETSC_STDERR))) fprintf(PETSC_STDERR, "\033[1;31m");
117:   }
118: #endif
119: }

121: static void PetscErrorPrintfNormal(void)
122: {
123: #if defined(PETSC_HAVE_UNISTD_H) && defined(PETSC_USE_ISATTY)
124:   if (PetscErrorPrintf == PetscErrorPrintfDefault && PETSC_STDERR != PETSC_STDOUT) {
125:     if (isatty(fileno(PETSC_STDERR))) fprintf(PETSC_STDERR, "\033[0;39m\033[0;49m");
126:   }
127: #endif
128: }

130: PETSC_EXTERN PetscErrorCode PetscOptionsViewError(void);

132: /*@C

134:    PetscTraceBackErrorHandler - Default error handler routine that generates
135:    a traceback on error detection.

137:    Not Collective

139:    Input Parameters:
140: +  comm - communicator over which error occurred
141: .  line - the line number of the error (indicated by __LINE__)
142: .  file - the file in which the error was detected (indicated by __FILE__)
143: .  mess - an error text string, usually just printed to the screen
144: .  n - the generic error number
145: .  p - `PETSC_ERROR_INITIAL` if this is the first call the error handler, otherwise `PETSC_ERROR_REPEAT`
146: -  ctx - error handler context

148:   Options Database Keys:
149: +  -error_output_stdout - output the error messages to stdout instead of the default stderr
150: -  -error_output_none - do not output the error messages

152:    Notes:
153:    Users do not directly call this routine

155:    Use `PetscPushErrorHandler()` to set the desired error handler.

157:    Level: developer

159: .seealso: `PetscError()`, `PetscPushErrorHandler()`, `PetscPopErrorHandler()`, `PetscAttachDebuggerErrorHandler()`,
160:           `PetscAbortErrorHandler()`, `PetscMPIAbortErrorHandler()`, `PetscReturnErrorHandler()`, `PetscEmacsClientErrorHandler()`
161:  @*/
162: PetscErrorCode PetscTraceBackErrorHandler(MPI_Comm comm, int line, const char *fun, const char *file, PetscErrorCode n, PetscErrorType p, const char *mess, void *ctx)
163: {
164:   PetscLogDouble mem, rss;
165:   PetscBool      flg1 = PETSC_FALSE, flg2 = PETSC_FALSE, flg3 = PETSC_FALSE;
166:   PetscMPIInt    rank = 0;

168:   if (comm != PETSC_COMM_SELF) MPI_Comm_rank(comm, &rank);

170:   if (rank == 0 && (!PetscCIEnabledPortableErrorOutput || PetscGlobalRank == 0)) {
171:     PetscBool  ismain;
172:     static int cnt = 1;

174:     if (cnt == 1) {
175:       PetscErrorPrintfHilight();
176:       (*PetscErrorPrintf)("--------------------- Error Message --------------------------------------------------------------\n");
177:       PetscErrorPrintfNormal();
178:       if (n == PETSC_ERR_MEM) {
179:         (*PetscErrorPrintf)("Out of memory. This could be due to allocating\n");
180:         (*PetscErrorPrintf)("too large an object or bleeding by not properly\n");
181:         (*PetscErrorPrintf)("destroying unneeded objects.\n");
182:         PetscMallocGetCurrentUsage(&mem);
183:         PetscMemoryGetCurrentUsage(&rss);
184:         PetscOptionsGetBool(NULL, NULL, "-malloc_dump", &flg1, NULL);
185:         PetscOptionsGetBool(NULL, NULL, "-malloc_view", &flg2, NULL);
186:         PetscOptionsHasName(NULL, NULL, "-malloc_view_threshold", &flg3);
187:         if (flg2 || flg3) PetscMallocView(stdout);
188:         else {
189:           (*PetscErrorPrintf)("Memory allocated %.0f Memory used by process %.0f\n", mem, rss);
190:           if (flg1) PetscMallocDump(stdout);
191:           else (*PetscErrorPrintf)("Try running with -malloc_dump or -malloc_view for info.\n");
192:         }
193:       } else {
194:         const char *text;
195:         PetscErrorMessage(n, &text, NULL);
196:         if (text) (*PetscErrorPrintf)("%s\n", text);
197:       }
198:       if (mess) (*PetscErrorPrintf)("%s\n", mess);
199:       PetscOptionsLeftError();
200:       (*PetscErrorPrintf)("See https://petsc.org/release/faq/ for trouble shooting.\n");
201:       if (!PetscCIEnabledPortableErrorOutput) {
202:         (*PetscErrorPrintf)("%s\n", version);
203:         if (PetscErrorPrintfInitializeCalled) (*PetscErrorPrintf)("%s on a %s named %s by %s %s\n", pname, arch, hostname, username, date);
204:         (*PetscErrorPrintf)("Configure options %s\n", petscconfigureoptions);
205:       }
206:     }
207:     /* print line of stack trace */
208:     if (fun) (*PetscErrorPrintf)("#%d %s() at %s:%d\n", cnt++, fun, PetscCIFilename(file), PetscCILinenumber(line));
209:     else if (file) (*PetscErrorPrintf)("#%d %s:%d\n", cnt++, PetscCIFilename(file), PetscCILinenumber(line));
210:     if (fun) {
211:       PetscStrncmp(fun, "main", 4, &ismain);
212:       if (ismain) {
213:         if ((n <= PETSC_ERR_MIN_VALUE) || (n >= PETSC_ERR_MAX_VALUE)) (*PetscErrorPrintf)("Reached the main program with an out-of-range error code %d. This should never happen\n", n);
214:         PetscOptionsViewError();
215:         PetscErrorPrintfHilight();
216:         (*PetscErrorPrintf)("----------------End of Error Message -------send entire error message to petsc-maint@mcs.anl.gov----------\n");
217:         PetscErrorPrintfNormal();
218:       }
219:     }
220:   } else {
221:     /* do not print error messages since process 0 will print them, sleep before aborting so will not accidentally kill process 0*/
222:     PetscSleep(10.0);
223:     exit(0);
224:   }
225:   return n;
226: }