Actual source code: dlregisvec.c

petsc-3.12.4 2020-02-04
Report Typos and Errors

  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;

 12: /*@C
 13:   ISFinalizePackage - This function destroys everything in the IS package. It is
 14:   called from PetscFinalize().

 16:   Level: developer

 18: .seealso: PetscFinalize()
 19: @*/
 20: PetscErrorCode  ISFinalizePackage(void)
 21: {

 25:   PetscFunctionListDestroy(&ISList);
 26:   PetscFunctionListDestroy(&ISLocalToGlobalMappingList);
 27:   PetscFunctionListDestroy(&PetscSectionSymList);
 28:   ISPackageInitialized                    = PETSC_FALSE;
 29:   ISRegisterAllCalled                     = PETSC_FALSE;
 30:   ISLocalToGlobalMappingRegisterAllCalled = PETSC_FALSE;
 31:   return(0);
 32: }

 34: /*@C
 35:       ISInitializePackage - This function initializes everything in the IS package. It is called
 36:   from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to ISCreateXXXX()
 37:   when using shared or static libraries.

 39:   Level: developer

 41: .seealso: PetscInitialize()
 42: @*/
 43: PetscErrorCode  ISInitializePackage(void)
 44: {
 45:   char           logList[256];
 46:   PetscBool      opt,pkg;

 50:   if (ISPackageInitialized) return(0);
 51:   ISPackageInitialized = PETSC_TRUE;
 52:   /* Register Classes */
 53:   PetscClassIdRegister("Index Set",&IS_CLASSID);
 54:   PetscClassIdRegister("IS L to G Mapping",&IS_LTOGM_CLASSID);
 55:   PetscClassIdRegister("Section",&PETSC_SECTION_CLASSID);
 56:   PetscClassIdRegister("Section Symmetry",&PETSC_SECTION_SYM_CLASSID);
 57:   /* Register Constructors */
 58:   ISRegisterAll();
 59:   ISLocalToGlobalMappingRegisterAll();
 60:   /* Process info exclusions */
 61:   PetscOptionsGetString(NULL,NULL,"-info_exclude",logList,sizeof(logList),&opt);
 62:   if (opt) {
 63:     PetscStrInList("is",logList,',',&pkg);
 64:     if (pkg) {PetscInfoDeactivateClass(IS_CLASSID);}
 65:     if (pkg) {PetscInfoDeactivateClass(IS_LTOGM_CLASSID);}
 66:     PetscStrInList("section",logList,',',&pkg);
 67:     if (pkg) {PetscInfoDeactivateClass(PETSC_SECTION_CLASSID);}
 68:     if (pkg) {PetscInfoDeactivateClass(PETSC_SECTION_SYM_CLASSID);}
 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_MAXINDEX_OP = 0;
 93: MPI_Op MPIU_MININDEX_OP = 0;

 95: static void MPIAPI MPIU_MaxIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
 96: {
 97:   PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;

100:   if (*datatype != MPIU_REAL) {
101:     (*PetscErrorPrintf)("Can only handle MPIU_REAL data types");
102:     MPI_Abort(MPI_COMM_SELF,1);
103:   }
104:   if (xin[0] > xout[0]) {
105:     xout[0] = xin[0];
106:     xout[1] = xin[1];
107:   } else if (xin[0] == xout[0]) {
108:     xout[1] = PetscMin(xin[1],xout[1]);
109:   }
110:   PetscFunctionReturnVoid(); /* cannot return a value */
111: }

113: static void MPIAPI MPIU_MinIndex_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
114: {
115:   PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;

118:   if (*datatype != MPIU_REAL) {
119:     (*PetscErrorPrintf)("Can only handle MPIU_REAL data types");
120:     MPI_Abort(MPI_COMM_SELF,1);
121:   }
122:   if (xin[0] < xout[0]) {
123:     xout[0] = xin[0];
124:     xout[1] = xin[1];
125:   } else if (xin[0] == xout[0]) {
126:     xout[1] = PetscMin(xin[1],xout[1]);
127:   }
128:   PetscFunctionReturnVoid();
129: }

131: PETSC_EXTERN void MPIAPI PetscSplitReduction_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);

133: const char *const NormTypes[] = {"1","2","FROBENIUS","INFINITY","1_AND_2","NormType","NORM_",0};
134: PetscInt          NormIds[7];  /* map from NormType to IDs used to cache Normvalues */

136: static PetscBool  VecPackageInitialized = PETSC_FALSE;

138: /*@C
139:   VecInitializePackage - This function initializes everything in the Vec package. It is called
140:   from PetscDLLibraryRegister_petscvec() when using dynamic libraries, and on the first call to VecCreate()
141:   when using shared or static libraries.

143:   Level: developer

145: .seealso: PetscInitialize()
146: @*/
147: PetscErrorCode  VecInitializePackage(void)
148: {
149:   char           logList[256];
150:   PetscBool      opt,pkg;
152:   PetscInt       i;

155:   if (VecPackageInitialized) return(0);
156:   VecPackageInitialized = PETSC_TRUE;
157:   /* Initialize subpackage */
158:   VecScatterInitializePackage();
159:   /* Register Classes */
160:   PetscClassIdRegister("Vector",&VEC_CLASSID);
161:   /* Register Constructors */
162:   VecRegisterAll();
163:   /* Register Events */
164:   PetscLogEventRegister("VecView",          VEC_CLASSID,&VEC_View);
165:   PetscLogEventRegister("VecMax",           VEC_CLASSID,&VEC_Max);
166:   PetscLogEventRegister("VecMin",           VEC_CLASSID,&VEC_Min);
167:   PetscLogEventRegister("VecDot",           VEC_CLASSID,&VEC_Dot);
168:   PetscLogEventRegister("VecDotNorm2",      VEC_CLASSID,&VEC_DotNorm2);
169:   PetscLogEventRegister("VecMDot",          VEC_CLASSID,&VEC_MDot);
170:   PetscLogEventRegister("VecTDot",          VEC_CLASSID,&VEC_TDot);
171:   PetscLogEventRegister("VecMTDot",         VEC_CLASSID,&VEC_MTDot);
172:   PetscLogEventRegister("VecNorm",          VEC_CLASSID,&VEC_Norm);
173:   PetscLogEventRegister("VecScale",         VEC_CLASSID,&VEC_Scale);
174:   PetscLogEventRegister("VecCopy",          VEC_CLASSID,&VEC_Copy);
175:   PetscLogEventRegister("VecSet",           VEC_CLASSID,&VEC_Set);
176:   PetscLogEventRegister("VecAXPY",          VEC_CLASSID,&VEC_AXPY);
177:   PetscLogEventRegister("VecAYPX",          VEC_CLASSID,&VEC_AYPX);
178:   PetscLogEventRegister("VecAXPBYCZ",       VEC_CLASSID,&VEC_AXPBYPCZ);
179:   PetscLogEventRegister("VecWAXPY",         VEC_CLASSID,&VEC_WAXPY);
180:   PetscLogEventRegister("VecMAXPY",         VEC_CLASSID,&VEC_MAXPY);
181:   PetscLogEventRegister("VecSwap",          VEC_CLASSID,&VEC_Swap);
182:   PetscLogEventRegister("VecOps",           VEC_CLASSID,&VEC_Ops);
183:   PetscLogEventRegister("VecAssemblyBegin", VEC_CLASSID,&VEC_AssemblyBegin);
184:   PetscLogEventRegister("VecAssemblyEnd",   VEC_CLASSID,&VEC_AssemblyEnd);
185:   PetscLogEventRegister("VecPointwiseMult", VEC_CLASSID,&VEC_PointwiseMult);
186:   PetscLogEventRegister("VecSetValues",     VEC_CLASSID,&VEC_SetValues);
187:   PetscLogEventRegister("VecLoad",          VEC_CLASSID,&VEC_Load);
188:   PetscLogEventRegister("VecScatterBegin",  VEC_CLASSID,&VEC_ScatterBegin);
189:   PetscLogEventRegister("VecScatterEnd  ",  VEC_CLASSID,&VEC_ScatterEnd);
190:   PetscLogEventRegister("VecSetRandom",     VEC_CLASSID,&VEC_SetRandom);
191:   PetscLogEventRegister("VecReduceArith",   VEC_CLASSID,&VEC_ReduceArithmetic);
192:   PetscLogEventRegister("VecReduceComm",    VEC_CLASSID,&VEC_ReduceCommunication);
193:   PetscLogEventRegister("VecReduceBegin",   VEC_CLASSID,&VEC_ReduceBegin);
194:   PetscLogEventRegister("VecReduceEnd",     VEC_CLASSID,&VEC_ReduceEnd);
195:   PetscLogEventRegister("VecNormalize",     VEC_CLASSID,&VEC_Normalize);
196: #if defined(PETSC_HAVE_VIENNACL)
197:   PetscLogEventRegister("VecVCLCopyTo",     VEC_CLASSID,&VEC_ViennaCLCopyToGPU);
198:   PetscLogEventRegister("VecVCLCopyFrom",   VEC_CLASSID,&VEC_ViennaCLCopyFromGPU);
199: #endif
200: #if defined(PETSC_HAVE_CUDA)
201:   PetscLogEventRegister("VecCUDACopyTo",    VEC_CLASSID,&VEC_CUDACopyToGPU);
202:   PetscLogEventRegister("VecCUDACopyFrom",  VEC_CLASSID,&VEC_CUDACopyFromGPU);
203:   PetscLogEventRegister("VecCopyToSome",    VEC_CLASSID,&VEC_CUDACopyToGPUSome);
204:   PetscLogEventRegister("VecCopyFromSome",  VEC_CLASSID,&VEC_CUDACopyFromGPUSome);
205: #endif

207:   /* Mark non-collective events */
208:   PetscLogEventSetCollective(VEC_SetValues,           PETSC_FALSE);
209: #if defined(PETSC_HAVE_VIENNACL)
210:   PetscLogEventSetCollective(VEC_ViennaCLCopyToGPU,   PETSC_FALSE);
211:   PetscLogEventSetCollective(VEC_ViennaCLCopyFromGPU, PETSC_FALSE);
212: #endif
213: #if defined(PETSC_HAVE_CUDA)
214:   PetscLogEventSetCollective(VEC_CUDACopyToGPU,       PETSC_FALSE);
215:   PetscLogEventSetCollective(VEC_CUDACopyFromGPU,     PETSC_FALSE);
216:   PetscLogEventSetCollective(VEC_CUDACopyToGPUSome,   PETSC_FALSE);
217:   PetscLogEventSetCollective(VEC_CUDACopyFromGPUSome, PETSC_FALSE);
218: #endif
219:   /* Turn off high traffic events by default */
220:   PetscLogEventSetActiveAll(VEC_SetValues, PETSC_FALSE);

222:   /* Process info exclusions */
223:   PetscOptionsGetString(NULL,NULL,"-info_exclude",logList,sizeof(logList),&opt);
224:   if (opt) {
225:     PetscStrInList("vec",logList,',',&pkg);
226:     if (pkg) {PetscInfoDeactivateClass(VEC_CLASSID);}
227:     if (pkg) {PetscInfoDeactivateClass(VEC_SCATTER_CLASSID);}
228:   }

230:   /* Process summary exclusions */
231:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
232:   if (opt) {
233:     PetscStrInList("vec",logList,',',&pkg);
234:     if (pkg) {PetscLogEventExcludeClass(VEC_CLASSID);}
235:     if (pkg) {PetscLogEventExcludeClass(VEC_SCATTER_CLASSID);}
236:   }

238:   /*
239:     Create the special MPI reduction operation that may be used by VecNorm/DotBegin()
240:   */
241:   MPI_Op_create(PetscSplitReduction_Local,1,&PetscSplitReduction_Op);
242:   MPI_Op_create(MPIU_MaxIndex_Local,2,&MPIU_MAXINDEX_OP);
243:   MPI_Op_create(MPIU_MinIndex_Local,2,&MPIU_MININDEX_OP);

245:   /* Register the different norm types for cached norms */
246:   for (i=0; i<4; i++) {
247:     PetscObjectComposedDataRegister(NormIds+i);
248:   }

250:   /* Register package finalizer */
251:   PetscRegisterFinalize(VecFinalizePackage);
252:   return(0);
253: }

255: /*@C
256:   VecFinalizePackage - This function finalizes everything in the Vec package. It is called
257:   from PetscFinalize().

259:   Level: developer

261: .seealso: PetscInitialize()
262: @*/
263: PetscErrorCode  VecFinalizePackage(void)
264: {

268:   PetscFunctionListDestroy(&VecList);
269:   PetscFunctionListDestroy(&VecScatterList);
270:   MPI_Op_free(&PetscSplitReduction_Op);
271:   MPI_Op_free(&MPIU_MAXINDEX_OP);
272:   MPI_Op_free(&MPIU_MININDEX_OP);
273:   if (Petsc_Reduction_keyval != MPI_KEYVAL_INVALID) {
274:     MPI_Comm_free_keyval(&Petsc_Reduction_keyval);
275:   }
276:   VecPackageInitialized = PETSC_FALSE;
277:   VecRegisterAllCalled  = PETSC_FALSE;
278:   return(0);
279: }

281: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
282: /*
283:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

285:   This one registers all the methods that are in the basic PETSc Vec library.

287:  */
288: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscvec(void)
289: {

293:   PetscSFInitializePackage();
294:   ISInitializePackage();
295:   AOInitializePackage();
296:   VecInitializePackage();
297:   PFInitializePackage();
298:   return(0);
299: }

301: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */