Actual source code: dlregisvec.c

  2: #include <petscvec.h>
  3: #include <petscpf.h>

  5: static PetscBool  ISPackageInitialized = PETSC_FALSE;
  8: /*@C
  9:   ISFinalizePackage - This function destroys everything in the IS package. It is
 10:   called from PetscFinalize().

 12:   Level: developer

 14: .keywords: Petsc, destroy, package
 15: .seealso: PetscFinalize()
 16: @*/
 17: PetscErrorCode  ISFinalizePackage(void)
 18: {
 20:   ISPackageInitialized = PETSC_FALSE;
 21:   ISList               = PETSC_NULL;
 22:   ISRegisterAllCalled  = PETSC_FALSE;
 23:   return(0);
 24: }

 28: /*@C
 29:       ISInitializePackage - This function initializes everything in the IS package. It is called
 30:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to ISCreateXXXX()
 31:   when using static libraries.

 33:   Input Parameter:
 34: . path - The dynamic library path, or PETSC_NULL

 36:   Level: developer

 38: .keywords: Vec, initialize, package
 39: .seealso: PetscInitialize()
 40: @*/
 41: PetscErrorCode  ISInitializePackage(const char path[])
 42: {
 43:   char              logList[256];
 44:   char              *className;
 45:   PetscBool         opt;
 46:   PetscErrorCode    ierr;

 49:   if (ISPackageInitialized) return(0);
 50:   ISPackageInitialized = PETSC_TRUE;
 51:   /* Register Constructors */
 52:   ISRegisterAll(path);
 53:   /* Register Classes */
 54:   PetscClassIdRegister("Index Set",&IS_CLASSID);
 55:   PetscClassIdRegister("IS L to G Mapping",&IS_LTOGM_CLASSID);

 57:   /* Process info exclusions */
 58:   PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);
 59:   if (opt) {
 60:     PetscStrstr(logList, "is", &className);
 61:     if (className) {
 62:       PetscInfoDeactivateClass(IS_CLASSID);
 63:       PetscInfoDeactivateClass(IS_LTOGM_CLASSID);
 64:     }
 65:   }
 66:   /* Process summary exclusions */
 67:   PetscOptionsGetString(PETSC_NULL, "-log_summary_exclude", logList, 256, &opt);
 68:   if (opt) {
 69:     PetscStrstr(logList, "is", &className);
 70:     if (className) {
 71:       PetscLogEventDeactivateClass(IS_CLASSID);
 72:       PetscLogEventDeactivateClass(IS_LTOGM_CLASSID);
 73:     }
 74:   }
 75:   PetscRegisterFinalize(ISFinalizePackage);
 76:   return(0);
 77: }



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

 92: static PetscBool  VecPackageInitialized = PETSC_FALSE;

 96: /*@C
 97:   VecInitializePackage - This function initializes everything in the Vec package. It is called
 98:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to VecCreate()
 99:   when using static libraries.

101:   Input Parameter:
102: . path - The dynamic library path, or PETSC_NULL

104:   Level: developer

106: .keywords: Vec, initialize, package
107: .seealso: PetscInitialize()
108: @*/
109: PetscErrorCode  VecInitializePackage(const char path[])
110: {
111:   char              logList[256];
112:   char              *className;
113:   PetscBool         opt;
114:   PetscErrorCode    ierr;
115:   PetscInt          i;

118:   if (VecPackageInitialized) return(0);
119:   VecPackageInitialized = PETSC_TRUE;
120:   /* Register Classes */
121:   PetscClassIdRegister("Vector",&VEC_CLASSID);
122:   PetscClassIdRegister("Vector Scatter",&VEC_SCATTER_CLASSID);
123:   /* Register Constructors */
124:   VecRegisterAll(path);
125:   /* Register Events */
126:   PetscLogEventRegister("VecView",          VEC_CLASSID,&VEC_View);
127:   PetscLogEventRegister("VecMax",           VEC_CLASSID,&VEC_Max);
128:   PetscLogEventRegister("VecMin",           VEC_CLASSID,&VEC_Min);
129:   PetscLogEventRegister("VecDotBarrier",    VEC_CLASSID,&VEC_DotBarrier);
130:   PetscLogEventRegister("VecDot",           VEC_CLASSID,&VEC_Dot);
131:   PetscLogEventRegister("VecDotNormBarr",   VEC_CLASSID,&VEC_DotNormBarrier);
132:   PetscLogEventRegister("VecDotNorm2",      VEC_CLASSID,&VEC_DotNorm);
133:   PetscLogEventRegister("VecMDotBarrier",   VEC_CLASSID,&VEC_MDotBarrier);
134:   PetscLogEventRegister("VecMDot",          VEC_CLASSID,&VEC_MDot);
135:   PetscLogEventRegister("VecTDot",          VEC_CLASSID,&VEC_TDot);
136:   PetscLogEventRegister("VecMTDot",         VEC_CLASSID,&VEC_MTDot);
137:   PetscLogEventRegister("VecNormBarrier",   VEC_CLASSID,&VEC_NormBarrier);
138:   PetscLogEventRegister("VecNorm",          VEC_CLASSID,&VEC_Norm);
139:   PetscLogEventRegister("VecScale",         VEC_CLASSID,&VEC_Scale);
140:   PetscLogEventRegister("VecCopy",          VEC_CLASSID,&VEC_Copy);
141:   PetscLogEventRegister("VecSet",           VEC_CLASSID,&VEC_Set);
142:   PetscLogEventRegister("VecAXPY",          VEC_CLASSID,&VEC_AXPY);
143:   PetscLogEventRegister("VecAYPX",          VEC_CLASSID,&VEC_AYPX);
144:   PetscLogEventRegister("VecAXPBYCZ",       VEC_CLASSID,&VEC_AXPBYPCZ);
145:   PetscLogEventRegister("VecWAXPY",         VEC_CLASSID,&VEC_WAXPY);
146:   PetscLogEventRegister("VecMAXPY",         VEC_CLASSID,&VEC_MAXPY);
147:   PetscLogEventRegister("VecSwap",          VEC_CLASSID,&VEC_Swap);
148:   PetscLogEventRegister("VecOps",           VEC_CLASSID,&VEC_Ops);
149:   PetscLogEventRegister("VecAssemblyBegin", VEC_CLASSID,&VEC_AssemblyBegin);
150:   PetscLogEventRegister("VecAssemblyEnd",   VEC_CLASSID,&VEC_AssemblyEnd);
151:   PetscLogEventRegister("VecPointwiseMult", VEC_CLASSID,&VEC_PointwiseMult);
152:   PetscLogEventRegister("VecSetValues",     VEC_CLASSID,&VEC_SetValues);
153:   PetscLogEventRegister("VecLoad",          VEC_CLASSID,&VEC_Load);
154:   PetscLogEventRegister("VecScatterBarrie", VEC_CLASSID,&VEC_ScatterBarrier);
155:   PetscLogEventRegister("VecScatterBegin",  VEC_CLASSID,&VEC_ScatterBegin);
156:   PetscLogEventRegister("VecScatterEnd",    VEC_CLASSID,&VEC_ScatterEnd);
157:   PetscLogEventRegister("VecSetRandom",     VEC_CLASSID,&VEC_SetRandom);
158:   PetscLogEventRegister("VecReduceArith",   VEC_CLASSID,&VEC_ReduceArithmetic);
159:   PetscLogEventRegister("VecReduceBarrier", VEC_CLASSID,&VEC_ReduceBarrier);
160:   PetscLogEventRegister("VecReduceComm",    VEC_CLASSID,&VEC_ReduceCommunication);
161:   PetscLogEventRegister("VecNormalize",     VEC_CLASSID,&VEC_Normalize);
162: #if defined(PETSC_HAVE_CUSP)
163:   PetscLogEventRegister("VecCUSPCopyTo",     VEC_CLASSID,&VEC_CUSPCopyToGPU);
164:   PetscLogEventRegister("VecCUSPCopyFrom",   VEC_CLASSID,&VEC_CUSPCopyFromGPU);
165:   PetscLogEventRegister("VecCopyToSome",     VEC_CLASSID,&VEC_CUSPCopyToGPUSome);
166:   PetscLogEventRegister("VecCopyFromSome",   VEC_CLASSID,&VEC_CUSPCopyFromGPUSome);
167: #endif
168:   /* Turn off high traffic events by default */
169:   PetscLogEventSetActiveAll(VEC_DotBarrier, PETSC_FALSE);
170:   PetscLogEventSetActiveAll(VEC_DotNormBarrier, PETSC_FALSE);
171:   PetscLogEventSetActiveAll(VEC_MDotBarrier, PETSC_FALSE);
172:   PetscLogEventSetActiveAll(VEC_NormBarrier, PETSC_FALSE);
173:   PetscLogEventSetActiveAll(VEC_SetValues, PETSC_FALSE);
174:   PetscLogEventSetActiveAll(VEC_ScatterBarrier, PETSC_FALSE);
175:   PetscLogEventSetActiveAll(VEC_ReduceBarrier, PETSC_FALSE);
176:   /* Process info exclusions */
177:   PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);
178:   if (opt) {
179:     PetscStrstr(logList, "vec", &className);
180:     if (className) {
181:       PetscInfoDeactivateClass(VEC_CLASSID);
182:     }
183:   }
184:   /* Process summary exclusions */
185:   PetscOptionsGetString(PETSC_NULL, "-log_summary_exclude", logList, 256, &opt);
186:   if (opt) {
187:     PetscStrstr(logList, "vec", &className);
188:     if (className) {
189:       PetscLogEventDeactivateClass(VEC_CLASSID);
190:     }
191:   }
192:   /* Special processing */
193:   opt = PETSC_FALSE;
194:   PetscOptionsGetBool(PETSC_NULL, "-log_sync", &opt,PETSC_NULL);
195:   if (opt) {
196:     PetscLogEventSetActiveAll(VEC_ScatterBarrier, PETSC_TRUE);
197:     PetscLogEventSetActiveAll(VEC_NormBarrier, PETSC_TRUE);
198:     PetscLogEventSetActiveAll(VEC_DotBarrier, PETSC_TRUE);
199:     PetscLogEventSetActiveAll(VEC_DotNormBarrier, PETSC_TRUE);
200:     PetscLogEventSetActiveAll(VEC_MDotBarrier, PETSC_TRUE);
201:     PetscLogEventSetActiveAll(VEC_ReduceBarrier, PETSC_TRUE);
202:   }

204:   /*
205:     Create the special MPI reduction operation that may be used by VecNorm/DotBegin()
206:   */
207:   MPI_Op_create(PetscSplitReduction_Local,1,&PetscSplitReduction_Op);
208:   MPI_Op_create(VecMax_Local,2,&VecMax_Local_Op);
209:   MPI_Op_create(VecMin_Local,2,&VecMin_Local_Op);

211:   /* Register the different norm types for cached norms */
212:   for (i=0; i<4; i++) {
213:     PetscObjectComposedDataRegister(NormIds+i);
214:   }
215: 
216:   /* Register finalization routine */
217:   PetscRegisterFinalize(VecFinalizePackage);
218:   return(0);
219: }

223: /*@C
224:   VecFinalizePackage - This function finalizes everything in the Vec package. It is called
225:   from PetscFinalize().

227:   Level: developer

229: .keywords: Vec, initialize, package
230: .seealso: PetscInitialize()
231: @*/
232: PetscErrorCode  VecFinalizePackage(void) {
235:   MPI_Op_free(&PetscSplitReduction_Op);
236:   MPI_Op_free(&VecMax_Local_Op);
237:   MPI_Op_free(&VecMin_Local_Op);
238:   VecPackageInitialized = PETSC_FALSE;
239:   VecList               = PETSC_NULL;
240:   VecRegisterAllCalled  = PETSC_FALSE;
241:   return(0);
242: }

244: #ifdef PETSC_USE_DYNAMIC_LIBRARIES
248: /*
249:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

253:   Input Parameter:
254:   path - library path
255:  */
256: PetscErrorCode  PetscDLLibraryRegister_petscvec(const char path[])
257: {

261:   ISInitializePackage(path);
262:   VecInitializePackage(path);
263:   PFInitializePackage(path);
264:   return(0);
265: }

268: #endif /* PETSC_USE_DYNAMIC_LIBRARIES */