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 **);
23: EXTERN PetscErrorCode PetscOptionsHelpDestroyList(void);
25: /* this is used by the _, __, and ___ macros (see include/petscerror.h) */
26: PetscErrorCode __g0;
28: /* user may set this BEFORE calling PetscInitialize() */
29: MPI_Comm PETSC_COMM_WORLD = 0;
31: /*
32: Declare and set all the string names of the PETSc enums
33: */
34: const char *PetscTruths[] = {"FALSE","TRUE","PetscTruth","PETSC_",0};
35: const char *PetscDataTypes[] = {"INT", "DOUBLE", "COMPLEX",
36: "LONG","SHORT", "FLOAT",
37: "CHAR","LOGICAL","ENUM","TRUTH","LONGDOUBLE","PetscDataType","PETSC_",0};
39: PetscCookie PETSC_LARGEST_COOKIE = PETSC_SMALLEST_COOKIE;
40: PetscCookie PETSC_OBJECT_COOKIE = 0;
42: PetscTruth PetscPreLoadingUsed = PETSC_FALSE;
43: PetscTruth PetscPreLoadingOn = PETSC_FALSE;
45: PetscErrorCode PetscCookieRegister(PetscCookie *cookie)
46: {
47: *cookie = ++PETSC_LARGEST_COOKIE;
48: return 0;
49: }
51: /*
52: Checks the options database for initializations related to the
53: PETSc components
54: */
57: PetscErrorCode PetscOptionsCheckInitial_Components(void)
58: {
59: PetscTruth flg1;
63: PetscOptionsHasName(PETSC_NULL,"-help",&flg1);
64: if (flg1) {
65: #if defined (PETSC_USE_LOG)
66: MPI_Comm comm = PETSC_COMM_WORLD;
67: (*PetscHelpPrintf)(comm,"------Additional PETSc component options--------\n");
68: (*PetscHelpPrintf)(comm," -log_summary_exclude: <vec,mat,pc.ksp,snes>\n");
69: (*PetscHelpPrintf)(comm," -info_exclude: <null,vec,mat,pc,ksp,snes,ts>\n");
70: (*PetscHelpPrintf)(comm,"-----------------------------------------------\n");
71: #endif
72: }
73: return(0);
74: }
78: /*@C
79: PetscInitializeNoArguments - Calls PetscInitialize() from C/C++ without
80: the command line arguments.
82: Collective
83:
84: Level: advanced
86: .seealso: PetscInitialize(), PetscInitializeFortran()
87: @*/
88: PetscErrorCode PetscInitializeNoArguments(void)
89: {
91: int argc = 0;
92: char **args = 0;
95: PetscInitialize(&argc,&args,PETSC_NULL,PETSC_NULL);
96: PetscFunctionReturn(ierr);
97: }
101: /*@
102: PetscInitialized - Determine whether PETSc is initialized.
103:
104: Level: beginner
106: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
107: @*/
108: PetscErrorCode PetscInitialized(PetscTruth *isInitialized)
109: {
112: *isInitialized = PetscInitializeCalled;
113: return(0);
114: }
118: /*@
119: PetscFinalized - Determine whether PetscFinalize() has been called yet
120:
121: Level: developer
123: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
124: @*/
125: PetscErrorCode PetscFinalized(PetscTruth *isFinalized)
126: {
129: *isFinalized = PetscFinalizeCalled;
130: return(0);
131: }
133: EXTERN PetscErrorCode PetscOptionsCheckInitial_Private(void);
136: /*
137: This function is the MPI reduction operation used to compute the sum of the
138: first half of the datatype and the max of the second half.
139: */
140: MPI_Op PetscMaxSum_Op = 0;
145: void PetscMaxSum_Local(void *in,void *out,int *cnt,MPI_Datatype *datatype)
146: {
147: PetscInt *xin = (PetscInt*)in,*xout = (PetscInt*)out,i,count = *cnt;
150: if (*datatype != MPIU_2INT) {
151: (*PetscErrorPrintf)("Can only handle MPIU_2INT data types");
152: MPI_Abort(MPI_COMM_WORLD,1);
153: }
155: for (i=0; i<count; i++) {
156: xout[2*i] = PetscMax(xout[2*i],xin[2*i]);
157: xout[2*i+1] += xin[2*i+1];
158: }
159: PetscStackPop;
160: return;
161: }
164: /*
165: Returns the max of the first entry owned by this processor and the
166: sum of the second entry.
167: */
170: PetscErrorCode PetscMaxSum(MPI_Comm comm,const PetscInt nprocs[],PetscInt *max,PetscInt *sum)
171: {
172: PetscMPIInt size,rank;
173: PetscInt *work;
177: MPI_Comm_size(comm,&size);
178: MPI_Comm_rank(comm,&rank);
179: PetscMalloc(2*size*sizeof(PetscInt),&work);
180: MPI_Allreduce((void*)nprocs,work,size,MPIU_2INT,PetscMaxSum_Op,comm);
181: *max = work[2*rank];
182: *sum = work[2*rank+1];
183: PetscFree(work);
184: return(0);
185: }
187: /* ----------------------------------------------------------------------------*/
188: MPI_Op PetscADMax_Op = 0;
193: void PetscADMax_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
194: {
195: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
196: PetscInt i,count = *cnt;
199: if (*datatype != MPIU_2SCALAR) {
200: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
201: MPI_Abort(MPI_COMM_WORLD,1);
202: }
204: for (i=0; i<count; i++) {
205: if (PetscRealPart(xout[2*i]) < PetscRealPart(xin[2*i])) {
206: xout[2*i] = xin[2*i];
207: xout[2*i+1] = xin[2*i+1];
208: }
209: }
211: PetscStackPop;
212: return;
213: }
216: MPI_Op PetscADMin_Op = 0;
221: void PetscADMin_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
222: {
223: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
224: PetscInt i,count = *cnt;
227: if (*datatype != MPIU_2SCALAR) {
228: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
229: MPI_Abort(MPI_COMM_WORLD,1);
230: }
232: for (i=0; i<count; i++) {
233: if (PetscRealPart(xout[2*i]) > PetscRealPart(xin[2*i])) {
234: xout[2*i] = xin[2*i];
235: xout[2*i+1] = xin[2*i+1];
236: }
237: }
239: PetscStackPop;
240: return;
241: }
243: /* ---------------------------------------------------------------------------------------*/
245: #if defined(PETSC_USE_COMPLEX)
246: MPI_Op PetscSum_Op = 0;
251: void PetscSum_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
252: {
253: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
254: PetscInt i,count = *cnt;
257: if (*datatype != MPIU_SCALAR) {
258: (*PetscErrorPrintf)("Can only handle MPIU_SCALAR data (i.e. double or complex) types");
259: MPI_Abort(MPI_COMM_WORLD,1);
260: }
262: for (i=0; i<count; i++) {
263: xout[i] += xin[i];
264: }
266: PetscStackPop;
267: return;
268: }
270: #endif
272: static int PetscGlobalArgc = 0;
273: static char **PetscGlobalArgs = 0;
277: /*@C
278: PetscGetArgs - Allows you to access the raw command line arguments anywhere
279: after PetscInitialize() is called but before PetscFinalize().
281: Not Collective
283: Output Parameters:
284: + argc - count of number of command line arguments
285: - args - the command line arguments
287: Level: intermediate
289: Notes:
290: This is usually used to pass the command line arguments into other libraries
291: that are called internally deep in PETSc or the application.
293: Concepts: command line arguments
294:
295: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArguments()
297: @*/
298: PetscErrorCode PetscGetArgs(int *argc,char ***args)
299: {
301: if (!PetscGlobalArgs) {
302: SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
303: }
304: *argc = PetscGlobalArgc;
305: *args = PetscGlobalArgs;
306: return(0);
307: }
311: /*@C
312: PetscGetArguments - Allows you to access the command line arguments anywhere
313: after PetscInitialize() is called but before PetscFinalize().
315: Not Collective
317: Output Parameters:
318: . args - the command line arguments
320: Level: intermediate
322: Notes:
323: This does NOT start with the program name and IS null terminated (final arg is void)
325: Concepts: command line arguments
326:
327: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscFreeArguments()
329: @*/
330: PetscErrorCode PetscGetArguments(char ***args)
331: {
332: PetscInt i,argc = PetscGlobalArgc;
336: if (!PetscGlobalArgs) {
337: SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
338: }
339: PetscMalloc(argc*sizeof(char*),args);
340: for (i=0; i<argc-1; i++) {
341: PetscStrallocpy(PetscGlobalArgs[i+1],&(*args)[i]);
342: }
343: (*args)[argc-1] = 0;
344: return(0);
345: }
349: /*@C
350: PetscFreeArguments - Frees the memory obtained with PetscGetArguments()
352: Not Collective
354: Output Parameters:
355: . args - the command line arguments
357: Level: intermediate
359: Concepts: command line arguments
360:
361: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscGetArguments()
363: @*/
364: PetscErrorCode PetscFreeArguments(char **args)
365: {
366: PetscInt i = 0;
370: while (args[i]) {
371: PetscFree(args[i]);
372: i++;
373: }
374: PetscFree(args);
375: return(0);
376: }
380: /*@C
381: PetscInitialize - Initializes the PETSc database and MPI.
382: PetscInitialize() calls MPI_Init() if that has yet to be called,
383: so this routine should always be called near the beginning of
384: your program -- usually the very first line!
386: Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set
388: Input Parameters:
389: + argc - count of number of command line arguments
390: . args - the command line arguments
391: . file - [optional] PETSc database file, also checks ~username/.petscrc and .petscrc use PETSC_NULL to not check for
392: code specific file. Use -skip_petscrc in the code specific file to skip the .petscrc files
393: - help - [optional] Help message to print, use PETSC_NULL for no message
395: If you wish PETSc to run on a subcommunicator of MPI_COMM_WORLD, create that
396: communicator first and assign it to PETSC_COMM_WORLD BEFORE calling PetscInitialize()
398: Options Database Keys:
399: + -start_in_debugger [noxterm,dbx,xdb,gdb,...] - Starts program in debugger
400: . -on_error_attach_debugger [noxterm,dbx,xdb,gdb,...] - Starts debugger when error detected
401: . -on_error_emacs <machinename> causes emacsclient to jump to error file
402: . -on_error_abort calls abort() when error detected (no traceback)
403: . -on_error_mpiabort calls MPI_abort() when error detected
404: . -error_output_stderr prints error messages to stderr instead of the default stdout
405: . -error_output_none does not print the error messages (but handles errors in the same way as if this was not called)
406: . -debugger_nodes [node1,node2,...] - Indicates nodes to start in debugger
407: . -debugger_pause [sleeptime] (in seconds) - Pauses debugger
408: . -stop_for_debugger - Print message on how to attach debugger manually to
409: process and wait (-debugger_pause) seconds for attachment
410: . -malloc - Indicates use of PETSc error-checking malloc (on by default for debug version of libraries)
411: . -malloc no - Indicates not to use error-checking malloc
412: . -malloc_debug - check for memory corruption at EVERY malloc or free
413: . -fp_trap - Stops on floating point exceptions (Note that on the
414: IBM RS6000 this slows code by at least a factor of 10.)
415: . -no_signal_handler - Indicates not to trap error signals
416: . -shared_tmp - indicates /tmp directory is shared by all processors
417: . -not_shared_tmp - each processor has own /tmp
418: . -tmp - alternative name of /tmp directory
419: . -get_total_flops - returns total flops done by all processors
420: - -memory_info - Print memory usage at end of run
422: Options Database Keys for Profiling:
423: See the Profiling chapter of the users manual for details.
424: + -log_trace [filename] - Print traces of all PETSc calls
425: to the screen (useful to determine where a program
426: hangs without running in the debugger). See PetscLogTraceBegin().
427: . -info <optional filename> - Prints verbose information to the screen
428: - -info_exclude <null,vec,mat,pc,ksp,snes,ts> - Excludes some of the verbose messages
430: Environmental Variables:
431: + PETSC_TMP - alternative tmp directory
432: . PETSC_SHARED_TMP - tmp is shared by all processes
433: . PETSC_NOT_SHARED_TMP - each process has its own private tmp
434: . PETSC_VIEWER_SOCKET_PORT - socket number to use for socket viewer
435: - PETSC_VIEWER_SOCKET_MACHINE - machine to use for socket viewer to connect to
438: Level: beginner
440: Notes:
441: If for some reason you must call MPI_Init() separately, call
442: it before PetscInitialize().
444: Fortran Version:
445: In Fortran this routine has the format
446: $ call PetscInitialize(file,ierr)
448: + ierr - error return code
449: - file - [optional] PETSc database file, also checks ~username/.petscrc and .petscrc use PETSC_CHARACTER_NULL to not check for
450: code specific file. Use -skip_petscrc in the code specific file to skip the .petscrc files
451:
452: Important Fortran Note:
453: In Fortran, you MUST use PETSC_NULL_CHARACTER to indicate a
454: null character string; you CANNOT just use PETSC_NULL as
455: in the C version. See the users manual for details.
458: Concepts: initializing PETSc
459:
460: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs()
462: @*/
463: PetscErrorCode PetscInitialize(int *argc,char ***args,const char file[],const char help[])
464: {
466: PetscMPIInt flag, size,nodesize;
467: PetscTruth flg;
468: char hostname[256];
471: if (PetscInitializeCalled) return(0);
473: /* these must be initialized in a routine, not as a constant declaration*/
474: PETSC_STDOUT = stdout;
475: PETSC_STDERR = stderr;
477: PetscOptionsCreate();
479: /*
480: We initialize the program name here (before MPI_Init()) because MPICH has a bug in
481: it that it sets args[0] on all processors to be args[0] on the first processor.
482: */
483: if (argc && *argc) {
484: PetscSetProgramName(**args);
485: } else {
486: PetscSetProgramName("Unknown Name");
487: }
490: MPI_Initialized(&flag);
491: if (!flag) {
492: if (PETSC_COMM_WORLD) SETERRQ(PETSC_ERR_SUP,"You cannot set PETSC_COMM_WORLD if you have not initialized MPI first");
493: MPI_Init(argc,args);
494: PetscBeganMPI = PETSC_TRUE;
495: }
496: if (argc && args) {
497: PetscGlobalArgc = *argc;
498: PetscGlobalArgs = *args;
499: }
500: PetscInitializeCalled = PETSC_TRUE;
501: PetscFinalizeCalled = PETSC_FALSE;
503: if (!PETSC_COMM_WORLD) {
504: PETSC_COMM_WORLD = MPI_COMM_WORLD;
505: }
507: /* Done after init due to a bug in MPICH-GM? */
508: PetscErrorPrintfInitialize();
510: MPI_Comm_rank(MPI_COMM_WORLD,&PetscGlobalRank);
511: MPI_Comm_size(MPI_COMM_WORLD,&PetscGlobalSize);
513: #if defined(PETSC_USE_COMPLEX)
514: /*
515: Initialized the global complex variable; this is because with
516: shared libraries the constructors for global variables
517: are not called; at least on IRIX.
518: */
519: {
520: #if defined(PETSC_CLANGUAGE_CXX)
521: PetscScalar ic(0.0,1.0);
522: PETSC_i = ic;
523: #else
524: PetscScalar ic;
525: ic = 1.I;
526: PETSC_i = ic;
527: #endif
528: }
530: MPI_Type_contiguous(2,MPIU_REAL,&MPIU_COMPLEX);
531: MPI_Type_commit(&MPIU_COMPLEX);
532: MPI_Op_create(PetscSum_Local,1,&PetscSum_Op);
533: #endif
535: /*
536: Create the PETSc MPI reduction operator that sums of the first
537: half of the entries and maxes the second half.
538: */
539: MPI_Op_create(PetscMaxSum_Local,1,&PetscMaxSum_Op);
541: MPI_Type_contiguous(2,MPIU_SCALAR,&MPIU_2SCALAR);
542: MPI_Type_commit(&MPIU_2SCALAR);
543: MPI_Op_create(PetscADMax_Local,1,&PetscADMax_Op);
544: MPI_Op_create(PetscADMin_Local,1,&PetscADMin_Op);
546: MPI_Type_contiguous(2,MPIU_INT,&MPIU_2INT);
547: MPI_Type_commit(&MPIU_2INT);
549: /*
550: Build the options database
551: */
552: PetscOptionsInsert(argc,args,file);
554: /*
555: Print main application help message
556: */
557: PetscOptionsHasName(PETSC_NULL,"-help",&flg);
558: if (help && flg) {
559: PetscPrintf(PETSC_COMM_WORLD,help);
560: }
561: PetscOptionsCheckInitial_Private();
563: /* SHOULD PUT IN GUARDS: Make sure logging is initialized, even if we do not print it out */
564: #if defined(PETSC_USE_LOG)
565: PetscLogBegin_Private();
566: #endif
568: /*
569: Load the dynamic libraries (on machines that support them), this registers all
570: the solvers etc. (On non-dynamic machines this initializes the PetscDraw and PetscViewer classes)
571: */
572: PetscInitialize_DynamicLibraries();
574: MPI_Comm_size(PETSC_COMM_WORLD,&size);
575: PetscInfo1(0,"PETSc successfully started: number of processors = %d\n",size);
576: PetscGetHostName(hostname,256);
577: PetscInfo1(0,"Running on machine: %s\n",hostname);
579: PetscOptionsCheckInitial_Components();
580: /* Check the options database for options related to the options database itself */
581: PetscOptionsSetFromOptions();
583: PetscOptionsGetInt(PETSC_NULL,"-openmp_spawn_size",&nodesize,&flg);
584: if (flg) {
585: #if defined(PETSC_HAVE_MPI_COMM_SPAWN)
586: PetscOpenMPSpawn(nodesize);
587: #else
588: SETERRQ(PETSC_ERR_SUP,"PETSc built without MPI 2 (MPI_Comm_spawn) support, use -openmp_merge_size instead");
589: #endif
590: } else {
591: PetscOptionsGetInt(PETSC_NULL,"-openmp_merge_size",&nodesize,&flg);
592: if (flg) {
593: PetscOpenMPMerge(nodesize);
594: }
595: }
597: PetscFunctionReturn(ierr);
598: }
603: /*@C
604: PetscFinalize - Checks for options to be called at the conclusion
605: of the program. MPI_Finalize() is called only if the user had not
606: called MPI_Init() before calling PetscInitialize().
608: Collective on PETSC_COMM_WORLD
610: Options Database Keys:
611: + -options_table - Calls PetscOptionsPrint()
612: . -options_left - Prints unused options that remain in the database
613: . -options_left no - Does not print unused options that remain in the database
614: . -mpidump - Calls PetscMPIDump()
615: . -malloc_dump - Calls PetscMallocDump()
616: . -malloc_info - Prints total memory usage
617: - -malloc_log - Prints summary of memory usage
619: Options Database Keys for Profiling:
620: See the Profiling chapter of the users manual for details.
621: + -log_summary [filename] - Prints summary of flop and timing
622: information to screen. If the filename is specified the
623: summary is written to the file. (for code compiled with
624: PETSC_USE_LOG). See PetscLogPrintSummary().
625: . -log_all [filename] - Logs extensive profiling information
626: (for code compiled with PETSC_USE_LOG). See PetscLogDump().
627: . -log [filename] - Logs basic profiline information (for
628: code compiled with PETSC_USE_LOG). See PetscLogDump().
629: . -log_sync - Log the synchronization in scatters, inner products
630: and norms
631: - -log_mpe [filename] - Creates a logfile viewable by the
632: utility Upshot/Nupshot (in MPICH distribution)
634: Level: beginner
636: Note:
637: See PetscInitialize() for more general runtime options.
639: .seealso: PetscInitialize(), PetscOptionsPrint(), PetscMallocDump(), PetscMPIDump(), PetscEnd()
640: @*/
641: PetscErrorCode PetscFinalize(void)
642: {
644: PetscMPIInt rank;
645: int nopt;
646: PetscTruth flg1,flg2,flg3;
647:
650: if (!PetscInitializeCalled) {
651: (*PetscErrorPrintf)("PetscInitialize() must be called before PetscFinalize()\n");
652: return(0);
653: }
654: PetscOpenMPFinalize();
656: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
657: PetscOptionsHasName(PETSC_NULL,"-malloc_info",&flg2);
658: if (!flg2) {
659: PetscOptionsHasName(PETSC_NULL,"-memory_info",&flg2);
660: }
661: if (flg2) {
662: PetscMemoryShowUsage(PETSC_VIEWER_STDOUT_WORLD,"Summary of Memory Usage in PETSc\n");
663: }
665: /* Destroy auxiliary packages */
666: #if defined(PETSC_HAVE_MATHEMATICA)
667: PetscViewerMathematicaFinalizePackage();
668: #endif
669: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
670: #if defined(PETSC_HAVE_SIEVE)
671: {
672: PetscErrorCode (*func)(void);
673: char lib[PETSC_MAX_PATH_LEN];
675: PetscStrcpy(lib,"${PETSC_LIB_DIR}");
676: PetscStrcat(lib,"/libpetscdm");
677: PetscDLLibrarySym(PETSC_COMM_WORLD,&DLLibrariesLoaded,lib,"DMFinalizePackage",(void **) &func);
678: if (func) {
679: (*func)();
680: }
681: }
682: #endif
683: #endif
685: /*
686: Destroy all the function registration lists created
687: */
688: PetscFinalize_DynamicLibraries();
690: #if defined(PETSC_USE_LOG)
691: PetscOptionsHasName(PETSC_NULL,"-get_total_flops",&flg1);
692: if (flg1) {
693: PetscLogDouble flops = 0;
694: MPI_Reduce(&_TotalFlops,&flops,1,MPI_DOUBLE,MPI_SUM,0,PETSC_COMM_WORLD);
695: PetscPrintf(PETSC_COMM_WORLD,"Total flops over all processors %g\n",flops);
696: }
697: #endif
699: /*
700: Free all objects registered with PetscObjectRegisterDestroy() such ast
701: PETSC_VIEWER_XXX_().
702: */
703: PetscObjectRegisterDestroyAll();
704: PetscOptionsHelpDestroyList();
706: #if defined(PETSC_USE_DEBUG)
707: if (PetscStackActive) {
708: PetscStackDestroy();
709: }
710: #endif
712: #if defined(PETSC_USE_LOG)
713: {
714: char mname[PETSC_MAX_PATH_LEN];
715: #if defined(PETSC_HAVE_MPE)
716: mname[0] = 0;
717: PetscOptionsGetString(PETSC_NULL,"-log_mpe",mname,PETSC_MAX_PATH_LEN,&flg1);
718: if (flg1){
719: if (mname[0]) {PetscLogMPEDump(mname);}
720: else {PetscLogMPEDump(0);}
721: }
722: #endif
723: mname[0] = 0;
724: PetscOptionsGetString(PETSC_NULL,"-log_summary",mname,PETSC_MAX_PATH_LEN,&flg1);
725: if (flg1) {
726: if (mname[0]) {PetscLogPrintSummary(PETSC_COMM_WORLD,mname);}
727: else {PetscLogPrintSummary(PETSC_COMM_WORLD,0);}
728: }
730: PetscOptionsGetString(PETSC_NULL,"-log_detailed",mname,PETSC_MAX_PATH_LEN,&flg1);
731: if (flg1) {
732: if (mname[0]) {PetscLogPrintDetailed(PETSC_COMM_WORLD,mname);}
733: else {PetscLogPrintDetailed(PETSC_COMM_WORLD,0);}
734: }
736: mname[0] = 0;
737: PetscOptionsGetString(PETSC_NULL,"-log_all",mname,PETSC_MAX_PATH_LEN,&flg1);
738: PetscOptionsGetString(PETSC_NULL,"-log",mname,PETSC_MAX_PATH_LEN,&flg2);
739: if (flg1 || flg2){
740: if (mname[0]) PetscLogDump(mname);
741: else PetscLogDump(0);
742: }
743: PetscLogDestroy();
744: }
745: #endif
746: PetscOptionsHasName(PETSC_NULL,"-no_signal_handler",&flg1);
747: if (!flg1) { PetscPopSignalHandler();}
748: PetscOptionsHasName(PETSC_NULL,"-mpidump",&flg1);
749: if (flg1) {
750: PetscMPIDump(stdout);
751: }
752: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
753: PetscOptionsHasName(PETSC_NULL,"-options_table",&flg2);
754: if (flg2) {
755: if (!rank) {PetscOptionsPrint(stdout);}
756: }
758: /* to prevent PETSc -options_left from warning */
759: PetscOptionsHasName(PETSC_NULL,"-nox",&flg1);CHKERRQ(ierr)
760: PetscOptionsHasName(PETSC_NULL,"-nox_warning",&flg1);CHKERRQ(ierr)
762: flg3 = PETSC_FALSE; /* default value is required */
763: PetscOptionsGetTruth(PETSC_NULL,"-options_left",&flg3,&flg1);
764: PetscOptionsAllUsed(&nopt);
765: if (flg3) {
766: if (!flg2) { /* have not yet printed the options */
767: PetscOptionsPrint(stdout);
768: }
769: if (!nopt) {
770: PetscPrintf(PETSC_COMM_WORLD,"There are no unused options.\n");
771: } else if (nopt == 1) {
772: PetscPrintf(PETSC_COMM_WORLD,"There is one unused database option. It is:\n");
773: } else {
774: PetscPrintf(PETSC_COMM_WORLD,"There are %d unused database options. They are:\n",nopt);
775: }
776: }
777: #if defined(PETSC_USE_DEBUG)
778: if (nopt && !flg3 && !flg1) {
779: PetscPrintf(PETSC_COMM_WORLD,"WARNING! There are options you set that were not used!\n");
780: PetscPrintf(PETSC_COMM_WORLD,"WARNING! could be spelling mistake, etc!\n");
781: PetscOptionsLeft();
782: } else if (nopt && flg3) {
783: #else
784: if (nopt && flg3) {
785: #endif
786: PetscOptionsLeft();
787: }
789: PetscOptionsHasName(PETSC_NULL,"-log_history",&flg1);
790: if (flg1) {
791: PetscLogCloseHistoryFile(&petsc_history);
792: petsc_history = 0;
793: }
795: PetscInfoAllow(PETSC_FALSE,PETSC_NULL);
797: /*
798: Free all the registered create functions, such as KSPList, VecList, SNESList, etc
799: */
800: PetscFListDestroyAll();
802: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
803: PetscOptionsHasName(PETSC_NULL,"-malloc_log",&flg3);
804: if (flg1) {
805: char fname[PETSC_MAX_PATH_LEN];
806: FILE *fd;
807:
808: fname[0] = 0;
809: PetscOptionsGetString(PETSC_NULL,"-malloc_dump",fname,250,&flg1);
810: if (flg1 && fname[0]) {
811: char sname[PETSC_MAX_PATH_LEN];
813: sprintf(sname,"%s_%d",fname,rank);
814: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
815: PetscMallocDump(fd);
816: fclose(fd);
817: } else {
818: MPI_Comm local_comm;
820: MPI_Comm_dup(MPI_COMM_WORLD,&local_comm);
821: PetscSequentialPhaseBegin_Private(local_comm,1);
822: PetscMallocDump(stdout);
823: PetscSequentialPhaseEnd_Private(local_comm,1);
824: MPI_Comm_free(&local_comm);
825: }
826: }
827: if (flg3) {
828: char fname[PETSC_MAX_PATH_LEN];
829: FILE *fd;
830:
831: fname[0] = 0;
832: PetscOptionsGetString(PETSC_NULL,"-malloc_log",fname,250,&flg1);
833: if (flg1 && fname[0]) {
834: char sname[PETSC_MAX_PATH_LEN];
836: sprintf(sname,"%s_%d",fname,rank);
837: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
838: PetscMallocDumpLog(fd);
839: fclose(fd);
840: } else {
841: PetscMallocDumpLog(stdout);
842: }
843: }
844: /* Can be destroyed only after all the options are used */
845: PetscOptionsDestroy();
847: PetscGlobalArgc = 0;
848: PetscGlobalArgs = 0;
850: #if defined(PETSC_USE_COMPLEX)
851: MPI_Op_free(&PetscSum_Op);
852: MPI_Type_free(&MPIU_COMPLEX);
853: #endif
854: MPI_Type_free(&MPIU_2SCALAR);
855: MPI_Type_free(&MPIU_2INT);
856: MPI_Op_free(&PetscMaxSum_Op);
857: MPI_Op_free(&PetscADMax_Op);
858: MPI_Op_free(&PetscADMin_Op);
860: PetscInfo(0,"PETSc successfully ended!\n");
861: if (PetscBeganMPI) {
862: MPI_Finalize();
863: }
865: /*
867: Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because
868: the communicator has some outstanding requests on it. Specifically if the
869: flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See
870: src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate()
871: is never freed as it should be. Thus one may obtain messages of the form
872: [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/mpiu.c indicating the
873: memory was not freed.
875: */
876: PetscClearMalloc();
877: PetscInitializeCalled = PETSC_FALSE;
878: PetscFinalizeCalled = PETSC_TRUE;
879: PetscFunctionReturn(ierr);
880: }
882: /*
883: These may be used in code that ADIC is to be used on
884: */
888: /*@C
889: PetscGlobalMax - Computes the maximum value over several processors
891: Collective on MPI_Comm
893: Input Parameters:
894: + local - the local value
895: - comm - the processors that find the maximum
897: Output Parameter:
898: . result - the maximum value
899:
900: Level: intermediate
902: Notes:
903: These functions are to be used inside user functions that are to be processed with
904: ADIC. PETSc will automatically provide differentiated versions of these functions
906: .seealso: PetscGlobalMin(), PetscGlobalSum()
907: @*/
908: PetscErrorCode PetscGlobalMax(PetscReal* local,PetscReal* result,MPI_Comm comm)
909: {
910: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MAX,comm);
911: }
915: /*@C
916: PetscGlobalMin - Computes the minimum value over several processors
918: Collective on MPI_Comm
920: Input Parameters:
921: + local - the local value
922: - comm - the processors that find the minimum
924: Output Parameter:
925: . result - the minimum value
926:
927: Level: intermediate
929: Notes:
930: These functions are to be used inside user functions that are to be processed with
931: ADIC. PETSc will automatically provide differentiated versions of these functions
933: .seealso: PetscGlobalMax(), PetscGlobalSum()
934: @*/
935: PetscErrorCode PetscGlobalMin(PetscReal* local,PetscReal* result,MPI_Comm comm)
936: {
937: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MIN,comm);
938: }
942: /*@C
943: PetscGlobalSum - Computes the sum over sever processors
945: Collective on MPI_Comm
947: Input Parameters:
948: + local - the local value
949: - comm - the processors that find the sum
951: Output Parameter:
952: . result - the sum
953:
954: Level: intermediate
956: Notes:
957: These functions are to be used inside user functions that are to be processed with
958: ADIC. PETSc will automatically provide differentiated versions of these functions
960: .seealso: PetscGlobalMin(), PetscGlobalMax()
961: @*/
962: PetscErrorCode PetscGlobalSum(PetscScalar* local,PetscScalar* result,MPI_Comm comm)
963: {
964: return MPI_Allreduce(local,result,1,MPIU_SCALAR,PetscSum_Op,comm);
965: }