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: }