Actual source code: dlregisvec.c

petsc-3.3-p7 2013-05-11
  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: }

 79: extern MPI_Op PetscSplitReduction_Op;
 80: extern MPI_Op VecMax_Local_Op;
 81: extern MPI_Op VecMin_Local_Op;

 83: EXTERN_C_BEGIN
 84: extern void  MPIAPI VecMax_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);
 85: extern void  MPIAPI VecMin_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);
 86: extern void  MPIAPI PetscSplitReduction_Local(void*,void*,PetscMPIInt*,MPI_Datatype*);
 87: EXTERN_C_END

 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); /* must follow barrier */
161:   PetscLogEventRegister("VecReduceBegin",   VEC_CLASSID,&VEC_ReduceBegin);
162:   PetscLogEventRegister("VecReduceEnd",     VEC_CLASSID,&VEC_ReduceEnd);
163:   PetscLogEventRegister("VecNormalize",     VEC_CLASSID,&VEC_Normalize);
164: #if defined(PETSC_HAVE_CUSP)
165:   PetscLogEventRegister("VecCUSPCopyTo",     VEC_CLASSID,&VEC_CUSPCopyToGPU);
166:   PetscLogEventRegister("VecCUSPCopyFrom",   VEC_CLASSID,&VEC_CUSPCopyFromGPU);
167:   PetscLogEventRegister("VecCopyToSome",     VEC_CLASSID,&VEC_CUSPCopyToGPUSome);
168:   PetscLogEventRegister("VecCopyFromSome",   VEC_CLASSID,&VEC_CUSPCopyFromGPUSome);
169: #endif
170:   /* Turn off high traffic events by default */
171:   PetscLogEventSetActiveAll(VEC_DotBarrier, PETSC_FALSE);
172:   PetscLogEventSetActiveAll(VEC_DotNormBarrier, PETSC_FALSE);
173:   PetscLogEventSetActiveAll(VEC_MDotBarrier, PETSC_FALSE);
174:   PetscLogEventSetActiveAll(VEC_NormBarrier, PETSC_FALSE);
175:   PetscLogEventSetActiveAll(VEC_SetValues, PETSC_FALSE);
176:   PetscLogEventSetActiveAll(VEC_ScatterBarrier, PETSC_FALSE);
177:   PetscLogEventSetActiveAll(VEC_ReduceBarrier, PETSC_FALSE);
178:   /* Process info exclusions */
179:   PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);
180:   if (opt) {
181:     PetscStrstr(logList, "vec", &className);
182:     if (className) {
183:       PetscInfoDeactivateClass(VEC_CLASSID);
184:     }
185:   }
186:   /* Process summary exclusions */
187:   PetscOptionsGetString(PETSC_NULL, "-log_summary_exclude", logList, 256, &opt);
188:   if (opt) {
189:     PetscStrstr(logList, "vec", &className);
190:     if (className) {
191:       PetscLogEventDeactivateClass(VEC_CLASSID);
192:     }
193:   }
194:   /* Special processing */
195:   opt = PETSC_FALSE;
196:   PetscOptionsGetBool(PETSC_NULL, "-log_sync", &opt,PETSC_NULL);
197:   if (opt) {
198:     PetscLogEventSetActiveAll(VEC_ScatterBarrier, PETSC_TRUE);
199:     PetscLogEventSetActiveAll(VEC_NormBarrier, PETSC_TRUE);
200:     PetscLogEventSetActiveAll(VEC_DotBarrier, PETSC_TRUE);
201:     PetscLogEventSetActiveAll(VEC_DotNormBarrier, PETSC_TRUE);
202:     PetscLogEventSetActiveAll(VEC_MDotBarrier, PETSC_TRUE);
203:     PetscLogEventSetActiveAll(VEC_ReduceBarrier, PETSC_TRUE);
204:   }

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

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

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

229:   Level: developer

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

246: #ifdef PETSC_USE_DYNAMIC_LIBRARIES
247: EXTERN_C_BEGIN
250: /*
251:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

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

263:   ISInitializePackage(path);
264:   VecInitializePackage(path);
265:   PFInitializePackage(path);
266:   return(0);
267: }
268: EXTERN_C_END

270: #endif /* PETSC_USE_DYNAMIC_LIBRARIES */