Actual source code: adebug.c

petsc-3.7.3 2016-07-24
Report Typos and Errors
  1: /*
  2:       Code to handle PETSc starting up in debuggers,etc.
  3: */

  5: #include <petscsys.h>               /*I   "petscsys.h"   I*/
  6: #include <signal.h>
  7: #if defined(PETSC_HAVE_UNISTD_H)
  8: #include <unistd.h>
  9: #endif

 11: /*
 12:       These are the debugger and display used if the debugger is started up
 13: */
 14: static char      PetscDebugger[PETSC_MAX_PATH_LEN];
 15: static char      DebugTerminal[PETSC_MAX_PATH_LEN];
 16: static PetscBool Xterm = PETSC_TRUE;

 20: /*@C
 21:    PetscSetDebugTerminal - Sets the terminal to use (instead of xterm) for debugging.

 23:    Not Collective

 25:    Input Parameters:
 26: +  terminal - name of terminal and any flags required to execute a program.
 27:               For example "xterm -e", "urxvt -e".

 29:    Options Database Keys:
 30:    -debug_terminal terminal - use this terminal instead of xterm

 32:    Level: developer

 34:    Notes:
 35:    You can start the debugger for all processes in the same GNU screen session.

 37:      mpiexec -n 4 ./myapp -start_in_debugger -debug_terminal "screen -X -S debug screen"

 39:    will open 4 windows in the session named "debug".

 41:    Fortran Note:
 42:    This routine is not supported in Fortran.

 44:    Concepts: debugger^setting

 46: .seealso: PetscSetDebugger()
 47: @*/
 48: PetscErrorCode  PetscSetDebugTerminal(const char terminal[])
 49: {

 53:   PetscStrcpy(DebugTerminal,terminal);
 54:   return(0);
 55: }

 59: /*@C
 60:    PetscSetDebugger - Sets options associated with the debugger.

 62:    Not Collective

 64:    Input Parameters:
 65: +  debugger - name of debugger, which should be in your path,
 66:               usually "lldb", "dbx", "gdb", "idb", "xxgdb", "kdgb" or "ddd". Also, HP-UX
 67:               supports "xdb", and IBM rs6000 supports "xldb".

 69: -  xterm - flag to indicate debugger window, set to either PETSC_TRUE (to indicate
 70:             debugger should be started in a new xterm) or PETSC_FALSE (to start debugger
 71:             in initial window (the option PETSC_FALSE makes no sense when using more
 72:             than one MPI process.)

 74:    Level: developer

 76:    Fortran Note:
 77:    This routine is not supported in Fortran.

 79:   Concepts: debugger^setting

 81: .seealso: PetscAttachDebugger(), PetscAttachDebuggerErrorHandler()
 82: @*/
 83: PetscErrorCode  PetscSetDebugger(const char debugger[],PetscBool xterm)
 84: {

 88:   if (debugger) {
 89:     PetscStrcpy(PetscDebugger,debugger);
 90:   }
 91:   Xterm = xterm;
 92:   return(0);
 93: }

 97: /*@C
 98:     PetscSetDefaultDebugger - Causes PETSc to use its default  debugger.

100:    Not collective

102:     Level: developer

104: .seealso: PetscSetDebugger(), PetscSetDebuggerFromString()
105: @*/
106: PetscErrorCode  PetscSetDefaultDebugger(void)
107: {

111: #if defined(PETSC_USE_LLDB_DEBUGGER)
112:   PetscSetDebugger("lldb",PETSC_TRUE);
113: #elif defined(PETSC_USE_DBX_DEBUGGER)
114:   PetscSetDebugger("dbx",PETSC_TRUE);
115: #elif defined(PETSC_USE_XDB_DEBUGGER)
116:   PetscSetDebugger("xdb",PETSC_TRUE);
117: #elif defined(PETSC_USE_IDB_DEBUGGER)
118:   PetscSetDebugger("idb",PETSC_TRUE);
119: #else  /* Default is gdb */
120:   PetscSetDebugger("gdb",PETSC_TRUE);
121: #endif
122:   PetscSetDebugTerminal("xterm -e");
123:   return(0);
124: }

129: {
130:   PetscBool      exists;
131:   char           *f;

135:   PetscStrstr(string, defaultDbg, &f);
136:   if (f) {
137:     PetscTestFile(string, 'x', &exists);
138:     if (exists) *debugger = string;
139:     else        *debugger = defaultDbg;
140:   }
141:   return(0);
142: }

146: /*@C
147:     PetscSetDebuggerFromString - Set the complete path for the
148:        debugger for PETSc to use.

150:    Not collective

152:    Level: developer

154: .seealso: PetscSetDebugger(), PetscSetDefaultDebugger()
155: @*/
156: PetscErrorCode  PetscSetDebuggerFromString(const char *string)
157: {
158:   const char     *debugger = NULL;
159:   PetscBool      xterm     = PETSC_TRUE;
160:   char           *f;

164:   PetscStrstr(string, "noxterm", &f);
165:   if (f) xterm = PETSC_FALSE;
166:   PetscStrstr(string, "ddd", &f);
167:   if (f) xterm = PETSC_FALSE;

182:   PetscSetDebugger(debugger, xterm);
183:   return(0);
184: }


189: /*@
190:    PetscAttachDebugger - Attaches the debugger to the running process.

192:    Not Collective

194:    Level: advanced

196:    Concepts: debugger^starting from program

198:    Developer Notes: Since this can be called by the error handler should it be calling SETERRQ() and CHKERRQ()?

200: .seealso: PetscSetDebugger()
201: @*/
202: PetscErrorCode  PetscAttachDebugger(void)
203: {
204: #if !defined(PETSC_CANNOT_START_DEBUGGER)
205:   int            child    =0;
206:   PetscReal      sleeptime=0;
208:   char           program[PETSC_MAX_PATH_LEN],display[256],hostname[64];
209: #endif

212: #if defined(PETSC_CANNOT_START_DEBUGGER) || !defined(PETSC_HAVE_FORK)
213:   (*PetscErrorPrintf)("System cannot start debugger\n");
214:   (*PetscErrorPrintf)("On Cray run program in Totalview debugger\n");
215:   (*PetscErrorPrintf)("On Windows use Developer Studio(MSDEV)\n");
216:   MPI_Abort(PETSC_COMM_WORLD,1);
217: #else
218:   PetscGetDisplay(display,128);
219:   PetscGetProgramName(program,PETSC_MAX_PATH_LEN);
220:   if (ierr) {
221:     (*PetscErrorPrintf)("Cannot determine program name\n");
222:     PetscFunctionReturn(1);
223:   }
224:   if (!program[0]) {
225:     (*PetscErrorPrintf)("Cannot determine program name\n");
226:     PetscFunctionReturn(1);
227:   }
228:   child = (int)fork();
229:   if (child < 0) {
230:     (*PetscErrorPrintf)("Error in fork() attaching debugger\n");
231:     PetscFunctionReturn(1);
232:   }

234:   /*
235:       Swap role the parent and child. This is (I think) so that control c typed
236:     in the debugger goes to the correct process.
237:   */
238:   if (child) child = 0;
239:   else       child = (int)getppid();

241:   if (child) { /* I am the parent, will run the debugger */
242:     const char *args[10];
243:     char       pid[10];
244:     PetscInt   j,jj;
245:     PetscBool  isdbx,isidb,isxldb,isxxgdb,isups,isxdb,isworkshop,isddd,iskdbg,islldb;

247:     PetscGetHostName(hostname,64);
248:     /*
249:          We need to send a continue signal to the "child" process on the
250:        alpha, otherwise it just stays off forever
251:     */
252: #if defined(PETSC_NEED_KILL_FOR_DEBUGGER)
253:     kill(child,SIGCONT);
254: #endif
255:     sprintf(pid,"%d",child);

257:     PetscStrcmp(PetscDebugger,"xxgdb",&isxxgdb);
258:     PetscStrcmp(PetscDebugger,"ddd",&isddd);
259:     PetscStrcmp(PetscDebugger,"kdbg",&iskdbg);
260:     PetscStrcmp(PetscDebugger,"ups",&isups);
261:     PetscStrcmp(PetscDebugger,"xldb",&isxldb);
262:     PetscStrcmp(PetscDebugger,"xdb",&isxdb);
263:     PetscStrcmp(PetscDebugger,"dbx",&isdbx);
264:     PetscStrcmp(PetscDebugger,"idb",&isidb);
265:     PetscStrcmp(PetscDebugger,"workshop",&isworkshop);
266:     PetscStrcmp(PetscDebugger,"lldb",&islldb);

268:     if (isxxgdb || isups || isddd) {
269:       args[1] = program; args[2] = pid; args[3] = "-display";
270:       args[0] = PetscDebugger; args[4] = display; args[5] = 0;
271:       printf("PETSC: Attaching %s to %s %s on %s\n",args[0],args[1],pid,hostname);
272:       if (execvp(args[0],(char**)args)  < 0) {
273:         perror("Unable to start debugger");
274:         exit(0);
275:       }
276:     } else if (iskdbg) {
277:       args[1] = "-p"; args[2] = pid; args[3] = program;  args[4] = "-display";
278:       args[0] = PetscDebugger; args[5] = display; args[6] = 0;
279:       printf("PETSC: Attaching %s to %s %s on %s\n",args[0],args[3],pid,hostname);
280:       if (execvp(args[0],(char**)args)  < 0) {
281:         perror("Unable to start debugger");
282:         exit(0);
283:       }
284:     } else if (isxldb) {
285:       args[1] = "-a"; args[2] = pid; args[3] = program;  args[4] = "-display";
286:       args[0] = PetscDebugger; args[5] = display; args[6] = 0;
287:       printf("PETSC: Attaching %s to %s %s on %s\n",args[0],args[1],pid,hostname);
288:       if (execvp(args[0],(char**)args)  < 0) {
289:         perror("Unable to start debugger");
290:         exit(0);
291:       }
292:     } else if (isworkshop) {
293:       args[1] = "-s"; args[2] = pid; args[3] = "-D"; args[4] = "-";
294:       args[0] = PetscDebugger; args[5] = pid; args[6] = "-display"; args[7] = display; args[8] = 0;
295:       printf("PETSC: Attaching %s to %s on %s\n",args[0],pid,hostname);
296:       if (execvp(args[0],(char**)args)  < 0) {
297:         perror("Unable to start debugger");
298:         exit(0);
299:       }
300:     } else {
301:       j = 0;
302:       if (Xterm) {
303:         PetscBool cmp;
304:         char      *tmp,*tmp1;
305:         PetscStrncmp(DebugTerminal,"screen",6,&cmp);
306:         if (cmp) display[0] = 0; /* when using screen, we never pass -display */
307:         args[j++] = tmp = DebugTerminal;
308:         if (display[0]) {
309:           args[j++] = "-display"; args[j++] = display;
310:         }
311:         while (*tmp) {
312:           PetscStrchr(tmp,' ',&tmp1);
313:           if (!tmp1) break;
314:           *tmp1     = 0;
315:           tmp       = tmp1+1;
316:           args[j++] = tmp;
317:         }
318:       }
319:       args[j++] = PetscDebugger;
320:       jj = j;
321:       args[j++] = program; args[j++] = pid; args[j++] = 0;

323:       if (isidb) {
324:         j = jj;
325:         args[j++] = "-pid";
326:         args[j++] = pid;
327:         args[j++] = "-gdb";
328:         args[j++] = program;
329:         args[j++] = 0;
330:       }
331:       if (islldb) {
332:         j = jj;
333:         args[j++] = "-p";
334:         args[j++] = pid;
335:         args[j++] = 0;
336:       }
337:       if (isdbx) {
338:         j = jj;
339: #if defined(PETSC_USE_P_FOR_DEBUGGER)
340:         args[j++] = "-p";
341:         args[j++] = pid;
342:         args[j++] = program;
343: #elif defined(PETSC_USE_LARGEP_FOR_DEBUGGER)
344:         args[j++] = "-l";
345:         args[j++] = "ALL";
346:         args[j++] = "-P";
347:         args[j++] = pid;
348:         args[j++] = program;
349: #elif defined(PETSC_USE_A_FOR_DEBUGGER)
350:         args[j++] = "-a";
351:         args[j++] = pid;
352: #elif defined(PETSC_USE_PID_FOR_DEBUGGER)
353:         args[j++] = "-pid";
354:         args[j++] = pid;
355:         args[j++] = program;
356: #else
357:         args[j++] = program;
358:         args[j++] = pid;
359: #endif
360:         args[j++] = 0;
361:       }
362:       if (Xterm) {
363:         if (display[0]) printf("PETSC: Attaching %s to %s of pid %s on display %s on machine %s\n",PetscDebugger,program,pid,display,hostname);
364:         else            printf("PETSC: Attaching %s to %s on pid %s on %s\n",PetscDebugger,program,pid,hostname);

366:         if (execvp(args[0],(char**)args)  < 0) {
367:           perror("Unable to start debugger in xterm");
368:           exit(0);
369:         }
370:       } else {
371:         printf("PETSC: Attaching %s to %s of pid %s on %s\n",PetscDebugger,program,pid,hostname);
372:         if (execvp(args[0],(char**)args)  < 0) {
373:           perror("Unable to start debugger");
374:           exit(0);
375:         }
376:       }
377:     }
378:   } else {   /* I am the child, continue with user code */
379:     sleeptime = 10; /* default to sleep waiting for debugger */
380:     PetscOptionsGetReal(NULL,NULL,"-debugger_pause",&sleeptime,NULL);
381:     if (sleeptime < 0) sleeptime = -sleeptime;
382: #if defined(PETSC_NEED_DEBUGGER_NO_SLEEP)
383:     /*
384:         HP cannot attach process to sleeping debugger, hence count instead
385:     */
386:     {
387:       PetscReal x = 1.0;
388:       int       i =10000000;
389:       while (i--) x++;  /* cannot attach to sleeper */
390:     }
391: #elif defined(PETSC_HAVE_SLEEP_RETURNS_EARLY)
392:     /*
393:         IBM sleep may return at anytime, hence must see if there is more time to sleep
394:     */
395:     {
396:       int left = sleeptime;
397:       while (left > 0) left = PetscSleep(left) - 1;
398:     }
399: #else
400:     PetscSleep(sleeptime);
401: #endif
402:   }
403: #endif
404:   return(0);
405: }

409: /*@C
410:    PetscAttachDebuggerErrorHandler - Error handler that attaches
411:    a debugger to a running process when an error is detected.
412:    This routine is useful for examining variables, etc.

414:    Not Collective

416:    Input Parameters:
417: +  comm - communicator over which error occurred
418: .  line - the line number of the error (indicated by __LINE__)
419: .  fun - function where error occured (indicated by __FUNCT__)
420: .  file - the file in which the error was detected (indicated by __FILE__)
421: .  message - an error text string, usually just printed to the screen
422: .  number - the generic error number
423: .  p - PETSC_ERROR_INITIAL if error just detected, otherwise PETSC_ERROR_REPEAT
424: -  ctx - error handler context

426:    Options Database Keys:
427: .  -on_error_attach_debugger [noxterm,dbx,xxgdb,xdb,xldb,gdb] [-display name] - Activates
428:    debugger attachment

430:    Level: developer

432:    Notes:
433:    By default the GNU debugger, gdb, is used.  Alternatives are lldb, dbx and
434:    xxgdb,xldb (on IBM rs6000), xdb (on HP-UX).

436:    Most users need not directly employ this routine and the other error
437:    handlers, but can instead use the simplified interface SETERR, which has
438:    the calling sequence
439: $     SETERRQ(PETSC_COMM_SELF,number,p,message)

441:    Notes for experienced users:
442:    Use PetscPushErrorHandler() to set the desired error handler.  The
443:    currently available PETSc error handlers are
444: $    PetscTraceBackErrorHandler()
445: $    PetscAttachDebuggerErrorHandler()
446: $    PetscAbortErrorHandler()
447:    or you may write your own.

449:    Concepts: debugger^error handler
450:    Concepts: error handler^attach debugger

452: .seealso:  PetscPushErrorHandler(), PetscTraceBackErrorHandler(),
453:            PetscAbortErrorHandler()
454: @*/
455: PetscErrorCode  PetscAttachDebuggerErrorHandler(MPI_Comm comm,int line,const char *fun,const char *file,PetscErrorCode num,PetscErrorType p,const char *mess,void *ctx)
456: {

460:   if (!fun) fun = "User provided function";
461:   if (!mess) mess = " ";

463:   (*PetscErrorPrintf)("%s() line %d in %s %s\n",fun,line,file,mess);

465:   PetscAttachDebugger();
466:   if (ierr) abort(); /* call abort because don't want to kill other MPI processes that may successfully attach to debugger */
467:   return(0);
468: }

472: /*@C
473:    PetscStopForDebugger - Prints a message to the screen indicating how to
474:          attach to the process with the debugger and then waits for the
475:          debugger to attach.

477:    Not Collective

479:    Level: developer

481:    Notes: This is likely never needed since PetscAttachDebugger() is easier to use and seems to always work.

483:    Developer Notes: Since this can be called by the error handler, should it be calling SETERRQ() and CHKERRQ()?

485:    Concepts: debugger^waiting for attachment

487: .seealso: PetscSetDebugger(), PetscAttachDebugger()
488: @*/
489: PetscErrorCode  PetscStopForDebugger(void)
490: {
492:   PetscInt       sleeptime=0;
493: #if !defined(PETSC_CANNOT_START_DEBUGGER)
494:   int            ppid;
495:   PetscMPIInt    rank;
496:   char           program[PETSC_MAX_PATH_LEN],hostname[256];
497:   PetscBool      isdbx,isxldb,isxxgdb,isddd,iskdbg,isups,isxdb,islldb;
498: #endif

501: #if defined(PETSC_CANNOT_START_DEBUGGER)
502:   (*PetscErrorPrintf)("System cannot start debugger; just continuing program\n");
503: #else
504:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
505:   if (ierr) rank = 0; /* ignore error since this may be already in error handler */
506:   PetscGetHostName(hostname,256);
507:   if (ierr) {
508:     (*PetscErrorPrintf)("Cannot determine hostname; just continuing program\n");
509:     return(0);
510:   }

512:   PetscGetProgramName(program,256);
513:   if (ierr) {
514:     (*PetscErrorPrintf)("Cannot determine program name; just continuing program\n");
515:     return(0);
516:   }
517:   if (!program[0]) {
518:     (*PetscErrorPrintf)("Cannot determine program name; just continuing program\n");
519:     return(0);
520:   }

522:   ppid = getpid();

524:   PetscStrcmp(PetscDebugger,"xxgdb",&isxxgdb);
525:   PetscStrcmp(PetscDebugger,"ddd",&isddd);
526:   PetscStrcmp(PetscDebugger,"kdbg",&iskdbg);
527:   PetscStrcmp(PetscDebugger,"ups",&isups);
528:   PetscStrcmp(PetscDebugger,"xldb",&isxldb);
529:   PetscStrcmp(PetscDebugger,"xdb",&isxdb);
530:   PetscStrcmp(PetscDebugger,"dbx",&isdbx);
531:   PetscStrcmp(PetscDebugger,"lldb",&islldb);

533:   if (isxxgdb || isups || isddd || iskdbg) printf("[%d]%s>>%s %s %d\n",rank,hostname,PetscDebugger,program,ppid);
534:   else if (isxldb) printf("[%d]%s>>%s -a %d %s\n",rank,hostname,PetscDebugger,ppid,program);
535:   else if (islldb) printf("[%d]%s>>%s -p %d\n",rank,hostname,PetscDebugger,ppid);
536:   else if (isdbx) {
537: #if defined(PETSC_USE_P_FOR_DEBUGGER)
538:      printf("[%d]%s>>%s -p %d %s\n",rank,hostname,PetscDebugger,ppid,program);
539: #elif defined(PETSC_USE_LARGEP_FOR_DEBUGGER)
540:      printf("[%d]%s>>%s -l ALL -P %d %s\n",rank,hostname,PetscDebugger,ppid,program);
541: #elif defined(PETSC_USE_A_FOR_DEBUGGER)
542:      printf("[%d]%s>>%s -a %d\n",rank,hostname,PetscDebugger,ppid);
543: #elif defined(PETSC_USE_PID_FOR_DEBUGGER)
544:      printf("[%d]%s>>%s -pid %d %s\n",rank,hostname,PetscDebugger,ppid,program);
545: #else
546:      printf("[%d]%s>>%s %s %d\n",rank,hostname,PetscDebugger,program,ppid);
547: #endif
548:   }
549: #endif /* PETSC_CANNOT_START_DEBUGGER */

551:   fflush(stdout); /* ignore error because may already be in error handler */

553:   sleeptime = 25; /* default to sleep waiting for debugger */
554:   PetscOptionsGetInt(NULL,NULL,"-debugger_pause",&sleeptime,NULL); /* ignore error because may already be in error handler */
555:   if (sleeptime < 0) sleeptime = -sleeptime;
556: #if defined(PETSC_NEED_DEBUGGER_NO_SLEEP)
557:   /*
558:       HP cannot attach process to sleeping debugger, hence count instead
559:   */
560:   {
561:     PetscReal x = 1.0;
562:     int       i =10000000;
563:     while (i--) x++;  /* cannot attach to sleeper */
564:   }
565: #elif defined(PETSC_HAVE_SLEEP_RETURNS_EARLY)
566:   /*
567:       IBM sleep may return at anytime, hence must see if there is more time to sleep
568:   */
569:   {
570:     int left = sleeptime;
571:     while (left > 0) left = sleep(left) - 1;
572:   }
573: #else
574:   PetscSleep(sleeptime);
575: #endif
576:   return(0);
577: }