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 */