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: }