2: #include <petscsys.h>        /*I "petscsys.h" I*/
  3: #include <petscconfiginfo.h>

  7: /*@C
  8:    PetscIgnoreErrorHandler - Ignores the error, allows program to continue as if error did not occure

 10:    Not Collective

 12:    Input Parameters:
 13: +  comm - communicator over which error occurred
 14: .  line - the line number of the error (indicated by __LINE__)
 15: .  func - the function where error is detected (indicated by __FUNCT__)
 16: .  file - the file in which the error was detected (indicated by __FILE__)
 17: .  dir - the directory of the file (indicated by __SDIR__)
 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:    Notes:
 26:    Most users need not directly employ this routine and the other error
 27:    handlers, but can instead use the simplified interface SETERRQ, which has
 28:    the calling sequence
 29: $     SETERRQ(comm,number,p,mess)

 31:    Notes for experienced users:
 32:    Use PetscPushErrorHandler() to set the desired error handler.  The
 33:    currently available PETSc error handlers include PetscTraceBackErrorHandler(),
 34:    PetscAttachDebuggerErrorHandler(), PetscAbortErrorHandler(), and PetscMPIAbortErrorHandler()

 36:    Concepts: error handler^traceback
 37:    Concepts: traceback^generating

 39: .seealso:  PetscPushErrorHandler(), PetscAttachDebuggerErrorHandler(),
 40:           PetscAbortErrorHandler(), PetscTraceBackErrorHandler()
 41:  @*/
 42: PetscErrorCode  PetscIgnoreErrorHandler(MPI_Comm comm,int line,const char *fun,const char *file,const char *dir,PetscErrorCode n,PetscErrorType p,const char *mess,void *ctx)
 43: {
 45:   PetscFunctionReturn(n);
 46: }

 48: /* ---------------------------------------------------------------------------------------*/

 50: static char      arch[128],hostname[128],username[128],pname[PETSC_MAX_PATH_LEN],date[128];
 51: static PetscBool PetscErrorPrintfInitializeCalled = PETSC_FALSE;
 52: static char      version[256];

 56: /*
 57:    Initializes arch, hostname, username,date so that system calls do NOT need
 58:    to be made during the error handler.
 59: */
 60: PetscErrorCode  PetscErrorPrintfInitialize()
 61: {
 63:   PetscBool      use_stdout = PETSC_FALSE,use_none = PETSC_FALSE;

 66:   PetscGetArchType(arch,sizeof(arch));
 67:   PetscGetHostName(hostname,sizeof(hostname));
 68:   PetscGetUserName(username,sizeof(username));
 69:   PetscGetProgramName(pname,PETSC_MAX_PATH_LEN);
 70:   PetscGetDate(date,sizeof(date));
 71:   PetscGetVersion(version,sizeof(version));

 73:   PetscOptionsGetBool(NULL,"-error_output_stdout",&use_stdout,NULL);
 74:   if (use_stdout) PETSC_STDERR = PETSC_STDOUT;
 75:   PetscOptionsGetBool(NULL,"-error_output_none",&use_none,NULL);
 76:   if (use_none) PetscErrorPrintf = PetscErrorPrintfNone;
 77:   PetscErrorPrintfInitializeCalled = PETSC_TRUE;
 78:   return(0);
 79: }

 83: PetscErrorCode  PetscErrorPrintfNone(const char format[],...)
 84: {
 85:   return 0;
 86: }

 90: PetscErrorCode  PetscErrorPrintfDefault(const char format[],...)
 91: {
 92:   va_list          Argp;
 93:   static PetscBool PetscErrorPrintfCalled = PETSC_FALSE;

 95:   /*
 97:     it may be called by PetscStackView().

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

102:   if (!PetscErrorPrintfCalled) {
103:     PetscErrorPrintfCalled = PETSC_TRUE;

105:     /*
106:         On the SGI machines and Cray T3E, if errors are generated  "simultaneously" by
107:       different processors, the messages are printed all jumbled up; to try to
108:       prevent this we have each processor wait based on their rank
109:     */
110: #if defined(PETSC_CAN_SLEEP_AFTER_ERROR)
111:     {
112:       PetscMPIInt rank;
113:       if (PetscGlobalRank > 8) rank = 8;
114:       else rank = PetscGlobalRank;
115:       PetscSleep((PetscReal)rank);
116:     }
117: #endif
118:   }

120:   PetscFPrintf(PETSC_COMM_SELF,PETSC_STDERR,"[%d]PETSC ERROR: ",PetscGlobalRank);
121:   va_start(Argp,format);
122:   (*PetscVFPrintf)(PETSC_STDERR,format,Argp);
123:   va_end(Argp);
124:   return 0;
125: }

129: /*@C

131:    PetscTraceBackErrorHandler - Default error handler routine that generates
132:    a traceback on error detection.

134:    Not Collective

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

147:    Level: developer

149:    Notes:
150:    Most users need not directly employ this routine and the other error
151:    handlers, but can instead use the simplified interface SETERRQ, which has
152:    the calling sequence
153: $     SETERRQ(comm,number,n,mess)

155:    Notes for experienced users:
156:    Use PetscPushErrorHandler() to set the desired error handler.  The
157:    currently available PETSc error handlers include PetscTraceBackErrorHandler(),
158:    PetscAttachDebuggerErrorHandler(), PetscAbortErrorHandler(), and PetscMPIAbortErrorHandler()

160:    Concepts: error handler^traceback
161:    Concepts: traceback^generating

163: .seealso:  PetscPushErrorHandler(), PetscAttachDebuggerErrorHandler(),
164:           PetscAbortErrorHandler()
165:  @*/
166: PetscErrorCode  PetscTraceBackErrorHandler(MPI_Comm comm,int line,const char *fun,const char *file,const char *dir,PetscErrorCode n,PetscErrorType p,const char *mess,void *ctx)
167: {
168:   PetscLogDouble mem,rss;
169:   PetscBool      flg1 = PETSC_FALSE,flg2 = PETSC_FALSE,flg3 = PETSC_FALSE;
170:   PetscMPIInt    rank = 0;

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

175:   if (!rank) {
176:     if (p == PETSC_ERROR_INITIAL) {
177:       (*PetscErrorPrintf)("--------------------- Error Message ------------------------------------\n");
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,"-malloc_dump",&flg1,NULL);
185:         PetscOptionsGetBool(NULL,"-malloc_log",&flg2,NULL);
186:         PetscOptionsHasName(NULL,"-malloc_log_threshold",&flg3);
187:         if (flg2 || flg3) PetscMallocDumpLog(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_log 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:       (*PetscErrorPrintf)("------------------------------------------------------------------------\n");
200:       (*PetscErrorPrintf)("%s\n",version);
201:       (*PetscErrorPrintf)("See docs/changes/index.html for recent updates.\n");
202:       (*PetscErrorPrintf)("See docs/faq.html for hints about trouble shooting.\n");
203:       (*PetscErrorPrintf)("See docs/index.html for manual pages.\n");
204:       (*PetscErrorPrintf)("------------------------------------------------------------------------\n");
205:       if (PetscErrorPrintfInitializeCalled) (*PetscErrorPrintf)("%s on a %s named %s by %s %s\n",pname,arch,hostname,username,date);
206:       (*PetscErrorPrintf)("Libraries linked from %s\n",PETSC_LIB_DIR);
207:       (*PetscErrorPrintf)("Configure run at %s\n",petscconfigureruntime);
208:       (*PetscErrorPrintf)("Configure options %s\n",petscconfigureoptions);
209:       (*PetscErrorPrintf)("------------------------------------------------------------------------\n");
210:     }
211:     /* print line of stack trace */
212:     (*PetscErrorPrintf)("%s() line %d in %s%s\n",fun,line,dir,file);
213:   } else {
214:     /* do not print error messages since process 0 will print them, sleep before aborting so will not accidently kill process 0*/
215:     PetscSleep(10.0);
216:     abort();
217:   }
218:   PetscFunctionReturn(n);
219: }