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: 7 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;
467: PetscInt nodesize;
468: PetscTruth flg;
469: char hostname[256];
472: if (PetscInitializeCalled) return(0);
474: /* these must be initialized in a routine, not as a constant declaration*/
475: PETSC_STDOUT = stdout;
476: PETSC_STDERR = stderr;
478: PetscOptionsCreate();
480: /*
481: We initialize the program name here (before MPI_Init()) because MPICH has a bug in
482: it that it sets args[0] on all processors to be args[0] on the first processor.
483: */
484: if (argc && *argc) {
485: PetscSetProgramName(**args);
486: } else {
487: PetscSetProgramName("Unknown Name");
488: }
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: PETSC_i = I;
525: #endif
526: }
528: MPI_Type_contiguous(2,MPIU_REAL,&MPIU_COMPLEX);
529: MPI_Type_commit(&MPIU_COMPLEX);
530: MPI_Op_create(PetscSum_Local,1,&PetscSum_Op);
531: #endif
533: /*
534: Create the PETSc MPI reduction operator that sums of the first
535: half of the entries and maxes the second half.
536: */
537: MPI_Op_create(PetscMaxSum_Local,1,&PetscMaxSum_Op);
539: MPI_Type_contiguous(2,MPIU_SCALAR,&MPIU_2SCALAR);
540: MPI_Type_commit(&MPIU_2SCALAR);
541: MPI_Op_create(PetscADMax_Local,1,&PetscADMax_Op);
542: MPI_Op_create(PetscADMin_Local,1,&PetscADMin_Op);
544: MPI_Type_contiguous(2,MPIU_INT,&MPIU_2INT);
545: MPI_Type_commit(&MPIU_2INT);
547:
548: /*
549: Build the options database
550: */
551: PetscOptionsInsert(argc,args,file);
553:
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();
562:
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((PetscMPIInt) 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((PetscMPIInt) 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;
648:
651: if (!PetscInitializeCalled) {
652: (*PetscErrorPrintf)("PetscInitialize() must be called before PetscFinalize()\n");
653: return(0);
654: }
655: PetscOpenMPFinalize();
657: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
658: PetscOptionsHasName(PETSC_NULL,"-malloc_info",&flg2);
659: if (!flg2) {
660: PetscOptionsHasName(PETSC_NULL,"-memory_info",&flg2);
661: }
662: if (flg2) {
663: PetscMemoryShowUsage(PETSC_VIEWER_STDOUT_WORLD,"Summary of Memory Usage in PETSc\n");
664: }
666: /* Destroy any packages that registered a finalize */
667: PetscRegisterFinalizeAll();
669: /*
670: Destroy all the function registration lists created
671: */
672: PetscFinalize_DynamicLibraries();
674: #if defined(PETSC_USE_LOG)
675: PetscOptionsHasName(PETSC_NULL,"-get_total_flops",&flg1);
676: if (flg1) {
677: PetscLogDouble flops = 0;
678: MPI_Reduce(&_TotalFlops,&flops,1,MPI_DOUBLE,MPI_SUM,0,PETSC_COMM_WORLD);
679: PetscPrintf(PETSC_COMM_WORLD,"Total flops over all processors %g\n",flops);
680: }
681: #endif
683: /*
684: Free all objects registered with PetscObjectRegisterDestroy() such ast
685: PETSC_VIEWER_XXX_().
686: */
687: PetscObjectRegisterDestroyAll();
688: PetscOptionsHelpDestroyList();
690: #if defined(PETSC_USE_DEBUG)
691: if (PetscStackActive) {
692: PetscStackDestroy();
693: }
694: #endif
696: #if defined(PETSC_USE_LOG)
697: {
698: char mname[PETSC_MAX_PATH_LEN];
699: #if defined(PETSC_HAVE_MPE)
700: mname[0] = 0;
701: PetscOptionsGetString(PETSC_NULL,"-log_mpe",mname,PETSC_MAX_PATH_LEN,&flg1);
702: if (flg1){
703: if (mname[0]) {PetscLogMPEDump(mname);}
704: else {PetscLogMPEDump(0);}
705: }
706: #endif
707: mname[0] = 0;
708: PetscOptionsGetString(PETSC_NULL,"-log_summary",mname,PETSC_MAX_PATH_LEN,&flg1);
709: if (flg1) {
710: if (mname[0]) {PetscLogPrintSummary(PETSC_COMM_WORLD,mname);}
711: else {PetscLogPrintSummary(PETSC_COMM_WORLD,0);}
712: }
714: PetscOptionsGetString(PETSC_NULL,"-log_detailed",mname,PETSC_MAX_PATH_LEN,&flg1);
715: if (flg1) {
716: if (mname[0]) {PetscLogPrintDetailed(PETSC_COMM_WORLD,mname);}
717: else {PetscLogPrintDetailed(PETSC_COMM_WORLD,0);}
718: }
720: mname[0] = 0;
721: PetscOptionsGetString(PETSC_NULL,"-log_all",mname,PETSC_MAX_PATH_LEN,&flg1);
722: PetscOptionsGetString(PETSC_NULL,"-log",mname,PETSC_MAX_PATH_LEN,&flg2);
723: if (flg1 || flg2){
724: if (mname[0]) PetscLogDump(mname);
725: else PetscLogDump(0);
726: }
727: PetscLogDestroy();
728: }
729: #endif
730: PetscOptionsHasName(PETSC_NULL,"-no_signal_handler",&flg1);
731: if (!flg1) { PetscPopSignalHandler();}
732: PetscOptionsHasName(PETSC_NULL,"-mpidump",&flg1);
733: if (flg1) {
734: PetscMPIDump(stdout);
735: }
736: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
737: PetscOptionsHasName(PETSC_NULL,"-options_table",&flg2);
738: if (flg2) {
739: if (!rank) {PetscOptionsPrint(stdout);}
740: }
742: /* to prevent PETSc -options_left from warning */
743: PetscOptionsHasName(PETSC_NULL,"-nox",&flg1);CHKERRQ(ierr)
744: PetscOptionsHasName(PETSC_NULL,"-nox_warning",&flg1);CHKERRQ(ierr)
746: flg3 = PETSC_FALSE; /* default value is required */
747: PetscOptionsGetTruth(PETSC_NULL,"-options_left",&flg3,&flg1);
748: PetscOptionsAllUsed(&nopt);
749: if (flg3) {
750: if (!flg2) { /* have not yet printed the options */
751: PetscOptionsPrint(stdout);
752: }
753: if (!nopt) {
754: PetscPrintf(PETSC_COMM_WORLD,"There are no unused options.\n");
755: } else if (nopt == 1) {
756: PetscPrintf(PETSC_COMM_WORLD,"There is one unused database option. It is:\n");
757: } else {
758: PetscPrintf(PETSC_COMM_WORLD,"There are %d unused database options. They are:\n",nopt);
759: }
760: }
761: #if defined(PETSC_USE_DEBUG)
762: if (nopt && !flg3 && !flg1) {
763: PetscPrintf(PETSC_COMM_WORLD,"WARNING! There are options you set that were not used!\n");
764: PetscPrintf(PETSC_COMM_WORLD,"WARNING! could be spelling mistake, etc!\n");
765: PetscOptionsLeft();
766: } else if (nopt && flg3) {
767: #else
768: if (nopt && flg3) {
769: #endif
770: PetscOptionsLeft();
771: }
773: PetscOptionsHasName(PETSC_NULL,"-log_history",&flg1);
774: if (flg1) {
775: PetscLogCloseHistoryFile(&petsc_history);
776: petsc_history = 0;
777: }
779: PetscInfoAllow(PETSC_FALSE,PETSC_NULL);
781: /*
782: Free all the registered create functions, such as KSPList, VecList, SNESList, etc
783: */
784: PetscFListDestroyAll();
786: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
787: PetscOptionsHasName(PETSC_NULL,"-malloc_log",&flg3);
788: if (flg1) {
789: char fname[PETSC_MAX_PATH_LEN];
790: FILE *fd;
791: int err;
793: fname[0] = 0;
794: PetscOptionsGetString(PETSC_NULL,"-malloc_dump",fname,250,&flg1);
795: if (flg1 && fname[0]) {
796: char sname[PETSC_MAX_PATH_LEN];
798: sprintf(sname,"%s_%d",fname,rank);
799: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
800: PetscMallocDump(fd);
801: err = fclose(fd);
802: if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
803: } else {
804: MPI_Comm local_comm;
806: MPI_Comm_dup(MPI_COMM_WORLD,&local_comm);
807: PetscSequentialPhaseBegin_Private(local_comm,1);
808: PetscMallocDump(stdout);
809: PetscSequentialPhaseEnd_Private(local_comm,1);
810: MPI_Comm_free(&local_comm);
811: }
812: }
813: if (flg3) {
814: char fname[PETSC_MAX_PATH_LEN];
815: FILE *fd;
816:
817: fname[0] = 0;
818: PetscOptionsGetString(PETSC_NULL,"-malloc_log",fname,250,&flg1);
819: if (flg1 && fname[0]) {
820: char sname[PETSC_MAX_PATH_LEN];
821: int err;
823: sprintf(sname,"%s_%d",fname,rank);
824: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
825: PetscMallocDumpLog(fd);
826: err = fclose(fd);
827: if (err) SETERRQ(PETSC_ERR_SYS,"fclose() failed on file");
828: } else {
829: PetscMallocDumpLog(stdout);
830: }
831: }
832: /* Can be destroyed only after all the options are used */
833: PetscOptionsDestroy();
835: PetscGlobalArgc = 0;
836: PetscGlobalArgs = 0;
838: #if defined(PETSC_USE_COMPLEX)
839: MPI_Op_free(&PetscSum_Op);
840: MPI_Type_free(&MPIU_COMPLEX);
841: #endif
842: MPI_Type_free(&MPIU_2SCALAR);
843: MPI_Type_free(&MPIU_2INT);
844: MPI_Op_free(&PetscMaxSum_Op);
845: MPI_Op_free(&PetscADMax_Op);
846: MPI_Op_free(&PetscADMin_Op);
848: PetscInfo(0,"PETSc successfully ended!\n");
849: if (PetscBeganMPI) {
850: #if defined(PETSC_HAVE_MPI_FINALIZED)
851: PetscMPIInt flag;
852: MPI_Finalized(&flag);
853: if (flag) SETERRQ(PETSC_ERR_LIB,"MPI_Finalize() has already been called, even though MPI_Init() was called by PetscInitialize()");
854: #endif
855: MPI_Finalize();
856: }
858: if(PETSC_ZOPEFD != NULL){
859: if (PETSC_ZOPEFD != PETSC_STDOUT) fprintf(PETSC_ZOPEFD, "<<<end>>>");
860: else fprintf(PETSC_STDOUT, "<<<end>>>");}
862: /*
864: Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because
865: the communicator has some outstanding requests on it. Specifically if the
866: flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See
867: src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate()
868: is never freed as it should be. Thus one may obtain messages of the form
869: [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/mpiu.c indicating the
870: memory was not freed.
872: */
873: PetscMallocClear();
874: PetscInitializeCalled = PETSC_FALSE;
875: PetscFinalizeCalled = PETSC_TRUE;
876: PetscFunctionReturn(ierr);
877: }
879: /*
880: These may be used in code that ADIC is to be used on
881: */
885: /*@C
886: PetscGlobalMax - Computes the maximum value over several processors
888: Collective on MPI_Comm
890: Input Parameters:
891: + local - the local value
892: - comm - the processors that find the maximum
894: Output Parameter:
895: . result - the maximum value
896:
897: Level: intermediate
899: Notes:
900: These functions are to be used inside user functions that are to be processed with
901: ADIC. PETSc will automatically provide differentiated versions of these functions
903: .seealso: PetscGlobalMin(), PetscGlobalSum()
904: @*/
905: PetscErrorCode PetscGlobalMax(PetscReal* local,PetscReal* result,MPI_Comm comm)
906: {
907: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MAX,comm);
908: }
912: /*@C
913: PetscGlobalMin - Computes the minimum value over several processors
915: Collective on MPI_Comm
917: Input Parameters:
918: + local - the local value
919: - comm - the processors that find the minimum
921: Output Parameter:
922: . result - the minimum value
923:
924: Level: intermediate
926: Notes:
927: These functions are to be used inside user functions that are to be processed with
928: ADIC. PETSc will automatically provide differentiated versions of these functions
930: .seealso: PetscGlobalMax(), PetscGlobalSum()
931: @*/
932: PetscErrorCode PetscGlobalMin(PetscReal* local,PetscReal* result,MPI_Comm comm)
933: {
934: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MIN,comm);
935: }
939: /*@C
940: PetscGlobalSum - Computes the sum over sever processors
942: Collective on MPI_Comm
944: Input Parameters:
945: + local - the local value
946: - comm - the processors that find the sum
948: Output Parameter:
949: . result - the sum
950:
951: Level: intermediate
953: Notes:
954: These functions are to be used inside user functions that are to be processed with
955: ADIC. PETSc will automatically provide differentiated versions of these functions
957: .seealso: PetscGlobalMin(), PetscGlobalMax()
958: @*/
959: PetscErrorCode PetscGlobalSum(PetscScalar* local,PetscScalar* result,MPI_Comm comm)
960: {
961: return MPI_Allreduce(local,result,1,MPIU_SCALAR,PetscSum_Op,comm);
962: }