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: {
23: PetscFunctionListDestroy(&ISList);
24: PetscFunctionListDestroy(&ISLocalToGlobalMappingList);
25: PetscFunctionListDestroy(&PetscSectionSymList);
26: ISPackageInitialized = PETSC_FALSE;
27: ISRegisterAllCalled = PETSC_FALSE;
28: ISLocalToGlobalMappingRegisterAllCalled = PETSC_FALSE;
29: return 0;
30: }
32: /*@C
33: ISInitializePackage - This function initializes everything in the IS package. It is called
34: from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to ISCreateXXXX()
35: when using shared or static libraries.
37: Level: developer
39: .seealso: PetscInitialize()
40: @*/
41: PetscErrorCode ISInitializePackage(void)
42: {
43: char logList[256];
44: PetscBool opt,pkg;
46: if (ISPackageInitialized) return 0;
47: ISPackageInitialized = PETSC_TRUE;
48: /* Register Classes */
49: PetscClassIdRegister("Index Set",&IS_CLASSID);
50: PetscClassIdRegister("IS L to G Mapping",&IS_LTOGM_CLASSID);
51: PetscClassIdRegister("Section",&PETSC_SECTION_CLASSID);
52: PetscClassIdRegister("Section Symmetry",&PETSC_SECTION_SYM_CLASSID);
53: /* Register Constructors */
54: ISRegisterAll();
55: ISLocalToGlobalMappingRegisterAll();
56: /* Register Events */
57: PetscLogEventRegister("ISView",IS_CLASSID,&IS_View);
58: PetscLogEventRegister("ISLoad",IS_CLASSID,&IS_Load);
59: /* Process Info */
60: {
61: PetscClassId classids[4];
63: classids[0] = IS_CLASSID;
64: classids[1] = IS_LTOGM_CLASSID;
65: classids[2] = PETSC_SECTION_CLASSID;
66: classids[3] = PETSC_SECTION_SYM_CLASSID;
67: PetscInfoProcessClass("is", 2, classids);
68: PetscInfoProcessClass("section", 2, &classids[2]);
69: }
70: /* Process summary exclusions */
71: PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
72: if (opt) {
73: PetscStrInList("is",logList,',',&pkg);
74: if (pkg) PetscLogEventExcludeClass(IS_CLASSID);
75: if (pkg) PetscLogEventExcludeClass(IS_LTOGM_CLASSID);
76: PetscStrInList("section",logList,',',&pkg);
77: if (pkg) PetscLogEventExcludeClass(PETSC_SECTION_CLASSID);
78: if (pkg) PetscLogEventExcludeClass(PETSC_SECTION_SYM_CLASSID);
79: }
80: /* Register package finalizer */
81: PetscRegisterFinalize(ISFinalizePackage);
82: return 0;
83: }
85: extern MPI_Op PetscSplitReduction_Op;
87: /*
88: These two functions are the MPI reduction operation used for max and min with index
89: A call to MPI_Op_create() converts the function Vec[Max,Min]_Local() to the MPI operator Vec[Max,Min]_Local_Op.
91: */
92: MPI_Op MPIU_MAXLOC = 0;
93: MPI_Op MPIU_MINLOC = 0;
95: static void MPIAPI MPIU_MaxIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
96: {
97: struct PetscRealInt { PetscReal v; PetscInt i; };
98: struct PetscRealInt *xin = (struct PetscRealInt*)in;
99: struct PetscRealInt *xout = (struct PetscRealInt*)out;
100: int c;
102: if (*datatype != MPIU_REAL_INT) {
103: (*PetscErrorPrintf)("Can only handle MPIU_REAL_INT data types");
104: PETSCABORT(MPI_COMM_SELF,PETSC_ERR_ARG_WRONG);
105: }
106: for (c = 0; c < *cnt; c++) {
107: if (xin[c].v > xout[c].v) {
108: xout[c].v = xin[c].v;
109: xout[c].i = xin[c].i;
110: } else if (xin[c].v == xout[c].v) {
111: xout[c].i = PetscMin(xin[c].i,xout[c].i);
112: }
113: }
114: return; /* cannot return a value */
115: }
117: static void MPIAPI MPIU_MinIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
118: {
119: struct PetscRealInt { PetscReal v; PetscInt i; };
120: struct PetscRealInt *xin = (struct PetscRealInt*)in;
121: struct PetscRealInt *xout = (struct PetscRealInt*)out;
122: int c;
124: if (*datatype != MPIU_REAL_INT) {
125: (*PetscErrorPrintf)("Can only handle MPIU_REAL_INT data types");
126: PETSCABORT(MPI_COMM_SELF,PETSC_ERR_ARG_WRONG);
127: }
128: for (c = 0; c < *cnt; c++) {
129: if (xin[c].v < xout[c].v) {
130: xout[c].v = xin[c].v;
131: xout[c].i = xin[c].i;
132: } else if (xin[c].v == xout[c].v) {
133: xout[c].i = PetscMin(xin[c].i,xout[c].i);
134: }
135: }
136: return; /* cannot return a value */
137: }
139: PETSC_EXTERN void MPIAPI PetscSplitReduction_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);
141: const char *const NormTypes[] = {"1","2","FROBENIUS","INFINITY","1_AND_2","NormType","NORM_",NULL};
142: PetscInt NormIds[7]; /* map from NormType to IDs used to cache Normvalues */
144: static PetscBool VecPackageInitialized = PETSC_FALSE;
146: /*@C
147: VecInitializePackage - This function initializes everything in the Vec package. It is called
148: from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to VecCreate()
149: when using shared or static libraries.
151: Level: developer
153: .seealso: PetscInitialize()
154: @*/
155: PetscErrorCode VecInitializePackage(void)
156: {
157: char logList[256];
158: PetscBool opt,pkg;
159: PetscInt i;
161: if (VecPackageInitialized) return 0;
162: VecPackageInitialized = PETSC_TRUE;
163: /* Register Classes */
164: PetscClassIdRegister("Vector",&VEC_CLASSID);
165: /* Register Constructors */
166: VecRegisterAll();
167: /* Register Events */
168: PetscLogEventRegister("VecView", VEC_CLASSID,&VEC_View);
169: PetscLogEventRegister("VecMax", VEC_CLASSID,&VEC_Max);
170: PetscLogEventRegister("VecMin", VEC_CLASSID,&VEC_Min);
171: PetscLogEventRegister("VecDot", VEC_CLASSID,&VEC_Dot);
172: PetscLogEventRegister("VecDotNorm2", VEC_CLASSID,&VEC_DotNorm2);
173: PetscLogEventRegister("VecMDot", VEC_CLASSID,&VEC_MDot);
174: PetscLogEventRegister("VecTDot", VEC_CLASSID,&VEC_TDot);
175: PetscLogEventRegister("VecMTDot", VEC_CLASSID,&VEC_MTDot);
176: PetscLogEventRegister("VecNorm", VEC_CLASSID,&VEC_Norm);
177: PetscLogEventRegister("VecScale", VEC_CLASSID,&VEC_Scale);
178: PetscLogEventRegister("VecCopy", VEC_CLASSID,&VEC_Copy);
179: PetscLogEventRegister("VecSet", VEC_CLASSID,&VEC_Set);
180: PetscLogEventRegister("VecAXPY", VEC_CLASSID,&VEC_AXPY);
181: PetscLogEventRegister("VecAYPX", VEC_CLASSID,&VEC_AYPX);
182: PetscLogEventRegister("VecAXPBYCZ", VEC_CLASSID,&VEC_AXPBYPCZ);
183: PetscLogEventRegister("VecWAXPY", VEC_CLASSID,&VEC_WAXPY);
184: PetscLogEventRegister("VecMAXPY", VEC_CLASSID,&VEC_MAXPY);
185: PetscLogEventRegister("VecSwap", VEC_CLASSID,&VEC_Swap);
186: PetscLogEventRegister("VecOps", VEC_CLASSID,&VEC_Ops);
187: PetscLogEventRegister("VecAssemblyBegin", VEC_CLASSID,&VEC_AssemblyBegin);
188: PetscLogEventRegister("VecAssemblyEnd", VEC_CLASSID,&VEC_AssemblyEnd);
189: PetscLogEventRegister("VecPointwiseMult", VEC_CLASSID,&VEC_PointwiseMult);
190: PetscLogEventRegister("VecSetValues", VEC_CLASSID,&VEC_SetValues);
191: PetscLogEventRegister("VecLoad", VEC_CLASSID,&VEC_Load);
192: PetscLogEventRegister("VecScatterBegin", VEC_CLASSID,&VEC_ScatterBegin);
193: PetscLogEventRegister("VecScatterEnd ", VEC_CLASSID,&VEC_ScatterEnd);
194: PetscLogEventRegister("VecSetRandom", VEC_CLASSID,&VEC_SetRandom);
195: PetscLogEventRegister("VecReduceArith", VEC_CLASSID,&VEC_ReduceArithmetic);
196: PetscLogEventRegister("VecReduceComm", VEC_CLASSID,&VEC_ReduceCommunication);
197: PetscLogEventRegister("VecReduceBegin", VEC_CLASSID,&VEC_ReduceBegin);
198: PetscLogEventRegister("VecReduceEnd", VEC_CLASSID,&VEC_ReduceEnd);
199: PetscLogEventRegister("VecNormalize", VEC_CLASSID,&VEC_Normalize);
200: #if defined(PETSC_HAVE_VIENNACL)
201: PetscLogEventRegister("VecVCLCopyTo", VEC_CLASSID,&VEC_ViennaCLCopyToGPU);
202: PetscLogEventRegister("VecVCLCopyFrom", VEC_CLASSID,&VEC_ViennaCLCopyFromGPU);
203: #endif
204: #if defined(PETSC_HAVE_CUDA)
205: PetscLogEventRegister("VecCUDACopyTo", VEC_CLASSID,&VEC_CUDACopyToGPU);
206: PetscLogEventRegister("VecCUDACopyFrom", VEC_CLASSID,&VEC_CUDACopyFromGPU);
207: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID,&VEC_CUDACopyToGPUSome);
208: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID,&VEC_CUDACopyFromGPUSome);
209: #endif
210: #if defined(PETSC_HAVE_HIP)
211: PetscLogEventRegister("VecHIPCopyTo", VEC_CLASSID,&VEC_HIPCopyToGPU);
212: PetscLogEventRegister("VecHIPCopyFrom", VEC_CLASSID,&VEC_HIPCopyFromGPU);
213: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID,&VEC_HIPCopyToGPUSome);
214: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID,&VEC_HIPCopyFromGPUSome);
215: #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,1,&MPIU_MAXLOC);
257: MPI_Op_create(MPIU_MinIndex_Local,1,&MPIU_MINLOC);
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: {
279: PetscFunctionListDestroy(&VecList);
280: MPI_Op_free(&PetscSplitReduction_Op);
281: MPI_Op_free(&MPIU_MAXLOC);
282: MPI_Op_free(&MPIU_MINLOC);
283: if (Petsc_Reduction_keyval != MPI_KEYVAL_INVALID) {
284: MPI_Comm_free_keyval(&Petsc_Reduction_keyval);
285: }
286: VecPackageInitialized = PETSC_FALSE;
287: VecRegisterAllCalled = PETSC_FALSE;
288: return 0;
289: }
291: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
292: /*
293: PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.
295: This one registers all the methods that are in the basic PETSc Vec library.
297: */
298: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscvec(void)
299: {
300: PetscSFInitializePackage();
301: ISInitializePackage();
302: AOInitializePackage();
303: VecInitializePackage();
304: PFInitializePackage();
305: return 0;
306: }
308: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */