Actual source code: pinit.c

  1: #define PETSC_DLL
  2: /*
  3:    This file defines the initialization of PETSc, including PetscInitialize()
  4: */

 6:  #include petsc.h
 7:  #include petscsys.h

  9: #if defined(PETSC_USE_LOG)
 10: EXTERN PetscErrorCode PetscLogBegin_Private(void);
 11: #endif

 13: /* -----------------------------------------------------------------------------------------*/


 17: EXTERN PetscErrorCode PetscInitialize_DynamicLibraries(void);
 18: EXTERN PetscErrorCode PetscFinalize_DynamicLibraries(void);
 19: EXTERN PetscErrorCode PetscFListDestroyAll(void);
 20: EXTERN PetscErrorCode PetscSequentialPhaseBegin_Private(MPI_Comm,int);
 21: EXTERN PetscErrorCode PetscSequentialPhaseEnd_Private(MPI_Comm,int);
 22: EXTERN PetscErrorCode PetscLogCloseHistoryFile(FILE **);

 24: /* this is used by the _, __, and ___ macros (see include/petscerror.h) */
 25: PetscErrorCode __g0;

 27: /* user may set this BEFORE calling PetscInitialize() */
 28: MPI_Comm PETSC_COMM_WORLD = 0;

 30: /*
 31:      Declare and set all the string names of the PETSc enums
 32: */
 33: const char *PetscTruths[]    = {"FALSE","TRUE","PetscTruth","PETSC_",0};
 34: const char *PetscDataTypes[] = {"INT", "DOUBLE", "COMPLEX",
 35:                                 "LONG","SHORT",  "FLOAT",
 36:                                 "CHAR","LOGICAL","ENUM","TRUTH","LONGDOUBLE","PetscDataType","PETSC_",0};

 38: PetscCookie PETSC_LARGEST_COOKIE = PETSC_SMALLEST_COOKIE;
 39: PetscCookie PETSC_OBJECT_COOKIE = 0;

 41: PetscTruth PetscPreLoadingUsed = PETSC_FALSE;
 42: PetscTruth PetscPreLoadingOn   = PETSC_FALSE;

 44: PetscErrorCode  PetscCookieRegister(PetscCookie *cookie)
 45: {
 46:   if (*cookie == PETSC_DECIDE || *cookie == PETSC_NULL) {
 47:     *cookie = ++PETSC_LARGEST_COOKIE;
 48:   } else if (*cookie > 0) {
 49:     /* Need to check here for montonicity and insert if necessary */
 50:     return 0;
 51:   } else {
 52:     SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE, "Invalid suggested cookie %d", (int)*cookie);
 53:   }
 54:   return 0;
 55: }

 57: /*
 58:        Checks the options database for initializations related to the 
 59:     PETSc components
 60: */
 63: PetscErrorCode  PetscOptionsCheckInitial_Components(void)
 64: {
 65:   PetscTruth flg1;

 69:   PetscOptionsHasName(PETSC_NULL,"-help",&flg1);
 70:   if (flg1) {
 71: #if defined (PETSC_USE_LOG)
 72:     MPI_Comm   comm = PETSC_COMM_WORLD;
 73:     (*PetscHelpPrintf)(comm,"------Additional PETSc component options--------\n");
 74:     (*PetscHelpPrintf)(comm," -log_summary_exclude: <vec,mat,pc.ksp,snes>\n");
 75:     (*PetscHelpPrintf)(comm," -info_exclude: <null,vec,mat,pc,ksp,snes,ts>\n");
 76:     (*PetscHelpPrintf)(comm,"-----------------------------------------------\n");
 77: #endif
 78:   }
 79:   return(0);
 80: }

 84: /*@C
 85:       PetscInitializeNoArguments - Calls PetscInitialize() from C/C++ without
 86:         the command line arguments.

 88:    Collective
 89:   
 90:    Level: advanced

 92: .seealso: PetscInitialize(), PetscInitializeFortran()
 93: @*/
 94: PetscErrorCode  PetscInitializeNoArguments(void)
 95: {
 97:   int            argc = 0;
 98:   char           **args = 0;

101:   PetscInitialize(&argc,&args,PETSC_NULL,PETSC_NULL);
102:   PetscFunctionReturn(ierr);
103: }

107: /*@
108:       PetscInitialized - Determine whether PETSc is initialized.
109:   
110:    Level: beginner

112: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
113: @*/
114: PetscErrorCode  PetscInitialized(PetscTruth *isInitialized)
115: {
118:   *isInitialized = PetscInitializeCalled;
119:   return(0);
120: }

124: /*@
125:       PetscFinalized - Determine whether PetscFinalize() has been called yet
126:   
127:    Level: developer

129: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
130: @*/
131: PetscErrorCode  PetscFinalized(PetscTruth *isFinalized)
132: {
135:   *isFinalized = PetscFinalizeCalled;
136:   return(0);
137: }

139: EXTERN PetscErrorCode        PetscOptionsCheckInitial_Private(void);

142: /*
143:        This function is the MPI reduction operation used to compute the sum of the 
144:    first half of the datatype and the max of the second half.
145: */
146: MPI_Op PetscMaxSum_Op = 0;

151: void  PetscMaxSum_Local(void *in,void *out,int *cnt,MPI_Datatype *datatype)
152: {
153:   PetscInt *xin = (PetscInt*)in,*xout = (PetscInt*)out,i,count = *cnt;

156:   if (*datatype != MPIU_2INT) {
157:     (*PetscErrorPrintf)("Can only handle MPIU_2INT data types");
158:     MPI_Abort(MPI_COMM_WORLD,1);
159:   }

161:   for (i=0; i<count; i++) {
162:     xout[2*i]    = PetscMax(xout[2*i],xin[2*i]);
163:     xout[2*i+1] += xin[2*i+1];
164:   }
165:   PetscStackPop;
166:   return;
167: }

170: /*
171:     Returns the max of the first entry owned by this processor and the
172: sum of the second entry.
173: */
176: PetscErrorCode  PetscMaxSum(MPI_Comm comm,const PetscInt nprocs[],PetscInt *max,PetscInt *sum)
177: {
178:   PetscMPIInt    size,rank;
179:   PetscInt       *work;

183:   MPI_Comm_size(comm,&size);
184:   MPI_Comm_rank(comm,&rank);
185:   PetscMalloc(2*size*sizeof(PetscInt),&work);
186:   MPI_Allreduce((void*)nprocs,work,size,MPIU_2INT,PetscMaxSum_Op,comm);
187:   *max   = work[2*rank];
188:   *sum   = work[2*rank+1];
189:   PetscFree(work);
190:   return(0);
191: }

193: /* ----------------------------------------------------------------------------*/
194: MPI_Op  PetscADMax_Op = 0;

199: void  PetscADMax_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
200: {
201:   PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
202:   PetscInt    i,count = *cnt;

205:   if (*datatype != MPIU_2SCALAR) {
206:     (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
207:     MPI_Abort(MPI_COMM_WORLD,1);
208:   }

210:   for (i=0; i<count; i++) {
211:     if (PetscRealPart(xout[2*i]) < PetscRealPart(xin[2*i])) {
212:       xout[2*i]   = xin[2*i];
213:       xout[2*i+1] = xin[2*i+1];
214:     }
215:   }

217:   PetscStackPop;
218:   return;
219: }

222: MPI_Op  PetscADMin_Op = 0;

227: void  PetscADMin_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
228: {
229:   PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
230:   PetscInt    i,count = *cnt;

233:   if (*datatype != MPIU_2SCALAR) {
234:     (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
235:     MPI_Abort(MPI_COMM_WORLD,1);
236:   }

238:   for (i=0; i<count; i++) {
239:     if (PetscRealPart(xout[2*i]) > PetscRealPart(xin[2*i])) {
240:       xout[2*i]   = xin[2*i];
241:       xout[2*i+1] = xin[2*i+1];
242:     }
243:   }

245:   PetscStackPop;
246:   return;
247: }
249: /* ---------------------------------------------------------------------------------------*/

251: #if defined(PETSC_USE_COMPLEX)
252: MPI_Op PetscSum_Op = 0;

257: void  PetscSum_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
258: {
259:   PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
260:   PetscInt         i,count = *cnt;

263:   if (*datatype != MPIU_SCALAR) {
264:     (*PetscErrorPrintf)("Can only handle MPIU_SCALAR data (i.e. double or complex) types");
265:     MPI_Abort(MPI_COMM_WORLD,1);
266:   }

268:   for (i=0; i<count; i++) {
269:     xout[i] += xin[i];
270:   }

272:   PetscStackPop;
273:   return;
274: }
276: #endif

278: static int  PetscGlobalArgc   = 0;
279: static char **PetscGlobalArgs = 0;

283: /*@C
284:    PetscGetArgs - Allows you to access the raw command line arguments anywhere
285:      after PetscInitialize() is called but before PetscFinalize().

287:    Not Collective

289:    Output Parameters:
290: +  argc - count of number of command line arguments
291: -  args - the command line arguments

293:    Level: intermediate

295:    Notes:
296:       This is usually used to pass the command line arguments into other libraries
297:    that are called internally deep in PETSc or the application.

299:    Concepts: command line arguments
300:    
301: .seealso: PetscFinalize(), PetscInitializeFortran()

303: @*/
304: PetscErrorCode  PetscGetArgs(int *argc,char ***args)
305: {
307:   if (!PetscGlobalArgs) {
308:     SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
309:   }
310:   *argc = PetscGlobalArgc;
311:   *args = PetscGlobalArgs;
312:   return(0);
313: }

317: /*@C
318:    PetscInitialize - Initializes the PETSc database and MPI. 
319:    PetscInitialize() calls MPI_Init() if that has yet to be called,
320:    so this routine should always be called near the beginning of 
321:    your program -- usually the very first line! 

323:    Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set

325:    Input Parameters:
326: +  argc - count of number of command line arguments
327: .  args - the command line arguments
328: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
329:           (use PETSC_NULL for default)
330: -  help - [optional] Help message to print, use PETSC_NULL for no message

332:    If you wish PETSc to run on a subcommunicator of MPI_COMM_WORLD, create that
333:    communicator first and assign it to PETSC_COMM_WORLD BEFORE calling PetscInitialize()

335:    Options Database Keys:
336: +  -start_in_debugger [noxterm,dbx,xdb,gdb,...] - Starts program in debugger
337: .  -on_error_attach_debugger [noxterm,dbx,xdb,gdb,...] - Starts debugger when error detected
338: .  -on_error_emacs <machinename> causes emacsclient to jump to error file
339: .  -debugger_nodes [node1,node2,...] - Indicates nodes to start in debugger
340: .  -debugger_pause [sleeptime] (in seconds) - Pauses debugger
341: .  -stop_for_debugger - Print message on how to attach debugger manually to 
342:                         process and wait (-debugger_pause) seconds for attachment
343: .  -malloc - Indicates use of PETSc error-checking malloc (on by default for debug version of libraries)
344: .  -malloc no - Indicates not to use error-checking malloc
345: .  -malloc_debug - check for memory corruption at EVERY malloc or free
346: .  -fp_trap - Stops on floating point exceptions (Note that on the
347:               IBM RS6000 this slows code by at least a factor of 10.)
348: .  -no_signal_handler - Indicates not to trap error signals
349: .  -shared_tmp - indicates /tmp directory is shared by all processors
350: .  -not_shared_tmp - each processor has own /tmp
351: .  -tmp - alternative name of /tmp directory
352: .  -get_total_flops - returns total flops done by all processors
353: -  -memory_info - Print memory usage at end of run

355:    Options Database Keys for Profiling:
356:    See the Profiling chapter of the users manual for details.
357: +  -log_trace [filename] - Print traces of all PETSc calls
358:         to the screen (useful to determine where a program
359:         hangs without running in the debugger).  See PetscLogTraceBegin().
360: .  -info <optional filename> - Prints verbose information to the screen
361: -  -info_exclude <null,vec,mat,pc,ksp,snes,ts> - Excludes some of the verbose messages

363:    Environmental Variables:
364: +   PETSC_TMP - alternative tmp directory
365: .   PETSC_SHARED_TMP - tmp is shared by all processes
366: .   PETSC_NOT_SHARED_TMP - each process has its own private tmp
367: .   PETSC_VIEWER_SOCKET_PORT - socket number to use for socket viewer
368: -   PETSC_VIEWER_SOCKET_MACHINE - machine to use for socket viewer to connect to


371:    Level: beginner

373:    Notes:
374:    If for some reason you must call MPI_Init() separately, call
375:    it before PetscInitialize().

377:    Fortran Version:
378:    In Fortran this routine has the format
379: $       call PetscInitialize(file,ierr)

381: +   ierr - error return code
382: -   file - [optional] PETSc database file name, defaults to 
383:            ~username/.petscrc (use PETSC_NULL_CHARACTER for default)
384:            
385:    Important Fortran Note:
386:    In Fortran, you MUST use PETSC_NULL_CHARACTER to indicate a
387:    null character string; you CANNOT just use PETSC_NULL as 
388:    in the C version.  See the users manual for details.


391:    Concepts: initializing PETSc
392:    
393: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs()

395: @*/
396: PetscErrorCode  PetscInitialize(int *argc,char ***args,const char file[],const char help[])
397: {
399:   PetscMPIInt    flag, size;
400:   PetscTruth     flg;
401:   char           hostname[256];

404:   if (PetscInitializeCalled) return(0);

406:   /* this must be initialized in a routine, not as a constant declaration*/
407:   PETSC_STDOUT = stdout;

409:   PetscOptionsCreate();

411:   /*
412:      We initialize the program name here (before MPI_Init()) because MPICH has a bug in 
413:      it that it sets args[0] on all processors to be args[0] on the first processor.
414:   */
415:   if (argc && *argc) {
416:     PetscSetProgramName(**args);
417:   } else {
418:     PetscSetProgramName("Unknown Name");
419:   }


422:   MPI_Initialized(&flag);
423:   if (!flag) {
424:     if (PETSC_COMM_WORLD) SETERRQ(PETSC_ERR_SUP,"You cannot set PETSC_COMM_WORLD if you have not initialized MPI first");
425:     MPI_Init(argc,args);
426:     PetscBeganMPI = PETSC_TRUE;
427:   }
428:   if (argc && args) {
429:     PetscGlobalArgc = *argc;
430:     PetscGlobalArgs = *args;
431:   }
432:   PetscInitializeCalled = PETSC_TRUE;
433:   PetscFinalizeCalled   = PETSC_FALSE;

435:   if (!PETSC_COMM_WORLD) {
436:     PETSC_COMM_WORLD = MPI_COMM_WORLD;
437:   }

439:   /* Done after init due to a bug in MPICH-GM? */
440:   PetscErrorPrintfInitialize();

442:   MPI_Comm_rank(MPI_COMM_WORLD,&PetscGlobalRank);
443:   MPI_Comm_size(MPI_COMM_WORLD,&PetscGlobalSize);

445: #if defined(PETSC_USE_COMPLEX)
446:   /* 
447:      Initialized the global complex variable; this is because with 
448:      shared libraries the constructors for global variables
449:      are not called; at least on IRIX.
450:   */
451:   {
452: #if defined(PETSC_CLANGUAGE_CXX)
453:     PetscScalar ic(0.0,1.0);
454:     PETSC_i = ic;
455: #else
456:     PetscScalar ic;
457:     ic = 1.I;
458:     PETSC_i = ic;
459: #endif
460:   }

462:   MPI_Type_contiguous(2,MPIU_REAL,&MPIU_COMPLEX);
463:   MPI_Type_commit(&MPIU_COMPLEX);
464:   MPI_Op_create(PetscSum_Local,1,&PetscSum_Op);
465: #endif

467:   /*
468:      Create the PETSc MPI reduction operator that sums of the first
469:      half of the entries and maxes the second half.
470:   */
471:   MPI_Op_create(PetscMaxSum_Local,1,&PetscMaxSum_Op);

473:   MPI_Type_contiguous(2,MPIU_SCALAR,&MPIU_2SCALAR);
474:   MPI_Type_commit(&MPIU_2SCALAR);
475:   MPI_Op_create(PetscADMax_Local,1,&PetscADMax_Op);
476:   MPI_Op_create(PetscADMin_Local,1,&PetscADMin_Op);

478:   MPI_Type_contiguous(2,MPIU_INT,&MPIU_2INT);
479:   MPI_Type_commit(&MPIU_2INT);

481:   /*
482:      Build the options database and check for user setup requests
483:   */
484:   PetscOptionsInsert(argc,args,file);

486:   /*
487:      Print main application help message
488:   */
489:   PetscOptionsHasName(PETSC_NULL,"-help",&flg);
490:   if (help && flg) {
491:     PetscPrintf(PETSC_COMM_WORLD,help);
492:   }
493:   PetscOptionsCheckInitial_Private();

495:   /* SHOULD PUT IN GUARDS: Make sure logging is initialized, even if we do not print it out */
496: #if defined(PETSC_USE_LOG)
497:   PetscLogBegin_Private();
498: #endif

500:   /*
501:      Load the dynamic libraries (on machines that support them), this registers all
502:      the solvers etc. (On non-dynamic machines this initializes the PetscDraw and PetscViewer classes)
503:   */
504:   PetscInitialize_DynamicLibraries();

506:   /*
507:      Initialize all the default viewers
508:   */
509:   MPI_Comm_size(PETSC_COMM_WORLD,&size);
510:   PetscInfo1(0,"PETSc successfully started: number of processors = %d\n",size);
511:   PetscGetHostName(hostname,256);
512:   PetscInfo1(0,"Running on machine: %s\n",hostname);

514:   PetscOptionsCheckInitial_Components();
515:   /* Check the options database for options related to the options database itself */
516:   PetscOptionsSetFromOptions();


519:   PetscFunctionReturn(ierr);
520: }


525: /*@C 
526:    PetscFinalize - Checks for options to be called at the conclusion
527:    of the program. MPI_Finalize() is called only if the user had not
528:    called MPI_Init() before calling PetscInitialize().

530:    Collective on PETSC_COMM_WORLD

532:    Options Database Keys:
533: +  -options_table - Calls PetscOptionsPrint()
534: .  -options_left - Prints unused options that remain in the database
535: .  -options_left no - Does not print unused options that remain in the database
536: .  -mpidump - Calls PetscMPIDump()
537: .  -malloc_dump - Calls PetscMallocDump()
538: .  -malloc_info - Prints total memory usage
539: -  -malloc_log - Prints summary of memory usage

541:    Options Database Keys for Profiling:
542:    See the Profiling chapter of the users manual for details.
543: +  -log_summary [filename] - Prints summary of flop and timing
544:         information to screen. If the filename is specified the
545:         summary is written to the file. (for code compiled with 
546:         PETSC_USE_LOG).  See PetscLogPrintSummary().
547: .  -log_all [filename] - Logs extensive profiling information
548:         (for code compiled with PETSC_USE_LOG). See PetscLogDump(). 
549: .  -log [filename] - Logs basic profiline information (for
550:         code compiled with PETSC_USE_LOG).  See PetscLogDump().
551: .  -log_sync - Log the synchronization in scatters, inner products
552:         and norms
553: -  -log_mpe [filename] - Creates a logfile viewable by the 
554:       utility Upshot/Nupshot (in MPICH distribution)

556:    Level: beginner

558:    Note:
559:    See PetscInitialize() for more general runtime options.

561: .seealso: PetscInitialize(), PetscOptionsPrint(), PetscMallocDump(), PetscMPIDump(), PetscEnd()
562: @*/
563: PetscErrorCode  PetscFinalize(void)
564: {
566:   PetscMPIInt    rank;
567:   int            nopt;
568:   PetscTruth     flg1,flg2,flg3;
569: 

572:   if (!PetscInitializeCalled) {
573:     (*PetscErrorPrintf)("PetscInitialize() must be called before PetscFinalize()\n");
574:     return(0);
575:   }

577:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
578:   PetscOptionsHasName(PETSC_NULL,"-malloc_info",&flg2);
579:   if (!flg2) {
580:     PetscOptionsHasName(PETSC_NULL,"-memory_info",&flg2);
581:   }
582:   if (flg2) {
583:     PetscMemoryShowUsage(PETSC_VIEWER_STDOUT_WORLD,"Summary of Memory Usage in PETSc\n");
584:   }

586:   /* Destroy auxiliary packages */
587: #if defined(PETSC_HAVE_MATHEMATICA)
588:   PetscViewerMathematicaFinalizePackage();
589: #endif

591:   /*
592:      Destroy all the function registration lists created
593:   */
594:   PetscFinalize_DynamicLibraries();

596: #if defined(PETSC_USE_LOG)
597:   PetscOptionsHasName(PETSC_NULL,"-get_total_flops",&flg1);
598:   if (flg1) {
599:     PetscLogDouble flops = 0;
600:     MPI_Reduce(&_TotalFlops,&flops,1,MPI_DOUBLE,MPI_SUM,0,PETSC_COMM_WORLD);
601:     PetscPrintf(PETSC_COMM_WORLD,"Total flops over all processors %g\n",flops);
602:   }
603: #endif

605:   /*
606:      Free all objects registered with PetscObjectRegisterDestroy() such ast
607:     PETSC_VIEWER_XXX_().
608:   */
609:   PetscObjectRegisterDestroyAll();

611: #if defined(PETSC_USE_DEBUG)
612:   if (PetscStackActive) {
613:     PetscStackDestroy();
614:   }
615: #endif

617: #if defined(PETSC_USE_LOG)
618:   {
619:     char mname[PETSC_MAX_PATH_LEN];
620: #if defined(PETSC_HAVE_MPE)
621:     mname[0] = 0;
622:     PetscOptionsGetString(PETSC_NULL,"-log_mpe",mname,PETSC_MAX_PATH_LEN,&flg1);
623:     if (flg1){
624:       if (mname[0]) {PetscLogMPEDump(mname);}
625:       else          {PetscLogMPEDump(0);}
626:     }
627: #endif
628:     mname[0] = 0;
629:     PetscOptionsGetString(PETSC_NULL,"-log_summary",mname,PETSC_MAX_PATH_LEN,&flg1);
630:     if (flg1) {
631:       if (mname[0])  {PetscLogPrintSummary(PETSC_COMM_WORLD,mname);}
632:       else           {PetscLogPrintSummary(PETSC_COMM_WORLD,0);}
633:     }

635:     mname[0] = 0;
636:     PetscOptionsGetString(PETSC_NULL,"-log_all",mname,PETSC_MAX_PATH_LEN,&flg1);
637:     PetscOptionsGetString(PETSC_NULL,"-log",mname,PETSC_MAX_PATH_LEN,&flg2);
638:     if (flg1 || flg2){
639:       if (mname[0]) PetscLogDump(mname);
640:       else          PetscLogDump(0);
641:     }
642:     PetscLogDestroy();
643:   }
644: #endif
645:   PetscOptionsHasName(PETSC_NULL,"-no_signal_handler",&flg1);
646:   if (!flg1) { PetscPopSignalHandler();}
647:   PetscOptionsHasName(PETSC_NULL,"-mpidump",&flg1);
648:   if (flg1) {
649:     PetscMPIDump(stdout);
650:   }
651:   PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
652:   PetscOptionsHasName(PETSC_NULL,"-options_table",&flg2);
653:   if (flg2) {
654:     if (!rank) {PetscOptionsPrint(stdout);}
655:   }

657:   /* to prevent PETSc -options_left from warning */
658:   PetscOptionsHasName(PETSC_NULL,"-nox_warning",&flg1);CHKERRQ(ierr)
659:   PetscOptionsHasName(PETSC_NULL,"-error_output_stderr",&flg1);

661:   flg3 = PETSC_FALSE; /* default value is required */
662:   PetscOptionsGetTruth(PETSC_NULL,"-options_left",&flg3,&flg1);
663:   PetscOptionsAllUsed(&nopt);
664:   if (flg3) {
665:     if (!flg2) { /* have not yet printed the options */
666:       PetscOptionsPrint(stdout);
667:     }
668:     if (!nopt) {
669:       PetscPrintf(PETSC_COMM_WORLD,"There are no unused options.\n");
670:     } else if (nopt == 1) {
671:       PetscPrintf(PETSC_COMM_WORLD,"There is one unused database option. It is:\n");
672:     } else {
673:       PetscPrintf(PETSC_COMM_WORLD,"There are %d unused database options. They are:\n",nopt);
674:     }
675:   }
676: #if defined(PETSC_USE_DEBUG)
677:   if (nopt && !flg3 && !flg1) {
678:     PetscPrintf(PETSC_COMM_WORLD,"WARNING! There are options you set that were not used!\n");
679:     PetscPrintf(PETSC_COMM_WORLD,"WARNING! could be spelling mistake, etc!\n");
680:     PetscOptionsLeft();
681:   } else if (nopt && flg3) {
682: #else 
683:   if (nopt && flg3) {
684: #endif
685:     PetscOptionsLeft();
686:   }

688:   PetscOptionsHasName(PETSC_NULL,"-log_history",&flg1);
689:   if (flg1) {
690:     PetscLogCloseHistoryFile(&petsc_history);
691:     petsc_history = 0;
692:   }

694:   PetscInfoAllow(PETSC_FALSE,PETSC_NULL);

696:   /*
697:        Free all the registered create functions, such as KSPList, VecList, SNESList, etc
698:   */
699:   PetscFListDestroyAll();

701:   PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
702:   PetscOptionsHasName(PETSC_NULL,"-malloc_log",&flg3);
703:   if (flg1) {
704:     char fname[PETSC_MAX_PATH_LEN];
705:     FILE *fd;
706: 
707:     fname[0] = 0;
708:     PetscOptionsGetString(PETSC_NULL,"-malloc_dump",fname,250,&flg1);
709:     if (flg1 && fname[0]) {
710:       char sname[PETSC_MAX_PATH_LEN];

712:       sprintf(sname,"%s_%d",fname,rank);
713:       fd   = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
714:       PetscMallocDump(fd);
715:       fclose(fd);
716:     } else {
717:       MPI_Comm local_comm;

719:       MPI_Comm_dup(MPI_COMM_WORLD,&local_comm);
720:       PetscSequentialPhaseBegin_Private(local_comm,1);
721:         PetscMallocDump(stdout);
722:       PetscSequentialPhaseEnd_Private(local_comm,1);
723:       MPI_Comm_free(&local_comm);
724:     }
725:   }
726:   if (flg3) {
727:     char fname[PETSC_MAX_PATH_LEN];
728:     FILE *fd;
729: 
730:     fname[0] = 0;
731:     PetscOptionsGetString(PETSC_NULL,"-malloc_log",fname,250,&flg1);
732:     if (flg1 && fname[0]) {
733:       char sname[PETSC_MAX_PATH_LEN];

735:       sprintf(sname,"%s_%d",fname,rank);
736:       fd   = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
737:       PetscMallocDumpLog(fd);
738:       fclose(fd);
739:     } else {
740:       PetscMallocDumpLog(stdout);
741:     }
742:   }
743:   /* Can be destroyed only after all the options are used */
744:   PetscOptionsDestroy();

746:   PetscGlobalArgc = 0;
747:   PetscGlobalArgs = 0;

749: #if defined(PETSC_USE_COMPLEX)
750:   MPI_Op_free(&PetscSum_Op);
751:   MPI_Type_free(&MPIU_COMPLEX);
752: #endif
753:   MPI_Type_free(&MPIU_2SCALAR);
754:   MPI_Type_free(&MPIU_2INT);
755:   MPI_Op_free(&PetscMaxSum_Op);
756:   MPI_Op_free(&PetscADMax_Op);
757:   MPI_Op_free(&PetscADMin_Op);

759:   PetscInfo(0,"PETSc successfully ended!\n");
760:   if (PetscBeganMPI) {
761:     MPI_Finalize();
762:   }

764: /*

766:      Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because 
767:    the communicator has some outstanding requests on it. Specifically if the 
768:    flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See 
769:    src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate()
770:    is never freed as it should be. Thus one may obtain messages of the form
771:    [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/mpiu.c indicating the
772:    memory was not freed.

774: */
775:   PetscClearMalloc();
776:   PetscInitializeCalled = PETSC_FALSE;
777:   PetscFinalizeCalled   = PETSC_TRUE;
778:   PetscFunctionReturn(ierr);
779: }

781: /*
782:      These may be used in code that ADIC is to be used on
783: */

787: /*@C
788:       PetscGlobalMax - Computes the maximum value over several processors

790:      Collective on MPI_Comm

792:    Input Parameters:
793: +   local - the local value
794: -   comm - the processors that find the maximum

796:    Output Parameter:
797: .   result - the maximum value
798:   
799:    Level: intermediate

801:    Notes:
802:      These functions are to be used inside user functions that are to be processed with 
803:    ADIC. PETSc will automatically provide differentiated versions of these functions

805: .seealso: PetscGlobalMin(), PetscGlobalSum()
806: @*/
807: PetscErrorCode  PetscGlobalMax(PetscReal* local,PetscReal* result,MPI_Comm comm)
808: {
809:   return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MAX,comm);
810: }

814: /*@C
815:       PetscGlobalMin - Computes the minimum value over several processors

817:      Collective on MPI_Comm

819:    Input Parameters:
820: +   local - the local value
821: -   comm - the processors that find the minimum

823:    Output Parameter:
824: .   result - the minimum value
825:   
826:    Level: intermediate

828:    Notes:
829:      These functions are to be used inside user functions that are to be processed with 
830:    ADIC. PETSc will automatically provide differentiated versions of these functions

832: .seealso: PetscGlobalMax(), PetscGlobalSum()
833: @*/
834: PetscErrorCode  PetscGlobalMin(PetscReal* local,PetscReal* result,MPI_Comm comm)
835: {
836:   return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MIN,comm);
837: }

841: /*@C
842:       PetscGlobalSum - Computes the sum over sever processors

844:      Collective on MPI_Comm

846:    Input Parameters:
847: +   local - the local value
848: -   comm - the processors that find the sum

850:    Output Parameter:
851: .   result - the sum
852:   
853:    Level: intermediate

855:    Notes:
856:      These functions are to be used inside user functions that are to be processed with 
857:    ADIC. PETSc will automatically provide differentiated versions of these functions

859: .seealso: PetscGlobalMin(), PetscGlobalMax()
860: @*/
861: PetscErrorCode  PetscGlobalSum(PetscScalar* local,PetscScalar* result,MPI_Comm comm)
862: {
863:   return MPI_Allreduce(local,result,1,MPIU_SCALAR,PetscSum_Op,comm);
864: }