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: EXTERN PetscErrorCode PetscLogBegin_Private(void);
11: /* -----------------------------------------------------------------------------------------*/
15: EXTERN PetscErrorCode PetscInitialize_DynamicLibraries(void);
16: EXTERN PetscErrorCode PetscFinalize_DynamicLibraries(void);
17: EXTERN PetscErrorCode PetscFListDestroyAll(void);
18: EXTERN PetscErrorCode PetscSequentialPhaseBegin_Private(MPI_Comm,int);
19: EXTERN PetscErrorCode PetscSequentialPhaseEnd_Private(MPI_Comm,int);
20: EXTERN PetscErrorCode PetscLogCloseHistoryFile(FILE **);
22: /* this is used by the _, __, and ___ macros (see include/petscerror.h) */
23: PetscErrorCode __g0;
25: /* user may set this BEFORE calling PetscInitialize() */
26: MPI_Comm PETSC_COMM_WORLD = 0;
28: /*
29: Declare and set all the string names of the PETSc enums
30: */
31: const char *PetscTruths[] = {"FALSE","TRUE","PetscTruth","PETSC_",0};
32: const char *PetscDataTypes[] = {"INT", "DOUBLE", "COMPLEX",
33: "LONG","SHORT", "FLOAT",
34: "CHAR","LOGICAL","ENUM","TRUTH","PetscDataType","PETSC_",0};
36: /*
37: Checks the options database for initializations related to the
38: PETSc components
39: */
42: PetscErrorCode PETSC_DLLEXPORT PetscOptionsCheckInitial_Components(void)
43: {
44: MPI_Comm comm = PETSC_COMM_WORLD;
45: PetscTruth flg1;
49: PetscOptionsHasName(PETSC_NULL,"-help",&flg1);
50: if (flg1) {
51: #if defined (PETSC_USE_LOG)
52: (*PetscHelpPrintf)(comm,"------Additional PETSc component options--------\n");
53: (*PetscHelpPrintf)(comm," -log_summary_exclude: <vec,mat,pc.ksp,snes>\n");
54: (*PetscHelpPrintf)(comm," -log_info_exclude: <null,vec,mat,pc,ksp,snes,ts>\n");
55: (*PetscHelpPrintf)(comm,"-----------------------------------------------\n");
56: #endif
57: }
58: return(0);
59: }
63: /*@C
64: PetscInitializeNoArguments - Calls PetscInitialize() from C/C++ without
65: the command line arguments.
67: Collective
68:
69: Level: advanced
71: .seealso: PetscInitialize(), PetscInitializeFortran()
72: @*/
73: PetscErrorCode PETSC_DLLEXPORT PetscInitializeNoArguments(void)
74: {
76: int argc = 0;
77: char **args = 0;
80: PetscInitialize(&argc,&args,PETSC_NULL,PETSC_NULL);
81: PetscFunctionReturn(ierr);
82: }
86: /*@
87: PetscInitialized - Determine whether PETSc is initialized.
88:
89: Level: beginner
91: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
92: @*/
93: PetscErrorCode PETSC_DLLEXPORT PetscInitialized(PetscTruth *isInitialized)
94: {
97: *isInitialized = PetscInitializeCalled;
98: return(0);
99: }
103: /*@
104: PetscFinalized - Determine whether PetscFinalize() has been called yet
105:
106: Level: developer
108: .seealso: PetscInitialize(), PetscInitializeNoArguments(), PetscInitializeFortran()
109: @*/
110: PetscErrorCode PETSC_DLLEXPORT PetscFinalized(PetscTruth *isFinalized)
111: {
114: *isFinalized = PetscFinalizeCalled;
115: return(0);
116: }
118: EXTERN PetscErrorCode PetscOptionsCheckInitial_Private(void);
121: /*
122: This function is the MPI reduction operation used to compute the sum of the
123: first half of the datatype and the max of the second half.
124: */
125: MPI_Op PetscMaxSum_Op = 0;
130: void PETSC_DLLEXPORT PetscMaxSum_Local(void *in,void *out,int *cnt,MPI_Datatype *datatype)
131: {
132: PetscInt *xin = (PetscInt*)in,*xout = (PetscInt*)out,i,count = *cnt;
135: if (*datatype != MPIU_2INT) {
136: (*PetscErrorPrintf)("Can only handle MPIU_2INT data types");
137: MPI_Abort(MPI_COMM_WORLD,1);
138: }
140: for (i=0; i<count; i++) {
141: xout[2*i] = PetscMax(xout[2*i],xin[2*i]);
142: xout[2*i+1] += xin[2*i+1];
143: }
144: PetscStackPop;
145: return;
146: }
149: /*
150: Returns the max of the first entry owned by this processor and the
151: sum of the second entry.
152: */
155: PetscErrorCode PETSC_DLLEXPORT PetscMaxSum(MPI_Comm comm,const PetscInt nprocs[],PetscInt *max,PetscInt *sum)
156: {
157: PetscMPIInt size,rank;
158: PetscInt *work;
162: MPI_Comm_size(comm,&size);
163: MPI_Comm_rank(comm,&rank);
164: PetscMalloc(2*size*sizeof(PetscInt),&work);
165: MPI_Allreduce((void*)nprocs,work,size,MPIU_2INT,PetscMaxSum_Op,comm);
166: *max = work[2*rank];
167: *sum = work[2*rank+1];
168: PetscFree(work);
169: return(0);
170: }
172: /* ----------------------------------------------------------------------------*/
173: MPI_Op PETSC_DLLEXPORT PetscADMax_Op = 0;
178: void PETSC_DLLEXPORT PetscADMax_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
179: {
180: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
181: PetscInt i,count = *cnt;
184: if (*datatype != MPIU_2SCALAR) {
185: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
186: MPI_Abort(MPI_COMM_WORLD,1);
187: }
189: for (i=0; i<count; i++) {
190: if (PetscRealPart(xout[2*i]) < PetscRealPart(xin[2*i])) {
191: xout[2*i] = xin[2*i];
192: xout[2*i+1] = xin[2*i+1];
193: }
194: }
196: PetscStackPop;
197: return;
198: }
201: MPI_Op PETSC_DLLEXPORT PetscADMin_Op = 0;
206: void PETSC_DLLEXPORT PetscADMin_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
207: {
208: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
209: PetscInt i,count = *cnt;
212: if (*datatype != MPIU_2SCALAR) {
213: (*PetscErrorPrintf)("Can only handle MPIU_2SCALAR data (i.e. double or complex) types");
214: MPI_Abort(MPI_COMM_WORLD,1);
215: }
217: for (i=0; i<count; i++) {
218: if (PetscRealPart(xout[2*i]) > PetscRealPart(xin[2*i])) {
219: xout[2*i] = xin[2*i];
220: xout[2*i+1] = xin[2*i+1];
221: }
222: }
224: PetscStackPop;
225: return;
226: }
228: /* ---------------------------------------------------------------------------------------*/
230: #if defined(PETSC_USE_COMPLEX)
231: MPI_Op PetscSum_Op = 0;
236: void PETSC_DLLEXPORT PetscSum_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
237: {
238: PetscScalar *xin = (PetscScalar *)in,*xout = (PetscScalar*)out;
239: PetscInt i,count = *cnt;
242: if (*datatype != MPIU_SCALAR) {
243: (*PetscErrorPrintf)("Can only handle MPIU_SCALAR data (i.e. double or complex) types");
244: MPI_Abort(MPI_COMM_WORLD,1);
245: }
247: for (i=0; i<count; i++) {
248: xout[i] += xin[i];
249: }
251: PetscStackPop;
252: return;
253: }
255: #endif
257: static int PetscGlobalArgc = 0;
258: static char **PetscGlobalArgs = 0;
262: /*@C
263: PetscGetArgs - Allows you to access the raw command line arguments anywhere
264: after PetscInitialize() is called but before PetscFinalize().
266: Not Collective
268: Output Parameters:
269: + argc - count of number of command line arguments
270: - args - the command line arguments
272: Level: intermediate
274: Notes:
275: This is usually used to pass the command line arguments into other libraries
276: that are called internally deep in PETSc or the application.
278: Concepts: command line arguments
279:
280: .seealso: PetscFinalize(), PetscInitializeFortran()
282: @*/
283: PetscErrorCode PETSC_DLLEXPORT PetscGetArgs(int *argc,char ***args)
284: {
286: if (!PetscGlobalArgs) {
287: SETERRQ(PETSC_ERR_ORDER,"You must call after PetscInitialize() but before PetscFinalize()");
288: }
289: *argc = PetscGlobalArgc;
290: *args = PetscGlobalArgs;
291: return(0);
292: }
296: /*@C
297: PetscInitialize - Initializes the PETSc database and MPI.
298: PetscInitialize() calls MPI_Init() if that has yet to be called,
299: so this routine should always be called near the beginning of
300: your program -- usually the very first line!
302: Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set
304: Input Parameters:
305: + argc - count of number of command line arguments
306: . args - the command line arguments
307: . file - [optional] PETSc database file, defaults to ~username/.petscrc
308: (use PETSC_NULL for default)
309: - help - [optional] Help message to print, use PETSC_NULL for no message
311: If you wish PETSc to run on a subcommunicator of MPI_COMM_WORLD, create that
312: communicator first and assign it to PETSC_COMM_WORLD BEFORE calling PetscInitialize()
314: Options Database Keys:
315: + -start_in_debugger [noxterm,dbx,xdb,gdb,...] - Starts program in debugger
316: . -on_error_attach_debugger [noxterm,dbx,xdb,gdb,...] - Starts debugger when error detected
317: . -on_error_emacs <machinename> causes emacsclient to jump to error file
318: . -debugger_nodes [node1,node2,...] - Indicates nodes to start in debugger
319: . -debugger_pause [sleeptime] (in seconds) - Pauses debugger
320: . -stop_for_debugger - Print message on how to attach debugger manually to
321: process and wait (-debugger_pause) seconds for attachment
322: . -malloc - Indicates use of PETSc error-checking malloc
323: . -malloc no - Indicates not to use error-checking malloc
324: . -fp_trap - Stops on floating point exceptions (Note that on the
325: IBM RS6000 this slows code by at least a factor of 10.)
326: . -no_signal_handler - Indicates not to trap error signals
327: . -shared_tmp - indicates /tmp directory is shared by all processors
328: . -not_shared_tmp - each processor has own /tmp
329: . -tmp - alternative name of /tmp directory
330: . -get_total_flops - returns total flops done by all processors
331: - -memory_info - Print memory usage at end of run
333: Options Database Keys for Profiling:
334: See the Profiling chapter of the users manual for details.
335: + -log_trace [filename] - Print traces of all PETSc calls
336: to the screen (useful to determine where a program
337: hangs without running in the debugger). See PetscLogTraceBegin().
338: . -log_info <optional filename> - Prints verbose information to the screen
339: - -log_info_exclude <null,vec,mat,pc,ksp,snes,ts> - Excludes some of the verbose messages
341: Environmental Variables:
342: + PETSC_TMP - alternative tmp directory
343: . PETSC_SHARED_TMP - tmp is shared by all processes
344: . PETSC_NOT_SHARED_TMP - each process has its own private tmp
345: . PETSC_VIEWER_SOCKET_PORT - socket number to use for socket viewer
346: - PETSC_VIEWER_SOCKET_MACHINE - machine to use for socket viewer to connect to
349: Level: beginner
351: Notes:
352: If for some reason you must call MPI_Init() separately, call
353: it before PetscInitialize().
355: Fortran Version:
356: In Fortran this routine has the format
357: $ call PetscInitialize(file,ierr)
359: + ierr - error return code
360: - file - [optional] PETSc database file name, defaults to
361: ~username/.petscrc (use PETSC_NULL_CHARACTER for default)
362:
363: Important Fortran Note:
364: In Fortran, you MUST use PETSC_NULL_CHARACTER to indicate a
365: null character string; you CANNOT just use PETSC_NULL as
366: in the C version. See the users manual for details.
369: Concepts: initializing PETSc
370:
371: .seealso: PetscFinalize(), PetscInitializeFortran(), PetescGetArgs()
373: @*/
374: PetscErrorCode PETSC_DLLEXPORT PetscInitialize(int *argc,char ***args,const char file[],const char help[])
375: {
377: PetscMPIInt flag, size;
378: PetscTruth flg;
379: char hostname[256];
382: if (PetscInitializeCalled) return(0);
383:
384: PetscOptionsCreate();
386: /*
387: We initialize the program name here (before MPI_Init()) because MPICH has a bug in
388: it that it sets args[0] on all processors to be args[0] on the first processor.
389: */
390: if (argc && *argc) {
391: PetscSetProgramName(**args);
392: } else {
393: PetscSetProgramName("Unknown Name");
394: }
397: MPI_Initialized(&flag);
398: if (!flag) {
399: if (PETSC_COMM_WORLD) SETERRQ(PETSC_ERR_SUP,"You cannot set PETSC_COMM_WORLD if you have not initialized MPI first");
400: MPI_Init(argc,args);
401: PetscBeganMPI = PETSC_TRUE;
402: }
403: if (argc && args) {
404: PetscGlobalArgc = *argc;
405: PetscGlobalArgs = *args;
406: }
407: PetscInitializeCalled = PETSC_TRUE;
408: PetscFinalizeCalled = PETSC_FALSE;
410: if (!PETSC_COMM_WORLD) {
411: PETSC_COMM_WORLD = MPI_COMM_WORLD;
412: }
414: /* Done after init due to a bug in MPICH-GM? */
415: PetscErrorPrintfInitialize();
417: MPI_Comm_rank(MPI_COMM_WORLD,&PetscGlobalRank);
418: MPI_Comm_size(MPI_COMM_WORLD,&PetscGlobalSize);
420: #if defined(PETSC_USE_COMPLEX)
421: /*
422: Initialized the global complex variable; this is because with
423: shared libraries the constructors for global variables
424: are not called; at least on IRIX.
425: */
426: {
427: PetscScalar ic(0.0,1.0);
428: PETSC_i = ic;
429: }
430: MPI_Type_contiguous(2,MPIU_REAL,&MPIU_COMPLEX);
431: MPI_Type_commit(&MPIU_COMPLEX);
432: MPI_Op_create(PetscSum_Local,1,&PetscSum_Op);
433: #endif
435: /*
436: Create the PETSc MPI reduction operator that sums of the first
437: half of the entries and maxes the second half.
438: */
439: MPI_Op_create(PetscMaxSum_Local,1,&PetscMaxSum_Op);
441: MPI_Type_contiguous(2,MPIU_SCALAR,&MPIU_2SCALAR);
442: MPI_Type_commit(&MPIU_2SCALAR);
443: MPI_Op_create(PetscADMax_Local,1,&PetscADMax_Op);
444: MPI_Op_create(PetscADMin_Local,1,&PetscADMin_Op);
446: MPI_Type_contiguous(2,MPIU_INT,&MPIU_2INT);
447: MPI_Type_commit(&MPIU_2INT);
449: /*
450: Build the options database and check for user setup requests
451: */
452: PetscOptionsInsert(argc,args,file);
454: /*
455: Print main application help message
456: */
457: PetscOptionsHasName(PETSC_NULL,"-help",&flg);
458: if (help && flg) {
459: PetscPrintf(PETSC_COMM_WORLD,help);
460: }
461: PetscOptionsCheckInitial_Private();
463: /* SHOULD PUT IN GUARDS: Make sure logging is initialized, even if we do not print it out */
464: PetscLogBegin_Private();
466: /*
467: Load the dynamic libraries (on machines that support them), this registers all
468: the solvers etc. (On non-dynamic machines this initializes the PetscDraw and PetscViewer classes)
469: */
470: PetscInitialize_DynamicLibraries();
472: /*
473: Initialize all the default viewers
474: */
475: MPI_Comm_size(PETSC_COMM_WORLD,&size);
476: PetscLogInfo((0,"PetscInitialize:PETSc successfully started: number of processors = %d\n",size));
477: PetscGetHostName(hostname,256);
478: PetscLogInfo((0,"PetscInitialize:Running on machine: %s\n",hostname));
480: PetscOptionsCheckInitial_Components();
482: PetscFunctionReturn(ierr);
483: }
488: /*@C
489: PetscFinalize - Checks for options to be called at the conclusion
490: of the program. MPI_Finalize() is called only if the user had not
491: called MPI_Init() before calling PetscInitialize().
493: Collective on PETSC_COMM_WORLD
495: Options Database Keys:
496: + -options_table - Calls PetscOptionsPrint()
497: . -options_left - Prints unused options that remain in the database
498: . -options_left no - Does not print unused options that remain in the database
499: . -mpidump - Calls PetscMPIDump()
500: . -malloc_dump - Calls PetscMallocDump()
501: . -malloc_info - Prints total memory usage
502: . -malloc_debug - Calls PetscMallocDebug(), checks allocated memory for corruption while running
503: - -malloc_log - Prints summary of memory usage
505: Options Database Keys for Profiling:
506: See the Profiling chapter of the users manual for details.
507: + -log_summary [filename] - Prints summary of flop and timing
508: information to screen. If the filename is specified the
509: summary is written to the file. (for code compiled with
510: PETSC_USE_LOG). See PetscLogPrintSummary().
511: . -log_all [filename] - Logs extensive profiling information
512: (for code compiled with PETSC_USE_LOG). See PetscLogDump().
513: . -log [filename] - Logs basic profiline information (for
514: code compiled with PETSC_USE_LOG). See PetscLogDump().
515: . -log_sync - Log the synchronization in scatters, inner products
516: and norms
517: - -log_mpe [filename] - Creates a logfile viewable by the
518: utility Upshot/Nupshot (in MPICH distribution)
520: Level: beginner
522: Note:
523: See PetscInitialize() for more general runtime options.
525: .seealso: PetscInitialize(), PetscOptionsPrint(), PetscMallocDump(), PetscMPIDump(), PetscEnd()
526: @*/
527: PetscErrorCode PETSC_DLLEXPORT PetscFinalize(void)
528: {
530: PetscMPIInt rank;
531: int nopt;
532: PetscTruth flg1,flg2,flg3;
533:
536: if (!PetscInitializeCalled) {
537: (*PetscErrorPrintf)("PetscInitialize() must be called before PetscFinalize()\n");
538: return(0);
539: }
541: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
542: PetscOptionsHasName(PETSC_NULL,"-malloc_info",&flg2);
543: if (!flg2) {
544: PetscOptionsHasName(PETSC_NULL,"-memory_info",&flg2);
545: }
546: if (flg2) {
547: PetscMemoryShowUsage(PETSC_VIEWER_STDOUT_WORLD,"Summary of Memory Usage in PETSc\n");
548: }
550: /* Destroy auxiliary packages */
551: #if defined(PETSC_HAVE_MATHEMATICA)
552: PetscViewerMathematicaFinalizePackage();
553: #endif
554: PetscPLAPACKFinalizePackage();
556: /*
557: Destroy all the function registration lists created
558: */
559: PetscFinalize_DynamicLibraries();
561: #if defined(PETSC_USE_LOG)
562: PetscOptionsHasName(PETSC_NULL,"-get_total_flops",&flg1);
563: if (flg1) {
564: PetscLogDouble flops = 0;
565: MPI_Reduce(&_TotalFlops,&flops,1,MPI_DOUBLE,MPI_SUM,0,PETSC_COMM_WORLD);
566: PetscPrintf(PETSC_COMM_WORLD,"Total flops over all processors %g\n",flops);
567: }
568: #endif
570: /*
571: Free all objects registered with PetscObjectRegisterDestroy() such ast
572: PETSC_VIEWER_XXX_().
573: */
574: PetscObjectRegisterDestroyAll();
576: #if defined(PETSC_USE_DEBUG)
577: if (PetscStackActive) {
578: PetscStackDestroy();
579: }
580: #endif
582: #if defined(PETSC_USE_LOG)
583: {
584: char mname[PETSC_MAX_PATH_LEN];
585: #if defined(PETSC_HAVE_MPE)
586: mname[0] = 0;
587: PetscOptionsGetString(PETSC_NULL,"-log_mpe",mname,PETSC_MAX_PATH_LEN,&flg1);
588: if (flg1){
589: if (mname[0]) {PetscLogMPEDump(mname);}
590: else {PetscLogMPEDump(0);}
591: }
592: #endif
593: mname[0] = 0;
594: PetscOptionsGetString(PETSC_NULL,"-log_summary",mname,PETSC_MAX_PATH_LEN,&flg1);
595: if (flg1) {
596: if (mname[0]) {PetscLogPrintSummary(PETSC_COMM_WORLD,mname);}
597: else {PetscLogPrintSummary(PETSC_COMM_WORLD,0);}
598: }
600: mname[0] = 0;
601: PetscOptionsGetString(PETSC_NULL,"-log_all",mname,PETSC_MAX_PATH_LEN,&flg1);
602: PetscOptionsGetString(PETSC_NULL,"-log",mname,PETSC_MAX_PATH_LEN,&flg2);
603: if (flg1 || flg2){
604: if (mname[0]) PetscLogDump(mname);
605: else PetscLogDump(0);
606: }
607: PetscLogDestroy();
608: }
609: #endif
610: PetscOptionsHasName(PETSC_NULL,"-no_signal_handler",&flg1);
611: if (!flg1) { PetscPopSignalHandler();}
612: PetscOptionsHasName(PETSC_NULL,"-mpidump",&flg1);
613: if (flg1) {
614: PetscMPIDump(stdout);
615: }
616: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
617: PetscOptionsHasName(PETSC_NULL,"-options_table",&flg2);
618: if (flg2) {
619: if (!rank) {PetscOptionsPrint(stdout);}
620: }
622: /* to prevent PETSc -options_left from warning */
623: PetscOptionsHasName(PETSC_NULL,"-nox_warning",&flg1);CHKERRQ(ierr)
624: PetscOptionsHasName(PETSC_NULL,"-error_output_stderr",&flg1);
626: PetscOptionsGetTruth(PETSC_NULL,"-options_left",&flg2,&flg1);
627: PetscOptionsAllUsed(&nopt);
628: if (flg2) {
629: PetscOptionsPrint(stdout);
630: if (!nopt) {
631: PetscPrintf(PETSC_COMM_WORLD,"There are no unused options.\n");
632: } else if (nopt == 1) {
633: PetscPrintf(PETSC_COMM_WORLD,"There is one unused database option. It is:\n");
634: } else {
635: PetscPrintf(PETSC_COMM_WORLD,"There are %d unused database options. They are:\n",nopt);
636: }
637: }
638: #if defined(PETSC_USE_DEBUG)
639: if (nopt && !flg1 && !flg2) {
640: PetscPrintf(PETSC_COMM_WORLD,"WARNING! There are options you set that were not used!\n");
641: PetscPrintf(PETSC_COMM_WORLD,"WARNING! could be spelling mistake, etc!\n");
642: PetscOptionsLeft();
643: } else if (nopt && flg2) {
644: #else
645: if (nopt && flg2) {
646: #endif
647: PetscOptionsLeft();
648: }
650: PetscOptionsHasName(PETSC_NULL,"-log_history",&flg1);
651: if (flg1) {
652: PetscLogCloseHistoryFile(&petsc_history);
653: petsc_history = 0;
654: }
656: PetscLogInfoAllow(PETSC_FALSE,PETSC_NULL);
658: /*
659: Free all the registered create functions, such as KSPList, VecList, SNESList, etc
660: */
661: PetscFListDestroyAll();
663: PetscOptionsHasName(PETSC_NULL,"-malloc_dump",&flg1);
664: PetscOptionsHasName(PETSC_NULL,"-malloc_log",&flg3);
665: if (flg1) {
666: char fname[PETSC_MAX_PATH_LEN];
667: FILE *fd;
668:
669: fname[0] = 0;
670: PetscOptionsGetString(PETSC_NULL,"-malloc_dump",fname,250,&flg1);
671: if (flg1 && fname[0]) {
672: char sname[PETSC_MAX_PATH_LEN];
674: sprintf(sname,"%s_%d",fname,rank);
675: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
676: PetscMallocDump(fd);
677: fclose(fd);
678: } else {
679: MPI_Comm local_comm;
681: MPI_Comm_dup(MPI_COMM_WORLD,&local_comm);
682: PetscSequentialPhaseBegin_Private(local_comm,1);
683: PetscMallocDump(stdout);
684: PetscSequentialPhaseEnd_Private(local_comm,1);
685: MPI_Comm_free(&local_comm);
686: }
687: }
688: if (flg3) {
689: char fname[PETSC_MAX_PATH_LEN];
690: FILE *fd;
691:
692: fname[0] = 0;
693: PetscOptionsGetString(PETSC_NULL,"-malloc_log",fname,250,&flg1);
694: if (flg1 && fname[0]) {
695: char sname[PETSC_MAX_PATH_LEN];
697: sprintf(sname,"%s_%d",fname,rank);
698: fd = fopen(sname,"w"); if (!fd) SETERRQ1(PETSC_ERR_FILE_OPEN,"Cannot open log file: %s",sname);
699: PetscMallocDumpLog(fd);
700: fclose(fd);
701: } else {
702: PetscMallocDumpLog(stdout);
703: }
704: }
705: /* Can be destroyed only after all the options are used */
706: PetscOptionsDestroy();
708: PetscGlobalArgc = 0;
709: PetscGlobalArgs = 0;
711: #if defined(PETSC_USE_COMPLEX)
712: MPI_Op_free(&PetscSum_Op);
713: MPI_Type_free(&MPIU_COMPLEX);
714: #endif
715: MPI_Type_free(&MPIU_2SCALAR);
716: MPI_Type_free(&MPIU_2INT);
717: MPI_Op_free(&PetscMaxSum_Op);
718: MPI_Op_free(&PetscADMax_Op);
719: MPI_Op_free(&PetscADMin_Op);
721: PetscLogInfo((0,"PetscFinalize:PETSc successfully ended!\n"));
722: if (PetscBeganMPI) {
723: MPI_Finalize();
724: }
726: /*
728: Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because
729: the communicator has some outstanding requests on it. Specifically if the
730: flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See
731: src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate()
732: is never freed as it should be. Thus one may obtain messages of the form
733: [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/src/mpiu.c indicating the
734: memory was not freed.
736: */
737: PetscClearMalloc();
738: PetscInitializeCalled = PETSC_FALSE;
739: PetscFinalizeCalled = PETSC_TRUE;
740: PetscFunctionReturn(ierr);
741: }
743: /*
744: These may be used in code that ADIC is to be used on
745: */
749: /*@C
750: PetscGlobalMax - Computes the maximum value over several processors
752: Collective on MPI_Comm
754: Input Parameters:
755: + local - the local value
756: - comm - the processors that find the maximum
758: Output Parameter:
759: . result - the maximum value
760:
761: Level: intermediate
763: Notes:
764: These functions are to be used inside user functions that are to be processed with
765: ADIC. PETSc will automatically provide differentiated versions of these functions
767: .seealso: PetscGlobalMin(), PetscGlobalSum()
768: @*/
769: PetscErrorCode PETSC_DLLEXPORT PetscGlobalMax(PetscReal* local,PetscReal* result,MPI_Comm comm)
770: {
771: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MAX,comm);
772: }
776: /*@C
777: PetscGlobalMin - Computes the minimum value over several processors
779: Collective on MPI_Comm
781: Input Parameters:
782: + local - the local value
783: - comm - the processors that find the minimum
785: Output Parameter:
786: . result - the minimum value
787:
788: Level: intermediate
790: Notes:
791: These functions are to be used inside user functions that are to be processed with
792: ADIC. PETSc will automatically provide differentiated versions of these functions
794: .seealso: PetscGlobalMax(), PetscGlobalSum()
795: @*/
796: PetscErrorCode PETSC_DLLEXPORT PetscGlobalMin(PetscReal* local,PetscReal* result,MPI_Comm comm)
797: {
798: return MPI_Allreduce(local,result,1,MPIU_REAL,MPI_MIN,comm);
799: }
803: /*@C
804: PetscGlobalSum - Computes the sum over sever processors
806: Collective on MPI_Comm
808: Input Parameters:
809: + local - the local value
810: - comm - the processors that find the sum
812: Output Parameter:
813: . result - the sum
814:
815: Level: intermediate
817: Notes:
818: These functions are to be used inside user functions that are to be processed with
819: ADIC. PETSc will automatically provide differentiated versions of these functions
821: .seealso: PetscGlobalMin(), PetscGlobalMax()
822: @*/
823: PetscErrorCode PETSC_DLLEXPORT PetscGlobalSum(PetscScalar* local,PetscScalar* result,MPI_Comm comm)
824: {
825: return MPI_Allreduce(local,result,1,MPIU_SCALAR,PetscSum_Op,comm);
826: }