Actual source code: pinit.c
1: #define PETSC_DLL
2: /*
3: This file defines the initialization of PETSc, including PetscInitialize()
4: */
6: #include petscsys.h
8: #if defined(PETSC_USE_LOG)
9: EXTERN PetscErrorCode PetscLogBegin_Private(void);
10: #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 = MPI_COMM_NULL;
30: PetscMPIInt Petsc_Counter_keyval = MPI_KEYVAL_INVALID;
31: PetscMPIInt Petsc_InnerComm_keyval = MPI_KEYVAL_INVALID;
32: PetscMPIInt Petsc_OuterComm_keyval = MPI_KEYVAL_INVALID;
34: /*
35: Declare and set all the string names of the PETSc enums
36: */
37: const char *PetscTruths[] = {"FALSE","TRUE","PetscTruth","PETSC_",0};
38: const char *PetscDataTypes[] = {"INT", "DOUBLE", "COMPLEX",
39: "LONG","SHORT", "FLOAT",
40: "CHAR","LOGICAL","ENUM","TRUTH","LONGDOUBLE","PetscDataType","PETSC_",0};
42: PetscTruth PetscPreLoadingUsed = PETSC_FALSE;
43: PetscTruth PetscPreLoadingOn = PETSC_FALSE;
45: /*
46: Checks the options database for initializations related to the
47: PETSc components
48: */
51: PetscErrorCode PetscOptionsCheckInitial_Components(void)
52: {
53: PetscTruth flg1;
57: PetscOptionsHasName(PETSC_NULL,"-help",&flg1);
58: if (flg1) {
59: #if defined (PETSC_USE_LOG)
60: MPI_Comm comm = PETSC_COMM_WORLD;
61: (*PetscHelpPrintf)(comm,"------Additional PETSc component options--------\n");
62: (*PetscHelpPrintf)(comm," -log_summary_exclude: <vec,mat,pc.ksp,snes>\n");
63: (*PetscHelpPrintf)(comm," -info_exclude: <null,vec,mat,pc,ksp,snes,ts>\n");
64: (*PetscHelpPrintf)(comm,"-----------------------------------------------\n");
65: #endif
66: }
67: return(0);
68: }
72: /*@C
73: PetscInitializeNoArguments - Calls PetscInitialize() from C/C++ without
74: the command line arguments.
76: Collective
77:
78: Level: advanced
80: .seealso: PetscInitialize(), PetscInitializeFortran()
81: @*/
82: PetscErrorCode PetscInitializeNoArguments(void)
83: {
85: int argc = 0;
86: char **args = 0;
89: PetscInitialize(&argc,&args,PETSC_NULL,PETSC_NULL);
90: PetscFunctionReturn(ierr);
91: }
95: /*@
96: PetscInitialized - Determine whether PETSc is initialized.
97:
98: 7 Level: beginner
100: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
101: @*/
102: PetscErrorCode PetscInitialized(PetscTruth *isInitialized)
103: {
106: *isInitialized = PetscInitializeCalled;
107: return(0);
108: }
112: /*@
113: PetscFinalized - Determine whether PetscFinalize() has been called yet
114:
115: Level: developer
117: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
118: @*/
119: PetscErrorCode PetscFinalized(PetscTruth *isFinalized)
120: {
123: *isFinalized = PetscFinalizeCalled;
124: return(0);
125: }
127: EXTERN PetscErrorCode PetscOptionsCheckInitial_Private(void);
130: /*
131: This function is the MPI reduction operation used to compute the sum of the
132: first half of the datatype and the max of the second half.
133: */
134: MPI_Op PetscMaxSum_Op = 0;
139: void MPIAPI PetscMaxSum_Local(void *in,void *out,int *cnt,MPI_Datatype *datatype)
140: {
141: PetscInt *xin = (PetscInt*)in,*xout = (PetscInt*)out,i,count = *cnt;
144: if (*datatype != MPIU_2INT) {
145: (*PetscErrorPrintf)("Can only handle MPIU_2INT data types");
146: MPI_Abort(MPI_COMM_WORLD,1);
147: }
149: for (i=0; i<count; i++) {
150: xout[2*i] = PetscMax(xout[2*i],xin[2*i]);
151: xout[2*i+1] += xin[2*i+1];
152: }
153: PetscStackPop;
154: return;
155: }
158: /*
159: Returns the max of the first entry owned by this processor and the
160: sum of the second entry.
162: The reason nprocs[2*i] contains lengths nprocs[2*i+1] contains flag of 1 if length is nonzero
163: is so that the PetscMaxSum_Op() can set TWO values, if we passed in only nprocs[i] with lengths
164: there would be no place to store the both needed results.
165: */
168: PetscErrorCode PetscMaxSum(MPI_Comm comm,const PetscInt nprocs[],PetscInt *max,PetscInt *sum)
169: {
170: PetscMPIInt size,rank;
171: PetscInt *work;
175: MPI_Comm_size(comm,&size);
176: MPI_Comm_rank(comm,&rank);
177: PetscMalloc(2*size*sizeof(PetscInt),&work);
178: MPI_Allreduce((void*)nprocs,work,size,MPIU_2INT,PetscMaxSum_Op,comm);
179: *max = work[2*rank];
180: *sum = work[2*rank+1];
181: PetscFree(work);
182: return(0);
183: }
185: /* ----------------------------------------------------------------------------*/
186: MPI_Op PetscADMax_Op = 0;
191: void MPIAPI PetscADMax_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
192: {
193: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
194: PetscInt i,count = *cnt;
197: if (*datatype != MPIU_2SCALAR) {
198: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
199: MPI_Abort(MPI_COMM_WORLD,1);
200: }
202: for (i=0; i<count; i++) {
203: if (PetscRealPart(xout[2*i]) < PetscRealPart(xin[2*i])) {
204: xout[2*i] = xin[2*i];
205: xout[2*i+1] = xin[2*i+1];
206: }
207: }
209: PetscStackPop;
210: return;
211: }
214: MPI_Op PetscADMin_Op = 0;
219: void MPIAPI PetscADMin_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
220: {
221: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
222: PetscInt i,count = *cnt;
225: if (*datatype != MPIU_2SCALAR) {
226: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
227: MPI_Abort(MPI_COMM_WORLD,1);
228: }
230: for (i=0; i<count; i++) {
231: if (PetscRealPart(xout[2*i]) > PetscRealPart(xin[2*i])) {
232: xout[2*i] = xin[2*i];
233: xout[2*i+1] = xin[2*i+1];
234: }
235: }
237: PetscStackPop;
238: return;
239: }
241: /* ---------------------------------------------------------------------------------------*/
243: #if defined(PETSC_USE_COMPLEX)
245: /*
246: This operation is only needed when using complex numbers with older MPI that does not support complex numbers
247: */
248: #if !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX)
249: MPI_Op MPIU_SUM = 0;
254: void PetscSum_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
255: {
256: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
257: PetscInt i,count = *cnt;
260: if (*datatype != MPIU_SCALAR) {
261: (*PetscErrorPrintf)("Can only handle MPIU_SCALAR data (i.e. double or complex) types");
262: MPI_Abort(MPI_COMM_WORLD,1);
263: }
265: for (i=0; i<count; i++) {
266: xout[i] += xin[i];
267: }
269: PetscStackPop;
270: return;
271: }
273: #endif
274: #endif
279: /*
280: Private routine to delete internal tag/name counter storage when a communicator is freed.
282: This is called by MPI, not by users.
286: */
287: PetscMPIInt MPIAPI Petsc_DelCounter(MPI_Comm comm,PetscMPIInt keyval,void *count_val,void *extra_state)
288: {
292: PetscInfo1(0,"Deleting counter data in an MPI_Comm %ld\n",(long)comm);if (ierr) PetscFunctionReturn((PetscMPIInt)ierr);
293: PetscFree(count_val);if (ierr) PetscFunctionReturn((PetscMPIInt)ierr);
294: PetscFunctionReturn(MPI_SUCCESS);
295: }
301: /*
302: This does not actually free anything, it simply marks when a reference count to an internal MPI_Comm reaches zero and the
303: the external MPI_Comm drops its reference to the internal MPI_Comm
305: This is called by MPI, not by users.
309: */
310: PetscMPIInt MPIAPI Petsc_DelComm(MPI_Comm comm,PetscMPIInt keyval,void *attr_val,void *extra_state)
311: {
315: PetscInfo1(0,"Deleting PETSc communicator imbedded in a user MPI_Comm %ld\n",(long)comm);if (ierr) PetscFunctionReturn((PetscMPIInt)ierr);
316: /* actually don't delete anything because we cannot increase the reference count of the communicator anyways */
317: PetscFunctionReturn(MPI_SUCCESS);
318: }
321: #if defined(PETSC_USE_PETSC_MPI_EXTERNAL32)
322: #if !defined(PETSC_WORDS_BIGENDIAN)
328: #endif
329: #endif
331: int PetscGlobalArgc = 0;
332: char **PetscGlobalArgs = 0;
336: /*@C
337: PetscGetArgs - Allows you to access the raw command line arguments anywhere
338: after PetscInitialize() is called but before PetscFinalize().
340: Not Collective
342: Output Parameters:
343: + argc - count of number of command line arguments
344: - args - the command line arguments
346: Level: intermediate
348: Notes:
349: This is usually used to pass the command line arguments into other libraries
350: that are called internally deep in PETSc or the application.
352: The first argument contains the program name as is normal for C arguments.
354: Concepts: command line arguments
355:
356: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArguments()
358: @*/
359: PetscErrorCode PetscGetArgs(int *argc,char ***args)
360: {
362: if (!PetscInitializeCalled && PetscFinalizeCalled) {
363: SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
364: }
365: *argc = PetscGlobalArgc;
366: *args = PetscGlobalArgs;
367: return(0);
368: }
372: /*@C
373: PetscGetArguments - Allows you to access the command line arguments anywhere
374: after PetscInitialize() is called but before PetscFinalize().
376: Not Collective
378: Output Parameters:
379: . args - the command line arguments
381: Level: intermediate
383: Notes:
384: This does NOT start with the program name and IS null terminated (final arg is void)
386: Concepts: command line arguments
387:
388: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscFreeArguments()
390: @*/
391: PetscErrorCode PetscGetArguments(char ***args)
392: {
393: PetscInt i,argc = PetscGlobalArgc;
397: if (!PetscInitializeCalled && PetscFinalizeCalled) {
398: SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
399: }
400: if (!argc) {*args = 0; return(0);}
401: PetscMalloc(argc*sizeof(char*),args);
402: for (i=0; i<argc-1; i++) {
403: PetscStrallocpy(PetscGlobalArgs[i+1],&(*args)[i]);
404: }
405: (*args)[argc-1] = 0;
406: return(0);
407: }
411: /*@C
412: PetscFreeArguments - Frees the memory obtained with PetscGetArguments()
414: Not Collective
416: Output Parameters:
417: . args - the command line arguments
419: Level: intermediate
421: Concepts: command line arguments
422:
423: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscGetArguments()
425: @*/
426: PetscErrorCode PetscFreeArguments(char **args)
427: {
428: PetscInt i = 0;
432: if (!args) {return(0);}
433: while (args[i]) {
434: PetscFree(args[i]);
435: i++;
436: }
437: PetscFree(args);
438: return(0);
439: }
443: /*@C
444: PetscInitialize - Initializes the PETSc database and MPI.
445: PetscInitialize() calls MPI_Init() if that has yet to be called,
446: so this routine should always be called near the beginning of
447: your program -- usually the very first line!
449: Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set
451: Input Parameters:
452: + argc - count of number of command line arguments
453: . args - the command line arguments
454: . file - [optional] PETSc database file, also checks ~username/.petscrc and .petscrc use PETSC_NULL to not check for
455: code specific file. Use -skip_petscrc in the code specific file to skip the .petscrc files
456: - help - [optional] Help message to print, use PETSC_NULL for no message
458: If you wish PETSc code to run ONLY on a subcommunicator of MPI_COMM_WORLD, create that
459: communicator first and assign it to PETSC_COMM_WORLD BEFORE calling PetscInitialize(). Thus if you are running a
460: four process job and two processes will run PETSc and have PetscInitialize() and PetscFinalize() and two process will not,
461: then do this. If ALL processes in the job are using PetscInitialize() and PetscFinalize() then you don't need to do this, even
462: if different subcommunicators of the job are doing different things with PETSc.
464: Options Database Keys:
465: + -start_in_debugger [noxterm,dbx,xdb,gdb,...] - Starts program in debugger
466: . -on_error_attach_debugger [noxterm,dbx,xdb,gdb,...] - Starts debugger when error detected
467: . -on_error_emacs <machinename> causes emacsclient to jump to error file
468: . -on_error_abort calls abort() when error detected (no traceback)
469: . -on_error_mpiabort calls MPI_abort() when error detected
470: . -error_output_stderr prints error messages to stderr instead of the default stdout
471: . -error_output_none does not print the error messages (but handles errors in the same way as if this was not called)
472: . -debugger_nodes [node1,node2,...] - Indicates nodes to start in debugger
473: . -debugger_pause [sleeptime] (in seconds) - Pauses debugger
474: . -stop_for_debugger - Print message on how to attach debugger manually to
475: process and wait (-debugger_pause) seconds for attachment
476: . -malloc - Indicates use of PETSc error-checking malloc (on by default for debug version of libraries)
477: . -malloc no - Indicates not to use error-checking malloc
478: . -malloc_debug - check for memory corruption at EVERY malloc or free
479: . -fp_trap - Stops on floating point exceptions (Note that on the
480: IBM RS6000 this slows code by at least a factor of 10.)
481: . -no_signal_handler - Indicates not to trap error signals
482: . -shared_tmp - indicates /tmp directory is shared by all processors
483: . -not_shared_tmp - each processor has own /tmp
484: . -tmp - alternative name of /tmp directory
485: . -get_total_flops - returns total flops done by all processors
486: - -memory_info - Print memory usage at end of run
488: Options Database Keys for Profiling:
489: See the Profiling chapter of the users manual for details.
490: + -log_trace [filename] - Print traces of all PETSc calls
491: to the screen (useful to determine where a program
492: hangs without running in the debugger). See PetscLogTraceBegin().
493: . -info <optional filename> - Prints verbose information to the screen
494: - -info_exclude <null,vec,mat,pc,ksp,snes,ts> - Excludes some of the verbose messages
496: Environmental Variables:
497: + PETSC_TMP - alternative tmp directory
498: . PETSC_SHARED_TMP - tmp is shared by all processes
499: . PETSC_NOT_SHARED_TMP - each process has its own private tmp
500: . PETSC_VIEWER_SOCKET_PORT - socket number to use for socket viewer
501: - PETSC_VIEWER_SOCKET_MACHINE - machine to use for socket viewer to connect to
504: Level: beginner
506: Notes:
507: If for some reason you must call MPI_Init() separately, call
508: it before PetscInitialize().
510: Fortran Version:
511: In Fortran this routine has the format
512: $ call PetscInitialize(file,ierr)
514: + ierr - error return code
515: - file - [optional] PETSc database file, also checks ~username/.petscrc and .petscrc use PETSC_NULL_CHARACTER to not check for
516: code specific file. Use -skip_petscrc in the code specific file to skip the .petscrc files
517:
518: Important Fortran Note:
519: In Fortran, you MUST use PETSC_NULL_CHARACTER to indicate a
520: null character string; you CANNOT just use PETSC_NULL as
521: in the C version. See the users manual for details.
523: If your main program is C but you call Fortran code that also uses PETSc you need to call PetscInitializeFortran() soon after
524: calling PetscInitialize().
526: Concepts: initializing PETSc
527:
528: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscInitializeNoArguments()
530: @*/
531: PetscErrorCode PetscInitialize(int *argc,char ***args,const char file[],const char help[])
532: {
534: PetscMPIInt flag, size;
535: PetscInt nodesize;
536: PetscTruth flg;
537: char hostname[256];
540: if (PetscInitializeCalled) return(0);
542: /* these must be initialized in a routine, not as a constant declaration*/
543: PETSC_STDOUT = stdout;
544: PETSC_STDERR = stderr;
546: PetscOptionsCreate();
548: /*
549: We initialize the program name here (before MPI_Init()) because MPICH has a bug in
550: it that it sets args[0] on all processors to be args[0] on the first processor.
551: */
552: if (argc && *argc) {
553: PetscSetProgramName(**args);
554: } else {
555: PetscSetProgramName("Unknown Name");
556: }
558: MPI_Initialized(&flag);
559: if (!flag) {
560: if (PETSC_COMM_WORLD != MPI_COMM_NULL) SETERRQ(PETSC_ERR_SUP,"You cannot set PETSC_COMM_WORLD if you have not initialized MPI first");
561: MPI_Init(argc,args);
562: PetscBeganMPI = PETSC_TRUE;
563: }
564: if (argc && args) {
565: PetscGlobalArgc = *argc;
566: PetscGlobalArgs = *args;
567: }
568: PetscInitializeCalled = PETSC_TRUE;
569: PetscFinalizeCalled = PETSC_FALSE;
571: if (PETSC_COMM_WORLD == MPI_COMM_NULL) {
572: PETSC_COMM_WORLD = MPI_COMM_WORLD;
573: }
575: /* Done after init due to a bug in MPICH-GM? */
576: PetscErrorPrintfInitialize();
578: MPI_Comm_rank(MPI_COMM_WORLD,&PetscGlobalRank);
579: MPI_Comm_size(MPI_COMM_WORLD,&PetscGlobalSize);
581: #if defined(PETSC_USE_COMPLEX)
582: /*
583: Initialized the global complex variable; this is because with
584: shared libraries the constructors for global variables
585: are not called; at least on IRIX.
586: */
587: {
588: #if defined(PETSC_CLANGUAGE_CXX)
589: PetscScalar ic(0.0,1.0);
590: PETSC_i = ic;
591: #else
592: PETSC_i = I;
593: #endif
594: }
596: #if !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX)
597: MPI_Type_contiguous(2,MPIU_REAL,&MPI_C_DOUBLE_COMPLEX);
598: MPI_Type_commit(&MPI_C_DOUBLE_COMPLEX);
599: MPI_Type_contiguous(2,MPI_FLOAT,&MPI_C_COMPLEX);
600: MPI_Type_commit(&MPI_C_COMPLEX);
601: MPI_Op_create(PetscSum_Local,1,&MPIU_SUM);
602: #endif
603: #endif
605: /*
606: Create the PETSc MPI reduction operator that sums of the first
607: half of the entries and maxes the second half.
608: */
609: MPI_Op_create(PetscMaxSum_Local,1,&PetscMaxSum_Op);
611: MPI_Type_contiguous(2,MPIU_SCALAR,&MPIU_2SCALAR);
612: MPI_Type_commit(&MPIU_2SCALAR);
613: MPI_Op_create(PetscADMax_Local,1,&PetscADMax_Op);
614: MPI_Op_create(PetscADMin_Local,1,&PetscADMin_Op);
616: MPI_Type_contiguous(2,MPIU_INT,&MPIU_2INT);
617: MPI_Type_commit(&MPIU_2INT);
619: /*
620: Attributes to be set on PETSc communicators
621: */
622: MPI_Keyval_create(MPI_NULL_COPY_FN,Petsc_DelCounter,&Petsc_Counter_keyval,(void*)0);
623: MPI_Keyval_create(MPI_NULL_COPY_FN,Petsc_DelComm,&Petsc_InnerComm_keyval,(void*)0);
624: MPI_Keyval_create(MPI_NULL_COPY_FN,Petsc_DelComm,&Petsc_OuterComm_keyval,(void*)0);
626: /*
627: Build the options database
628: */
629: PetscOptionsInsert(argc,args,file);
631:
632: /*
633: Print main application help message
634: */
635: PetscOptionsHasName(PETSC_NULL,"-help",&flg);
636: if (help && flg) {
637: PetscPrintf(PETSC_COMM_WORLD,help);
638: }
639: PetscOptionsCheckInitial_Private();
640:
641: /* SHOULD PUT IN GUARDS: Make sure logging is initialized, even if we do not print it out */
642: #if defined(PETSC_USE_LOG)
643: PetscLogBegin_Private();
644: #endif
646: /*
647: Load the dynamic libraries (on machines that support them), this registers all
648: the solvers etc. (On non-dynamic machines this initializes the PetscDraw and PetscViewer classes)
649: */
650: PetscInitialize_DynamicLibraries();
652: MPI_Comm_size(PETSC_COMM_WORLD,&size);
653: PetscInfo1(0,"PETSc successfully started: number of processors = %d\n",size);
654: PetscGetHostName(hostname,256);
655: PetscInfo1(0,"Running on machine: %s\n",hostname);
657: PetscOptionsCheckInitial_Components();
658: /* Check the options database for options related to the options database itself */
659: PetscOptionsSetFromOptions();
661: #if defined(PETSC_USE_PETSC_MPI_EXTERNAL32)
662: /*
663: Tell MPI about our own data representation converter, this would/should be used if extern32 is not supported by the MPI
665: Currently not used because it is not supported by MPICH.
666: */
667: #if !defined(PETSC_WORDS_BIGENDIAN)
668: MPI_Register_datarep((char *)"petsc",PetscDataRep_read_conv_fn,PetscDataRep_write_conv_fn,PetscDataRep_extent_fn,PETSC_NULL);
669: #endif
670: #endif
672: PetscOptionsGetInt(PETSC_NULL,"-openmp_spawn_size",&nodesize,&flg);
673: if (flg) {
674: #if defined(PETSC_HAVE_MPI_COMM_SPAWN)
675: PetscOpenMPSpawn((PetscMPIInt) nodesize); /* worker nodes never return from here; they go directly to PetscEnd() */
676: #else
677: SETERRQ(PETSC_ERR_SUP,"PETSc built without MPI 2 (MPI_Comm_spawn) support, use -openmp_merge_size instead");
678: #endif
679: } else {
680: PetscOptionsGetInt(PETSC_NULL,"-openmp_merge_size",&nodesize,&flg);
681: if (flg) {
682: PetscOpenMPMerge((PetscMPIInt) nodesize,PETSC_NULL,PETSC_NULL);
683: if (PetscOpenMPWorker) { /* if worker then never enter user code */
684: PetscEnd();
685: }
686: }
687: }
688: flg = PETSC_FALSE;
689: PetscOptionsGetTruth(PETSC_NULL,"-python",&flg,PETSC_NULL);
690: if (flg) {PetscPythonInitialize(PETSC_NULL,PETSC_NULL);}
692: PetscFunctionReturn(ierr);
693: }
698: /*@C
699: PetscFinalize - Checks for options to be called at the conclusion
700: of the program. MPI_Finalize() is called only if the user had not
701: called MPI_Init() before calling PetscInitialize().
703: Collective on PETSC_COMM_WORLD
705: Options Database Keys:
706: + -options_table - Calls PetscOptionsPrint()
707: . -options_left - Prints unused options that remain in the database
708: . -options_left no - Does not print unused options that remain in the database
709: . -mpidump - Calls PetscMPIDump()
710: . -malloc_dump - Calls PetscMallocDump()
711: . -malloc_info - Prints total memory usage
712: - -malloc_log - Prints summary of memory usage
714: Options Database Keys for Profiling:
715: See the Profiling chapter of the users manual for details.
716: + -log_summary [filename] - Prints summary of flop and timing
717: information to screen. If the filename is specified the
718: summary is written to the file. (for code compiled with
719: PETSC_USE_LOG). See PetscLogPrintSummary().
720: . -log_all [filename] - Logs extensive profiling information
721: (for code compiled with PETSC_USE_LOG). See PetscLogDump().
722: . -log [filename] - Logs basic profiline information (for
723: code compiled with PETSC_USE_LOG). See PetscLogDump().
724: . -log_sync - Log the synchronization in scatters, inner products
725: and norms
726: - -log_mpe [filename] - Creates a logfile viewable by the
727: utility Upshot/Nupshot (in MPICH distribution)
729: Level: beginner
731: Note:
732: See PetscInitialize() for more general runtime options.
734: .seealso: PetscInitialize(), PetscOptionsPrint(), PetscMallocDump(), PetscMPIDump(), PetscEnd()
735: @*/
736: PetscErrorCode PetscFinalize(void)
737: {
739: PetscMPIInt rank;
740: int nopt;
741: PetscTruth flg1 = PETSC_FALSE,flg2 = PETSC_FALSE,flg3 = PETSC_FALSE;
743:
746: if (!PetscInitializeCalled) {
747: (*PetscErrorPrintf)("PetscInitialize() must be called before PetscFinalize()\n");
748: return(0);
749: }
750: PetscInfo(PETSC_NULL,"PetscFinalize() called\n");
752: PetscOpenMPFinalize();
754: PetscOptionsGetTruth(PETSC_NULL,"-python",&flg1,PETSC_NULL);
755: if (flg1) {PetscPythonFinalize();}
757: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
758: PetscOptionsGetTruth(PETSC_NULL,"-malloc_info",&flg2,PETSC_NULL);
759: if (!flg2) {
760: flg2 = PETSC_FALSE;
761: PetscOptionsGetTruth(PETSC_NULL,"-memory_info",&flg2,PETSC_NULL);
762: }
763: if (flg2) {
764: PetscMemoryShowUsage(PETSC_VIEWER_STDOUT_WORLD,"Summary of Memory Usage in PETSc\n");
765: }
767: /*
768: Free all objects registered with PetscObjectRegisterDestroy() such as PETSC_VIEWER_XXX_().
769: */
770: PetscObjectRegisterDestroyAll();
772: /*
773: Free all the registered create functions, such as KSPList, VecList, SNESList, etc
774: */
775: PetscFListDestroyAll();
777: /*
778: Destroy any packages that registered a finalize
779: */
780: PetscRegisterFinalizeAll();
782: /*
783: Destroy all the function registration lists created
784: */
785: PetscFinalize_DynamicLibraries();
787: #if defined(PETSC_USE_LOG)
788: flg1 = PETSC_FALSE;
789: PetscOptionsGetTruth(PETSC_NULL,"-get_total_flops",&flg1,PETSC_NULL);
790: if (flg1) {
791: PetscLogDouble flops = 0;
792: MPI_Reduce(&_TotalFlops,&flops,1,MPI_DOUBLE,MPI_SUM,0,PETSC_COMM_WORLD);
793: PetscPrintf(PETSC_COMM_WORLD,"Total flops over all processors %g\n",flops);
794: }
795: #endif
797: #if defined(PETSC_USE_DEBUG)
798: if (PetscStackActive) {
799: PetscStackDestroy();
800: }
801: #endif
803: #if defined(PETSC_USE_LOG)
804: {
805: char mname[PETSC_MAX_PATH_LEN];
806: #if defined(PETSC_HAVE_MPE)
807: mname[0] = 0;
808: PetscOptionsGetString(PETSC_NULL,"-log_mpe",mname,PETSC_MAX_PATH_LEN,&flg1);
809: if (flg1){
810: if (mname[0]) {PetscLogMPEDump(mname);}
811: else {PetscLogMPEDump(0);}
812: }
813: #endif
814: mname[0] = 0;
815: PetscOptionsGetString(PETSC_NULL,"-log_summary",mname,PETSC_MAX_PATH_LEN,&flg1);
816: if (flg1) {
817: if (mname[0]) {PetscLogPrintSummary(PETSC_COMM_WORLD,mname);}
818: else {PetscLogPrintSummary(PETSC_COMM_WORLD,0);}
819: }
821: PetscOptionsGetString(PETSC_NULL,"-log_detailed",mname,PETSC_MAX_PATH_LEN,&flg1);
822: if (flg1) {
823: if (mname[0]) {PetscLogPrintDetailed(PETSC_COMM_WORLD,mname);}
824: else {PetscLogPrintDetailed(PETSC_COMM_WORLD,0);}
825: }
827: mname[0] = 0;
828: PetscOptionsGetString(PETSC_NULL,"-log_all",mname,PETSC_MAX_PATH_LEN,&flg1);
829: PetscOptionsGetString(PETSC_NULL,"-log",mname,PETSC_MAX_PATH_LEN,&flg2);
830: if (flg1 || flg2){
831: if (mname[0]) PetscLogDump(mname);
832: else PetscLogDump(0);
833: }
834: PetscLogDestroy();
835: }
836: #endif
837: flg1 = PETSC_FALSE;
838: PetscOptionsGetTruth(PETSC_NULL,"-no_signal_handler",&flg1,PETSC_NULL);
839: if (!flg1) { PetscPopSignalHandler();}
840: flg1 = PETSC_FALSE;
841: PetscOptionsGetTruth(PETSC_NULL,"-mpidump",&flg1,PETSC_NULL);
842: if (flg1) {
843: PetscMPIDump(stdout);
844: }
845: flg1 = PETSC_FALSE;
846: flg2 = PETSC_FALSE;
847: /* preemptive call to avoid listing this option in options table as unused */
848: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
849: PetscOptionsGetTruth(PETSC_NULL,"-options_table",&flg2,PETSC_NULL);
850: if (flg2) {
851: if (!rank) {PetscOptionsPrint(stdout);}
852: }
854: /* to prevent PETSc -options_left from warning */
855: PetscOptionsHasName(PETSC_NULL,"-nox",&flg1);CHKERRQ(ierr)
856: PetscOptionsHasName(PETSC_NULL,"-nox_warning",&flg1);CHKERRQ(ierr)
858: if (!PetscOpenMPWorker) { /* worker processes skip this because they do not usually process options */
859: flg3 = PETSC_FALSE; /* default value is required */
860: PetscOptionsGetTruth(PETSC_NULL,"-options_left",&flg3,&flg1);
861: PetscOptionsAllUsed(&nopt);
862: if (flg3) {
863: if (!flg2) { /* have not yet printed the options */
864: PetscOptionsPrint(stdout);
865: }
866: if (!nopt) {
867: PetscPrintf(PETSC_COMM_WORLD,"There are no unused options.\n");
868: } else if (nopt == 1) {
869: PetscPrintf(PETSC_COMM_WORLD,"There is one unused database option. It is:\n");
870: } else {
871: PetscPrintf(PETSC_COMM_WORLD,"There are %d unused database options. They are:\n",nopt);
872: }
873: }
874: #if defined(PETSC_USE_DEBUG)
875: if (nopt && !flg3 && !flg1) {
876: PetscPrintf(PETSC_COMM_WORLD,"WARNING! There are options you set that were not used!\n");
877: PetscPrintf(PETSC_COMM_WORLD,"WARNING! could be spelling mistake, etc!\n");
878: PetscOptionsLeft();
879: } else if (nopt && flg3) {
880: #else
881: if (nopt && flg3) {
882: #endif
883: PetscOptionsLeft();
884: }
885: }
887: if (petsc_history) {
888: PetscLogCloseHistoryFile(&petsc_history);
889: petsc_history = 0;
890: }
892: PetscInfoAllow(PETSC_FALSE,PETSC_NULL);
894: {
895: char fname[PETSC_MAX_PATH_LEN];
896: FILE *fd;
897: int err;
899: fname[0] = 0;
900: PetscOptionsGetString(PETSC_NULL,"-malloc_dump",fname,250,&flg1);
901: if (flg1 && fname[0]) {
902: char sname[PETSC_MAX_PATH_LEN];
904: sprintf(sname,"%s_%d",fname,rank);
905: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
906: PetscMallocDump(fd);
907: err = fclose(fd);
908: if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
909: } else if (flg1) {
910: MPI_Comm local_comm;
912: MPI_Comm_dup(MPI_COMM_WORLD,&local_comm);
913: PetscSequentialPhaseBegin_Private(local_comm,1);
914: PetscMallocDump(stdout);
915: PetscSequentialPhaseEnd_Private(local_comm,1);
916: MPI_Comm_free(&local_comm);
917: }
918: }
919: {
920: char fname[PETSC_MAX_PATH_LEN];
921: FILE *fd;
922:
923: fname[0] = 0;
924: PetscOptionsGetString(PETSC_NULL,"-malloc_log",fname,250,&flg1);
925: if (flg1 && fname[0]) {
926: char sname[PETSC_MAX_PATH_LEN];
927: int err;
929: sprintf(sname,"%s_%d",fname,rank);
930: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
931: PetscMallocDumpLog(fd);
932: err = fclose(fd);
933: if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
934: } else if (flg1) {
935: PetscMallocDumpLog(stdout);
936: }
937: }
938: /* Can be destroyed only after all the options are used */
939: PetscOptionsDestroy();
941: PetscGlobalArgc = 0;
942: PetscGlobalArgs = 0;
944: #if defined(PETSC_USE_COMPLEX)
945: #if !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX)
946: MPI_Op_free(&MPIU_SUM);
947: MPI_Type_free(&MPI_C_DOUBLE_COMPLEX);
948: MPI_Type_free(&MPI_C_COMPLEX);
949: #endif
950: #endif
951: MPI_Type_free(&MPIU_2SCALAR);
952: MPI_Type_free(&MPIU_2INT);
953: MPI_Op_free(&PetscMaxSum_Op);
954: MPI_Op_free(&PetscADMax_Op);
955: MPI_Op_free(&PetscADMin_Op);
957: MPI_Keyval_free(&Petsc_Counter_keyval);
958: MPI_Keyval_free(&Petsc_InnerComm_keyval);
959: MPI_Keyval_free(&Petsc_OuterComm_keyval);
961: PetscInfo(0,"PETSc successfully ended!\n");
962: if (PetscBeganMPI) {
963: #if defined(PETSC_HAVE_MPI_FINALIZED)
964: PetscMPIInt flag;
965: MPI_Finalized(&flag);
966: if (flag) SETERRQ(PETSC_ERR_LIB,"MPI_Finalize() has already been called, even though MPI_Init() was called by PetscInitialize()");
967: #endif
968: MPI_Finalize();
969: }
971: if(PETSC_ZOPEFD != NULL){
972: if (PETSC_ZOPEFD != PETSC_STDOUT) fprintf(PETSC_ZOPEFD, "<<<end>>>");
973: else fprintf(PETSC_STDOUT, "<<<end>>>");}
975: /*
977: Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because
978: the communicator has some outstanding requests on it. Specifically if the
979: flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See
980: src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate()
981: is never freed as it should be. Thus one may obtain messages of the form
982: [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/mpiu.c indicating the
983: memory was not freed.
985: */
986: PetscMallocClear();
987: PetscInitializeCalled = PETSC_FALSE;
988: PetscFinalizeCalled = PETSC_TRUE;
989: PetscFunctionReturn(ierr);
990: }
992: /*
993: These may be used in code that ADIC is to be used on
994: */
998: /*@
999: PetscGlobalMax - Computes the maximum value over several processors
1001: Collective on MPI_Comm
1003: Input Parameters:
1004: + local - the local value
1005: - comm - the processors that find the maximum
1007: Output Parameter:
1008: . result - the maximum value
1009:
1010: Level: intermediate
1012: Notes:
1013: These functions are to be used inside user functions that are to be processed with
1014: ADIC. PETSc will automatically provide differentiated versions of these functions
1016: .seealso: PetscGlobalMin(), PetscGlobalSum()
1017: @*/
1018: PetscErrorCode PetscGlobalMax(PetscReal* local,PetscReal* result,MPI_Comm comm)
1019: {
1020: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MAX,comm);
1021: }
1025: /*@
1026: PetscGlobalMin - Computes the minimum value over several processors
1028: Collective on MPI_Comm
1030: Input Parameters:
1031: + local - the local value
1032: - comm - the processors that find the minimum
1034: Output Parameter:
1035: . result - the minimum value
1036:
1037: Level: intermediate
1039: Notes:
1040: These functions are to be used inside user functions that are to be processed with
1041: ADIC. PETSc will automatically provide differentiated versions of these functions
1043: .seealso: PetscGlobalMax(), PetscGlobalSum()
1044: @*/
1045: PetscErrorCode PetscGlobalMin(PetscReal* local,PetscReal* result,MPI_Comm comm)
1046: {
1047: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MIN,comm);
1048: }
1052: /*@
1053: PetscGlobalSum - Computes the sum over sever processors
1055: Collective on MPI_Comm
1057: Input Parameters:
1058: + local - the local value
1059: - comm - the processors that find the sum
1061: Output Parameter:
1062: . result - the sum
1063:
1064: Level: intermediate
1066: Notes:
1067: These functions are to be used inside user functions that are to be processed with
1068: ADIC. PETSc will automatically provide differentiated versions of these functions
1070: .seealso: PetscGlobalMin(), PetscGlobalMax()
1071: @*/
1072: PetscErrorCode PetscGlobalSum(PetscScalar* local,PetscScalar* result,MPI_Comm comm)
1073: {
1074: return MPI_Allreduce(local,result,1,MPIU_SCALAR,MPIU_SUM,comm);
1075: }