Actual source code: dlregisvec.c
2: #include <petsc/private/vecimpl.h>
3: #include <petsc/private/isimpl.h>
4: #include <petscpf.h>
5: #include <petscsf.h>
6: #include <petscsection.h>
7: #include <petscao.h>
9: static PetscBool ISPackageInitialized = PETSC_FALSE;
10: extern PetscFunctionList ISLocalToGlobalMappingList;
11: const char *ISInfos[] = {"SORTED", "UNIQUE", "PERMUTATION", "INTERVAL", "IDENTITY", "ISInfo", "IS_",NULL};
13: /*@C
14: ISFinalizePackage - This function destroys everything in the IS package. It is
15: called from PetscFinalize().
17: Level: developer
19: .seealso: PetscFinalize()
20: @*/
21: PetscErrorCode ISFinalizePackage(void)
22: {
26: PetscFunctionListDestroy(&ISList);
27: PetscFunctionListDestroy(&ISLocalToGlobalMappingList);
28: PetscFunctionListDestroy(&PetscSectionSymList);
29: ISPackageInitialized = PETSC_FALSE;
30: ISRegisterAllCalled = PETSC_FALSE;
31: ISLocalToGlobalMappingRegisterAllCalled = PETSC_FALSE;
32: return(0);
33: }
35: /*@C
36: ISInitializePackage - This function initializes everything in the IS package. It is called
37: from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to ISCreateXXXX()
38: when using shared or static libraries.
40: Level: developer
42: .seealso: PetscInitialize()
43: @*/
44: PetscErrorCode ISInitializePackage(void)
45: {
46: char logList[256];
47: PetscBool opt,pkg;
51: if (ISPackageInitialized) return(0);
52: ISPackageInitialized = PETSC_TRUE;
53: /* Register Classes */
54: PetscClassIdRegister("Index Set",&IS_CLASSID);
55: PetscClassIdRegister("IS L to G Mapping",&IS_LTOGM_CLASSID);
56: PetscClassIdRegister("Section",&PETSC_SECTION_CLASSID);
57: PetscClassIdRegister("Section Symmetry",&PETSC_SECTION_SYM_CLASSID);
58: /* Register Constructors */
59: ISRegisterAll();
60: ISLocalToGlobalMappingRegisterAll();
61: /* Register Events */
62: PetscLogEventRegister("ISView",IS_CLASSID,&IS_View);
63: PetscLogEventRegister("ISLoad",IS_CLASSID,&IS_Load);
64: /* Process Info */
65: {
66: PetscClassId classids[4];
68: classids[0] = IS_CLASSID;
69: classids[1] = IS_LTOGM_CLASSID;
70: classids[2] = PETSC_SECTION_CLASSID;
71: classids[3] = PETSC_SECTION_SYM_CLASSID;
72: PetscInfoProcessClass("is", 2, classids);
73: PetscInfoProcessClass("section", 2, &classids[2]);
74: }
75: /* Process summary exclusions */
76: PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
77: if (opt) {
78: PetscStrInList("is",logList,',',&pkg);
79: if (pkg) {PetscLogEventExcludeClass(IS_CLASSID);}
80: if (pkg) {PetscLogEventExcludeClass(IS_LTOGM_CLASSID);}
81: PetscStrInList("section",logList,',',&pkg);
82: if (pkg) {PetscLogEventExcludeClass(PETSC_SECTION_CLASSID);}
83: if (pkg) {PetscLogEventExcludeClass(PETSC_SECTION_SYM_CLASSID);}
84: }
85: /* Register package finalizer */
86: PetscRegisterFinalize(ISFinalizePackage);
87: return(0);
88: }
90: extern MPI_Op PetscSplitReduction_Op;
92: /*
93: These two functions are the MPI reduction operation used for max and min with index
94: A call to MPI_Op_create() converts the function Vec[Max,Min]_Local() to the MPI operator Vec[Max,Min]_Local_Op.
96: */
97: MPI_Op MPIU_MAXINDEX_OP = 0;
98: MPI_Op MPIU_MININDEX_OP = 0;
100: static void MPIAPI MPIU_MaxIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
101: {
102: PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;
105: if (*datatype != MPIU_REAL) {
106: (*PetscErrorPrintf)("Can only handle MPIU_REAL data types");
107: PETSCABORT(MPI_COMM_SELF,PETSC_ERR_ARG_WRONG);
108: }
109: if (xin[0] > xout[0]) {
110: xout[0] = xin[0];
111: xout[1] = xin[1];
112: } else if (xin[0] == xout[0]) {
113: xout[1] = PetscMin(xin[1],xout[1]);
114: }
115: PetscFunctionReturnVoid(); /* cannot return a value */
116: }
118: static void MPIAPI MPIU_MinIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
119: {
120: PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;
123: if (*datatype != MPIU_REAL) {
124: (*PetscErrorPrintf)("Can only handle MPIU_REAL data types");
125: PETSCABORT(MPI_COMM_SELF,PETSC_ERR_ARG_WRONG);
126: }
127: if (xin[0] < xout[0]) {
128: xout[0] = xin[0];
129: xout[1] = xin[1];
130: } else if (xin[0] == xout[0]) {
131: xout[1] = PetscMin(xin[1],xout[1]);
132: }
133: PetscFunctionReturnVoid();
134: }
136: PETSC_EXTERN void MPIAPI PetscSplitReduction_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);
138: const char *const NormTypes[] = {"1","2","FROBENIUS","INFINITY","1_AND_2","NormType","NORM_",NULL};
139: PetscInt NormIds[7]; /* map from NormType to IDs used to cache Normvalues */
141: static PetscBool VecPackageInitialized = PETSC_FALSE;
143: /*@C
144: VecInitializePackage - This function initializes everything in the Vec package. It is called
145: from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to VecCreate()
146: when using shared or static libraries.
148: Level: developer
150: .seealso: PetscInitialize()
151: @*/
152: PetscErrorCode VecInitializePackage(void)
153: {
154: char logList[256];
155: PetscBool opt,pkg;
157: PetscInt i;
160: if (VecPackageInitialized) return(0);
161: VecPackageInitialized = PETSC_TRUE;
162: /* Register Classes */
163: PetscClassIdRegister("Vector",&VEC_CLASSID);
164: /* Register Constructors */
165: VecRegisterAll();
166: /* Register Events */
167: PetscLogEventRegister("VecView", VEC_CLASSID,&VEC_View);
168: PetscLogEventRegister("VecMax", VEC_CLASSID,&VEC_Max);
169: PetscLogEventRegister("VecMin", VEC_CLASSID,&VEC_Min);
170: PetscLogEventRegister("VecDot", VEC_CLASSID,&VEC_Dot);
171: PetscLogEventRegister("VecDotNorm2", VEC_CLASSID,&VEC_DotNorm2);
172: PetscLogEventRegister("VecMDot", VEC_CLASSID,&VEC_MDot);
173: PetscLogEventRegister("VecTDot", VEC_CLASSID,&VEC_TDot);
174: PetscLogEventRegister("VecMTDot", VEC_CLASSID,&VEC_MTDot);
175: PetscLogEventRegister("VecNorm", VEC_CLASSID,&VEC_Norm);
176: PetscLogEventRegister("VecScale", VEC_CLASSID,&VEC_Scale);
177: PetscLogEventRegister("VecCopy", VEC_CLASSID,&VEC_Copy);
178: PetscLogEventRegister("VecSet", VEC_CLASSID,&VEC_Set);
179: PetscLogEventRegister("VecAXPY", VEC_CLASSID,&VEC_AXPY);
180: PetscLogEventRegister("VecAYPX", VEC_CLASSID,&VEC_AYPX);
181: PetscLogEventRegister("VecAXPBYCZ", VEC_CLASSID,&VEC_AXPBYPCZ);
182: PetscLogEventRegister("VecWAXPY", VEC_CLASSID,&VEC_WAXPY);
183: PetscLogEventRegister("VecMAXPY", VEC_CLASSID,&VEC_MAXPY);
184: PetscLogEventRegister("VecSwap", VEC_CLASSID,&VEC_Swap);
185: PetscLogEventRegister("VecOps", VEC_CLASSID,&VEC_Ops);
186: PetscLogEventRegister("VecAssemblyBegin", VEC_CLASSID,&VEC_AssemblyBegin);
187: PetscLogEventRegister("VecAssemblyEnd", VEC_CLASSID,&VEC_AssemblyEnd);
188: PetscLogEventRegister("VecPointwiseMult", VEC_CLASSID,&VEC_PointwiseMult);
189: PetscLogEventRegister("VecSetValues", VEC_CLASSID,&VEC_SetValues);
190: PetscLogEventRegister("VecLoad", VEC_CLASSID,&VEC_Load);
191: PetscLogEventRegister("VecScatterBegin", VEC_CLASSID,&VEC_ScatterBegin);
192: PetscLogEventRegister("VecScatterEnd ", VEC_CLASSID,&VEC_ScatterEnd);
193: PetscLogEventRegister("VecSetRandom", VEC_CLASSID,&VEC_SetRandom);
194: PetscLogEventRegister("VecReduceArith", VEC_CLASSID,&VEC_ReduceArithmetic);
195: PetscLogEventRegister("VecReduceComm", VEC_CLASSID,&VEC_ReduceCommunication);
196: PetscLogEventRegister("VecReduceBegin", VEC_CLASSID,&VEC_ReduceBegin);
197: PetscLogEventRegister("VecReduceEnd", VEC_CLASSID,&VEC_ReduceEnd);
198: PetscLogEventRegister("VecNormalize", VEC_CLASSID,&VEC_Normalize);
199: #if defined(PETSC_HAVE_VIENNACL)
200: PetscLogEventRegister("VecVCLCopyTo", VEC_CLASSID,&VEC_ViennaCLCopyToGPU);
201: PetscLogEventRegister("VecVCLCopyFrom", VEC_CLASSID,&VEC_ViennaCLCopyFromGPU);
202: #endif
203: #if defined(PETSC_HAVE_CUDA)
204: PetscLogEventRegister("VecCUDACopyTo", VEC_CLASSID,&VEC_CUDACopyToGPU);
205: PetscLogEventRegister("VecCUDACopyFrom", VEC_CLASSID,&VEC_CUDACopyFromGPU);
206: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID,&VEC_CUDACopyToGPUSome);
207: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID,&VEC_CUDACopyFromGPUSome);
208: #endif
209: #if defined(PETSC_HAVE_HIP)
210: PetscLogEventRegister("VecHIPCopyTo", VEC_CLASSID,&VEC_HIPCopyToGPU);
211: PetscLogEventRegister("VecHIPCopyFrom", VEC_CLASSID,&VEC_HIPCopyFromGPU);
212: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID,&VEC_HIPCopyToGPUSome);
213: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID,&VEC_HIPCopyFromGPUSome);
214: #endif
217: /* Mark non-collective events */
218: PetscLogEventSetCollective(VEC_SetValues, PETSC_FALSE);
219: #if defined(PETSC_HAVE_VIENNACL)
220: PetscLogEventSetCollective(VEC_ViennaCLCopyToGPU, PETSC_FALSE);
221: PetscLogEventSetCollective(VEC_ViennaCLCopyFromGPU, PETSC_FALSE);
222: #endif
223: #if defined(PETSC_HAVE_CUDA)
224: PetscLogEventSetCollective(VEC_CUDACopyToGPU, PETSC_FALSE);
225: PetscLogEventSetCollective(VEC_CUDACopyFromGPU, PETSC_FALSE);
226: PetscLogEventSetCollective(VEC_CUDACopyToGPUSome, PETSC_FALSE);
227: PetscLogEventSetCollective(VEC_CUDACopyFromGPUSome, PETSC_FALSE);
228: #endif
229: #if defined(PETSC_HAVE_HIP)
230: PetscLogEventSetCollective(VEC_HIPCopyToGPU, PETSC_FALSE);
231: PetscLogEventSetCollective(VEC_HIPCopyFromGPU, PETSC_FALSE);
232: PetscLogEventSetCollective(VEC_HIPCopyToGPUSome, PETSC_FALSE);
233: PetscLogEventSetCollective(VEC_HIPCopyFromGPUSome, PETSC_FALSE);
234: #endif
235: /* Turn off high traffic events by default */
236: PetscLogEventSetActiveAll(VEC_SetValues, PETSC_FALSE);
237: /* Process Info */
238: {
239: PetscClassId classids[1];
241: classids[0] = VEC_CLASSID;
242: PetscInfoProcessClass("vec", 1, classids);
243: }
244: /* Process summary exclusions */
245: PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
246: if (opt) {
247: PetscStrInList("vec",logList,',',&pkg);
248: if (pkg) {PetscLogEventExcludeClass(VEC_CLASSID);}
249: if (pkg) {PetscLogEventExcludeClass(PETSCSF_CLASSID);}
250: }
252: /*
253: Create the special MPI reduction operation that may be used by VecNorm/DotBegin()
254: */
255: MPI_Op_create(PetscSplitReduction_Local,1,&PetscSplitReduction_Op);
256: MPI_Op_create(MPIU_MaxIndex_Local,2,&MPIU_MAXINDEX_OP);
257: MPI_Op_create(MPIU_MinIndex_Local,2,&MPIU_MININDEX_OP);
259: /* Register the different norm types for cached norms */
260: for (i=0; i<4; i++) {
261: PetscObjectComposedDataRegister(NormIds+i);
262: }
264: /* Register package finalizer */
265: PetscRegisterFinalize(VecFinalizePackage);
266: return(0);
267: }
269: /*@C
270: VecFinalizePackage - This function finalizes everything in the Vec package. It is called
271: from PetscFinalize().
273: Level: developer
275: .seealso: PetscInitialize()
276: @*/
277: PetscErrorCode VecFinalizePackage(void)
278: {
282: PetscFunctionListDestroy(&VecList);
283: MPI_Op_free(&PetscSplitReduction_Op);
284: MPI_Op_free(&MPIU_MAXINDEX_OP);
285: MPI_Op_free(&MPIU_MININDEX_OP);
286: if (Petsc_Reduction_keyval != MPI_KEYVAL_INVALID) {
287: MPI_Comm_free_keyval(&Petsc_Reduction_keyval);
288: }
289: VecPackageInitialized = PETSC_FALSE;
290: VecRegisterAllCalled = PETSC_FALSE;
291: return(0);
292: }
294: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
295: /*
296: PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.
298: This one registers all the methods that are in the basic PETSc Vec library.
300: */
301: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscvec(void)
302: {
306: PetscSFInitializePackage();
307: ISInitializePackage();
308: AOInitializePackage();
309: VecInitializePackage();
310: PFInitializePackage();
311: return(0);
312: }
314: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */