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 {
98: PetscReal v;
99: PetscInt i;
100: };
101: struct PetscRealInt *xin = (struct PetscRealInt *)in;
102: struct PetscRealInt *xout = (struct PetscRealInt *)out;
103: int c;
105: if (*datatype != MPIU_REAL_INT) {
106: (*PetscErrorPrintf)("Can only handle MPIU_REAL_INT data types");
107: PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG);
108: }
109: for (c = 0; c < *cnt; c++) {
110: if (xin[c].v > xout[c].v) {
111: xout[c].v = xin[c].v;
112: xout[c].i = xin[c].i;
113: } else if (xin[c].v == xout[c].v) {
114: xout[c].i = PetscMin(xin[c].i, xout[c].i);
115: }
116: }
117: return; /* cannot return a value */
118: }
120: static void MPIAPI MPIU_MinIndex_Local(void *in, void *out, PetscMPIInt *cnt, MPI_Datatype *datatype)
121: {
122: struct PetscRealInt {
123: PetscReal v;
124: PetscInt i;
125: };
126: struct PetscRealInt *xin = (struct PetscRealInt *)in;
127: struct PetscRealInt *xout = (struct PetscRealInt *)out;
128: int c;
130: if (*datatype != MPIU_REAL_INT) {
131: (*PetscErrorPrintf)("Can only handle MPIU_REAL_INT data types");
132: PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG);
133: }
134: for (c = 0; c < *cnt; c++) {
135: if (xin[c].v < xout[c].v) {
136: xout[c].v = xin[c].v;
137: xout[c].i = xin[c].i;
138: } else if (xin[c].v == xout[c].v) {
139: xout[c].i = PetscMin(xin[c].i, xout[c].i);
140: }
141: }
142: return; /* cannot return a value */
143: }
145: PETSC_EXTERN void MPIAPI PetscSplitReduction_Local(void *, void *, PetscMPIInt *, MPI_Datatype *);
147: const char *const NormTypes[] = {"1", "2", "FROBENIUS", "INFINITY", "1_AND_2", "NormType", "NORM_", NULL};
148: PetscInt NormIds[7]; /* map from NormType to IDs used to cache Normvalues */
150: static PetscBool VecPackageInitialized = PETSC_FALSE;
152: /*@C
153: VecInitializePackage - This function initializes everything in the Vec package. It is called
154: from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to VecCreate()
155: when using shared or static libraries.
157: Level: developer
159: .seealso: `PetscInitialize()`
160: @*/
161: PetscErrorCode VecInitializePackage(void)
162: {
163: char logList[256];
164: PetscBool opt, pkg;
165: PetscInt i;
167: if (VecPackageInitialized) return 0;
168: VecPackageInitialized = PETSC_TRUE;
169: /* Register Classes */
170: PetscClassIdRegister("Vector", &VEC_CLASSID);
171: /* Register Constructors */
172: VecRegisterAll();
173: /* Register Events */
174: PetscLogEventRegister("VecView", VEC_CLASSID, &VEC_View);
175: PetscLogEventRegister("VecMax", VEC_CLASSID, &VEC_Max);
176: PetscLogEventRegister("VecMin", VEC_CLASSID, &VEC_Min);
177: PetscLogEventRegister("VecDot", VEC_CLASSID, &VEC_Dot);
178: PetscLogEventRegister("VecDotNorm2", VEC_CLASSID, &VEC_DotNorm2);
179: PetscLogEventRegister("VecMDot", VEC_CLASSID, &VEC_MDot);
180: PetscLogEventRegister("VecTDot", VEC_CLASSID, &VEC_TDot);
181: PetscLogEventRegister("VecMTDot", VEC_CLASSID, &VEC_MTDot);
182: PetscLogEventRegister("VecNorm", VEC_CLASSID, &VEC_Norm);
183: PetscLogEventRegister("VecScale", VEC_CLASSID, &VEC_Scale);
184: PetscLogEventRegister("VecCopy", VEC_CLASSID, &VEC_Copy);
185: PetscLogEventRegister("VecSet", VEC_CLASSID, &VEC_Set);
186: PetscLogEventRegister("VecAXPY", VEC_CLASSID, &VEC_AXPY);
187: PetscLogEventRegister("VecAYPX", VEC_CLASSID, &VEC_AYPX);
188: PetscLogEventRegister("VecAXPBYCZ", VEC_CLASSID, &VEC_AXPBYPCZ);
189: PetscLogEventRegister("VecWAXPY", VEC_CLASSID, &VEC_WAXPY);
190: PetscLogEventRegister("VecMAXPY", VEC_CLASSID, &VEC_MAXPY);
191: PetscLogEventRegister("VecSwap", VEC_CLASSID, &VEC_Swap);
192: PetscLogEventRegister("VecOps", VEC_CLASSID, &VEC_Ops);
193: PetscLogEventRegister("VecAssemblyBegin", VEC_CLASSID, &VEC_AssemblyBegin);
194: PetscLogEventRegister("VecAssemblyEnd", VEC_CLASSID, &VEC_AssemblyEnd);
195: PetscLogEventRegister("VecPointwiseMult", VEC_CLASSID, &VEC_PointwiseMult);
196: PetscLogEventRegister("VecSetValues", VEC_CLASSID, &VEC_SetValues);
197: PetscLogEventRegister("VecSetPreallCOO", VEC_CLASSID, &VEC_SetPreallocateCOO);
198: PetscLogEventRegister("VecSetValuesCOO", VEC_CLASSID, &VEC_SetValuesCOO);
199: PetscLogEventRegister("VecLoad", VEC_CLASSID, &VEC_Load);
200: PetscLogEventRegister("VecScatterBegin", VEC_CLASSID, &VEC_ScatterBegin);
201: PetscLogEventRegister("VecScatterEnd ", VEC_CLASSID, &VEC_ScatterEnd);
202: PetscLogEventRegister("VecSetRandom", VEC_CLASSID, &VEC_SetRandom);
203: PetscLogEventRegister("VecReduceArith", VEC_CLASSID, &VEC_ReduceArithmetic);
204: PetscLogEventRegister("VecReduceComm", VEC_CLASSID, &VEC_ReduceCommunication);
205: PetscLogEventRegister("VecReduceBegin", VEC_CLASSID, &VEC_ReduceBegin);
206: PetscLogEventRegister("VecReduceEnd", VEC_CLASSID, &VEC_ReduceEnd);
207: PetscLogEventRegister("VecNormalize", VEC_CLASSID, &VEC_Normalize);
208: #if defined(PETSC_HAVE_VIENNACL)
209: PetscLogEventRegister("VecVCLCopyTo", VEC_CLASSID, &VEC_ViennaCLCopyToGPU);
210: PetscLogEventRegister("VecVCLCopyFrom", VEC_CLASSID, &VEC_ViennaCLCopyFromGPU);
211: #endif
212: #if defined(PETSC_HAVE_CUDA)
213: PetscLogEventRegister("VecCUDACopyTo", VEC_CLASSID, &VEC_CUDACopyToGPU);
214: PetscLogEventRegister("VecCUDACopyFrom", VEC_CLASSID, &VEC_CUDACopyFromGPU);
215: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID, &VEC_CUDACopyToGPUSome);
216: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID, &VEC_CUDACopyFromGPUSome);
217: #endif
218: #if defined(PETSC_HAVE_HIP)
219: PetscLogEventRegister("VecHIPCopyTo", VEC_CLASSID, &VEC_HIPCopyToGPU);
220: PetscLogEventRegister("VecHIPCopyFrom", VEC_CLASSID, &VEC_HIPCopyFromGPU);
221: PetscLogEventRegister("VecCopyToSome", VEC_CLASSID, &VEC_HIPCopyToGPUSome);
222: PetscLogEventRegister("VecCopyFromSome", VEC_CLASSID, &VEC_HIPCopyFromGPUSome);
223: #endif
225: /* Mark non-collective events */
226: PetscLogEventSetCollective(VEC_SetValues, PETSC_FALSE);
227: #if defined(PETSC_HAVE_VIENNACL)
228: PetscLogEventSetCollective(VEC_ViennaCLCopyToGPU, PETSC_FALSE);
229: PetscLogEventSetCollective(VEC_ViennaCLCopyFromGPU, PETSC_FALSE);
230: #endif
231: #if defined(PETSC_HAVE_CUDA)
232: PetscLogEventSetCollective(VEC_CUDACopyToGPU, PETSC_FALSE);
233: PetscLogEventSetCollective(VEC_CUDACopyFromGPU, PETSC_FALSE);
234: PetscLogEventSetCollective(VEC_CUDACopyToGPUSome, PETSC_FALSE);
235: PetscLogEventSetCollective(VEC_CUDACopyFromGPUSome, PETSC_FALSE);
236: #endif
237: #if defined(PETSC_HAVE_HIP)
238: PetscLogEventSetCollective(VEC_HIPCopyToGPU, PETSC_FALSE);
239: PetscLogEventSetCollective(VEC_HIPCopyFromGPU, PETSC_FALSE);
240: PetscLogEventSetCollective(VEC_HIPCopyToGPUSome, PETSC_FALSE);
241: PetscLogEventSetCollective(VEC_HIPCopyFromGPUSome, PETSC_FALSE);
242: #endif
243: /* Turn off high traffic events by default */
244: PetscLogEventSetActiveAll(VEC_SetValues, PETSC_FALSE);
245: /* Process Info */
246: {
247: PetscClassId classids[1];
249: classids[0] = VEC_CLASSID;
250: PetscInfoProcessClass("vec", 1, classids);
251: }
252: /* Process summary exclusions */
253: PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt);
254: if (opt) {
255: PetscStrInList("vec", logList, ',', &pkg);
256: if (pkg) PetscLogEventExcludeClass(VEC_CLASSID);
257: if (pkg) PetscLogEventExcludeClass(PETSCSF_CLASSID);
258: }
260: /*
261: Create the special MPI reduction operation that may be used by VecNorm/DotBegin()
262: */
263: MPI_Op_create(PetscSplitReduction_Local, 1, &PetscSplitReduction_Op);
264: MPI_Op_create(MPIU_MaxIndex_Local, 1, &MPIU_MAXLOC);
265: MPI_Op_create(MPIU_MinIndex_Local, 1, &MPIU_MINLOC);
267: /* Register the different norm types for cached norms */
268: for (i = 0; i < 4; i++) PetscObjectComposedDataRegister(NormIds + i);
270: /* Register package finalizer */
271: PetscRegisterFinalize(VecFinalizePackage);
272: return 0;
273: }
275: /*@C
276: VecFinalizePackage - This function finalizes everything in the Vec package. It is called
277: from PetscFinalize().
279: Level: developer
281: .seealso: `PetscInitialize()`
282: @*/
283: PetscErrorCode VecFinalizePackage(void)
284: {
285: PetscFunctionListDestroy(&VecList);
286: MPI_Op_free(&PetscSplitReduction_Op);
287: MPI_Op_free(&MPIU_MAXLOC);
288: MPI_Op_free(&MPIU_MINLOC);
289: if (Petsc_Reduction_keyval != MPI_KEYVAL_INVALID) MPI_Comm_free_keyval(&Petsc_Reduction_keyval);
290: VecPackageInitialized = PETSC_FALSE;
291: VecRegisterAllCalled = PETSC_FALSE;
292: return 0;
293: }
295: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
296: /*
297: PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.
299: This one registers all the methods that are in the basic PETSc Vec library.
301: */
302: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscvec(void)
303: {
304: PetscSFInitializePackage();
305: ISInitializePackage();
306: AOInitializePackage();
307: VecInitializePackage();
308: PFInitializePackage();
309: return 0;
310: }
312: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */