Actual source code: dlregisksp.c


  2: #include <petsc/private/pcimpl.h>
  3: #include <petsc/private/pcpatchimpl.h>
  4: #include <petsc/private/kspimpl.h>

  6: static const char *const PCSides_Shifted[]       = {"DEFAULT", "LEFT", "RIGHT", "SYMMETRIC", "PCSide", "PC_", NULL};
  7: const char *const *const PCSides                 = PCSides_Shifted + 1;
  8: const char *const        PCASMTypes[]            = {"NONE", "RESTRICT", "INTERPOLATE", "BASIC", "PCASMType", "PC_ASM_", NULL};
  9: const char *const        PCGASMTypes[]           = {"NONE", "RESTRICT", "INTERPOLATE", "BASIC", "PCGASMType", "PC_GASM_", NULL};
 10: const char *const        PCCompositeTypes[]      = {"ADDITIVE", "MULTIPLICATIVE", "SYMMETRIC_MULTIPLICATIVE", "SPECIAL", "SCHUR", "GKB", "PCCompositeType", "PC_COMPOSITE", NULL};
 11: const char *const        PCPARMSGlobalTypes[]    = {"RAS", "SCHUR", "BJ", "PCPARMSGlobalType", "PC_PARMS_", NULL};
 12: const char *const        PCPARMSLocalTypes[]     = {"ILU0", "ILUK", "ILUT", "ARMS", "PCPARMSLocalType", "PC_PARMS_", NULL};
 13: const char *const        PCPatchConstructTypes[] = {"star", "vanka", "pardecomp", "user", "python", "PCPatchSetConstructType", "PC_PATCH_", NULL};

 15: const char *const        PCFailedReasons_Shifted[] = {"SETUP_ERROR", "FACTOR_NOERROR", "FACTOR_STRUCT_ZEROPIVOT", "FACTOR_NUMERIC_ZEROPIVOT", "FACTOR_OUTMEMORY", "FACTOR_OTHER", "PC_INCONSISTENT_RHS", "SUBPC_ERROR", NULL};
 16: const char *const *const PCFailedReasons           = PCFailedReasons_Shifted + 1;

 18: static PetscBool PCPackageInitialized = PETSC_FALSE;
 19: /*@C
 20:   PCFinalizePackage - This function destroys everything in the `PC` package. It is
 21:   called from `PetscFinalize()`.

 23:   Level: developer

 25: .seealso: [](chapter_ksp), `PetscFinalize()`, `PCInitializePackage()`
 26: @*/
 27: PetscErrorCode PCFinalizePackage(void)
 28: {
 29:   PetscFunctionListDestroy(&PCList);
 30:   PetscFunctionListDestroy(&PCMGCoarseList);
 31:   PCPackageInitialized = PETSC_FALSE;
 32:   PCRegisterAllCalled  = PETSC_FALSE;
 33:   return 0;
 34: }

 36: /*@C
 37:   PCInitializePackage - This function initializes everything in the `PC` package. It is called
 38:   from `PetscDLLibraryRegister_petscksp()` when using dynamic libraries, and on the first call to `PCCreate()`
 39:   when using shared static libraries.

 41:   Level: developer

 43: .seealso: [](chapter_ksp), `PetscInitialize()`, `PCFinalizePackage()`
 44: @*/
 45: PetscErrorCode PCInitializePackage(void)
 46: {
 47:   char      logList[256];
 48:   PetscBool opt, pkg;

 50:   if (PCPackageInitialized) return 0;
 51:   PCPackageInitialized = PETSC_TRUE;
 52:   /* Initialize subpackages */
 53:   PCGAMGInitializePackage();
 54:   PCBDDCInitializePackage();
 55: #if defined(PETSC_HAVE_HPDDM) && defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
 56:   PCHPDDMInitializePackage();
 57: #endif
 58:   /* Register Classes */
 59:   PetscClassIdRegister("Preconditioner", &PC_CLASSID);
 60:   /* Register Constructors */
 61:   PCRegisterAll();
 62:   /* Register Events */
 63:   PetscLogEventRegister("PCSetUp", PC_CLASSID, &PC_SetUp);
 64:   PetscLogEventRegister("PCSetUpOnBlocks", PC_CLASSID, &PC_SetUpOnBlocks);
 65:   PetscLogEventRegister("PCApply", PC_CLASSID, &PC_Apply);
 66:   PetscLogEventRegister("PCMatApply", PC_CLASSID, &PC_MatApply);
 67:   PetscLogEventRegister("PCApplyOnBlocks", PC_CLASSID, &PC_ApplyOnBlocks);
 68:   PetscLogEventRegister("PCApplyCoarse", PC_CLASSID, &PC_ApplyCoarse);
 69:   PetscLogEventRegister("PCApplyMultiple", PC_CLASSID, &PC_ApplyMultiple);
 70:   PetscLogEventRegister("PCApplySymmLeft", PC_CLASSID, &PC_ApplySymmetricLeft);
 71:   PetscLogEventRegister("PCApplySymmRight", PC_CLASSID, &PC_ApplySymmetricRight);
 72:   PetscLogEventRegister("PCModifySubMatri", PC_CLASSID, &PC_ModifySubMatrices);

 74:   PetscLogEventRegister("PCPATCHCreate", PC_CLASSID, &PC_Patch_CreatePatches);
 75:   PetscLogEventRegister("PCPATCHComputeOp", PC_CLASSID, &PC_Patch_ComputeOp);
 76:   PetscLogEventRegister("PCPATCHSolve", PC_CLASSID, &PC_Patch_Solve);
 77:   PetscLogEventRegister("PCPATCHApply", PC_CLASSID, &PC_Patch_Apply);
 78:   PetscLogEventRegister("PCPATCHPrealloc", PC_CLASSID, &PC_Patch_Prealloc);

 80:   PetscLogEventRegister("KSPSolve_FS_0", KSP_CLASSID, &KSP_Solve_FS_0);
 81:   PetscLogEventRegister("KSPSolve_FS_1", KSP_CLASSID, &KSP_Solve_FS_1);
 82:   PetscLogEventRegister("KSPSolve_FS_2", KSP_CLASSID, &KSP_Solve_FS_2);
 83:   PetscLogEventRegister("KSPSolve_FS_3", KSP_CLASSID, &KSP_Solve_FS_3);
 84:   PetscLogEventRegister("KSPSolve_FS_4", KSP_CLASSID, &KSP_Solve_FS_4);
 85:   PetscLogEventRegister("KSPSolve_FS_Schu", KSP_CLASSID, &KSP_Solve_FS_S);
 86:   PetscLogEventRegister("KSPSolve_FS_Up", KSP_CLASSID, &KSP_Solve_FS_U);
 87:   PetscLogEventRegister("KSPSolve_FS_Low", KSP_CLASSID, &KSP_Solve_FS_L);

 89:   PetscLogStageRegister("PCMPI", &PCMPIStage);

 91:   /* Process Info */
 92:   {
 93:     PetscClassId classids[1];

 95:     classids[0] = PC_CLASSID;
 96:     PetscInfoProcessClass("pc", 1, classids);
 97:   }
 98:   /* Process summary exclusions */
 99:   PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt);
100:   if (opt) {
101:     PetscStrInList("pc", logList, ',', &pkg);
102:     if (pkg) PetscLogEventExcludeClass(PC_CLASSID);
103:   }
104:   /* Register data */
105:   PetscObjectComposedDataRegister(&PetscMGLevelId);
106:   /* Register package finalizer */
107:   PetscRegisterFinalize(PCFinalizePackage);
108:   return 0;
109: }

111: const char *const        KSPCGTypes[]                 = {"SYMMETRIC", "HERMITIAN", "KSPCGType", "KSP_CG_", NULL};
112: const char *const        KSPGMRESCGSRefinementTypes[] = {"REFINE_NEVER", "REFINE_IFNEEDED", "REFINE_ALWAYS", "KSPGMRESRefinementType", "KSP_GMRES_CGS_", NULL};
113: const char *const        KSPNormTypes_Shifted[]       = {"DEFAULT", "NONE", "PRECONDITIONED", "UNPRECONDITIONED", "NATURAL", "KSPNormType", "KSP_NORM_", NULL};
114: const char *const *const KSPNormTypes                 = KSPNormTypes_Shifted + 1;
115: const char *const KSPConvergedReasons_Shifted[] = {"DIVERGED_PC_FAILED", "DIVERGED_INDEFINITE_MAT", "DIVERGED_NANORINF", "DIVERGED_INDEFINITE_PC", "DIVERGED_NONSYMMETRIC", "DIVERGED_BREAKDOWN_BICG", "DIVERGED_BREAKDOWN", "DIVERGED_DTOL", "DIVERGED_ITS", "DIVERGED_NULL", "", "CONVERGED_ITERATING", "CONVERGED_RTOL_NORMAL", "CONVERGED_RTOL", "CONVERGED_ATOL", "CONVERGED_ITS", "CONVERGED_CG_NEG_CURVE", "CONVERGED_CG_CONSTRAINED", "CONVERGED_STEP_LENGTH", "CONVERGED_HAPPY_BREAKDOWN", "CONVERGED_ATOL_NORMAL", "KSPConvergedReason", "KSP_", NULL};
116: const char *const *KSPConvergedReasons     = KSPConvergedReasons_Shifted + 11;
117: const char *const  KSPFCDTruncationTypes[] = {"STANDARD", "NOTAY", "KSPFCDTruncationTypes", "KSP_FCD_TRUNC_TYPE_", NULL};

119: static PetscBool KSPPackageInitialized = PETSC_FALSE;
120: /*@C
121:   KSPFinalizePackage - This function destroys everything in the Petsc interface to the KSP package. It is
122:   called from PetscFinalize().

124:   Level: developer

126: .seealso: [](chapter_ksp), `PetscFinalize()`, `KSPInitializePackage()`
127: @*/
128: PetscErrorCode KSPFinalizePackage(void)
129: {
130:   PetscFunctionListDestroy(&KSPList);
131:   PetscFunctionListDestroy(&KSPGuessList);
132:   PetscFunctionListDestroy(&KSPMonitorList);
133:   PetscFunctionListDestroy(&KSPMonitorCreateList);
134:   PetscFunctionListDestroy(&KSPMonitorDestroyList);
135:   KSPPackageInitialized       = PETSC_FALSE;
136:   KSPRegisterAllCalled        = PETSC_FALSE;
137:   KSPMonitorRegisterAllCalled = PETSC_FALSE;
138:   return 0;
139: }

141: /*@C
142:   KSPInitializePackage - This function initializes everything in the `KSP` package. It is called
143:   from `PetscDLLibraryRegister_petscksp()` when using dynamic libraries, and on the first call to `KSPCreate()`
144:   when using shared or static libraries.

146:   Level: developer

148: .seealso: [](chapter_ksp), `PetscInitialize()`, `KSPFinalizePackage()`
149: @*/
150: PetscErrorCode KSPInitializePackage(void)
151: {
152:   char      logList[256];
153:   PetscBool opt, pkg, cls;

155:   if (KSPPackageInitialized) return 0;
156:   KSPPackageInitialized = PETSC_TRUE;
157:   /* Register Classes */
158:   PetscClassIdRegister("Krylov Solver", &KSP_CLASSID);
159:   PetscClassIdRegister("DMKSP interface", &DMKSP_CLASSID);
160:   PetscClassIdRegister("KSPGuess interface", &KSPGUESS_CLASSID);
161:   /* Register Constructors */
162:   KSPRegisterAll();
163:   /* Register matrix implementations packaged in KSP */
164:   KSPMatRegisterAll();
165:   /* Register KSP guesses implementations */
166:   KSPGuessRegisterAll();
167:   /* Register Monitors */
168:   KSPMonitorRegisterAll();
169:   /* Register Events */
170:   PetscLogEventRegister("KSPSetUp", KSP_CLASSID, &KSP_SetUp);
171:   PetscLogEventRegister("KSPSolve", KSP_CLASSID, &KSP_Solve);
172:   PetscLogEventRegister("KSPGMRESOrthog", KSP_CLASSID, &KSP_GMRESOrthogonalization);
173:   PetscLogEventRegister("KSPSolveTranspos", KSP_CLASSID, &KSP_SolveTranspose);
174:   PetscLogEventRegister("KSPMatSolve", KSP_CLASSID, &KSP_MatSolve);
175:   /* Process Info */
176:   {
177:     PetscClassId classids[3];

179:     classids[0] = KSP_CLASSID;
180:     classids[1] = DMKSP_CLASSID;
181:     classids[2] = KSPGUESS_CLASSID;
182:     PetscInfoProcessClass("ksp", 1, &classids[0]);
183:     PetscInfoProcessClass("dm", 1, &classids[1]);
184:     PetscInfoProcessClass("kspguess", 1, &classids[2]);
185:   }
186:   /* Process summary exclusions */
187:   PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt);
188:   if (opt) {
189:     PetscStrInList("ksp", logList, ',', &pkg);
190:     if (pkg) PetscLogEventExcludeClass(KSP_CLASSID);
191:     PetscStrInList("dm", logList, ',', &cls);
192:     if (pkg || cls) PetscLogEventExcludeClass(DMKSP_CLASSID);
193:     PetscStrInList("kspguess", logList, ',', &cls);
194:     if (pkg || cls) PetscLogEventExcludeClass(KSPGUESS_CLASSID);
195:   }
196:   /* Register package finalizer */
197:   PetscRegisterFinalize(KSPFinalizePackage);
198:   return 0;
199: }

201: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)

203: /*
204:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

206:   This one registers all the `KSP` and `PC` methods that are in the basic PETSc libpetscksp library.
207:  */
208: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscksp(void)
209: {
210:   PCInitializePackage();
211:   KSPInitializePackage();
212:   return 0;
213: }

215: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */