1 #include <petsc/private/petscimpl.h> /*I "petscsys.h" I*/ 2 3 /* ---------------------------------------------------------------- */ 4 5 #if !defined(PETSC_PYTHON_EXE) 6 #define PETSC_PYTHON_EXE "python" 7 #endif 8 9 static PetscErrorCode PetscPythonFindExecutable(char pythonexe[], size_t len) 10 { 11 PetscBool flag; 12 13 PetscFunctionBegin; 14 /* get the path for the Python interpreter executable */ 15 PetscCall(PetscStrncpy(pythonexe, PETSC_PYTHON_EXE, len)); 16 PetscCall(PetscOptionsGetString(NULL, NULL, "-python", pythonexe, len, &flag)); 17 if (!flag || pythonexe[0] == 0) PetscCall(PetscStrncpy(pythonexe, PETSC_PYTHON_EXE, len)); 18 PetscFunctionReturn(PETSC_SUCCESS); 19 } 20 21 /* 22 Python does not appear to have a universal way to indicate the location of Python dynamic library so try several possibilities 23 */ 24 static PetscErrorCode PetscPythonFindLibraryName(const char pythonexe[], const char attempt[], char pythonlib[], size_t pl, PetscBool *found) 25 { 26 char command[2 * PETSC_MAX_PATH_LEN]; 27 FILE *fp = NULL; 28 char *eol = NULL; 29 30 PetscFunctionBegin; 31 /* call Python to find out the name of the Python dynamic library */ 32 PetscCall(PetscStrncpy(command, pythonexe, sizeof(command))); 33 PetscCall(PetscStrlcat(command, " ", sizeof(command))); 34 PetscCall(PetscStrlcat(command, attempt, sizeof(command))); 35 #if defined(PETSC_HAVE_POPEN) 36 PetscCall(PetscPOpen(PETSC_COMM_SELF, NULL, command, "r", &fp)); 37 PetscCheck(fgets(pythonlib, pl, fp), PETSC_COMM_SELF, PETSC_ERR_PLIB, "Python: bad output from executable: %s\nRunning: %s", pythonexe, command); 38 PetscCall(PetscPClose(PETSC_COMM_SELF, fp)); 39 #else 40 SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: Aborted due to missing popen()"); 41 #endif 42 /* remove newlines */ 43 PetscCall(PetscStrchr(pythonlib, '\n', &eol)); 44 if (eol) eol[0] = 0; 45 PetscCall(PetscTestFile(pythonlib, 'r', found)); 46 PetscFunctionReturn(PETSC_SUCCESS); 47 } 48 49 static PetscErrorCode PetscPythonFindLibrary(const char pythonexe[], char pythonlib[], size_t pl) 50 { 51 const char cmdline1[] = "-c 'import os, sysconfig; print(os.path.join(sysconfig.get_config_var(\"LIBDIR\"),sysconfig.get_config_var(\"LDLIBRARY\")))'"; 52 const char cmdline2[] = "-c 'import os, sysconfig; print(os.path.join(sysconfig.get_path(\"stdlib\"),os.path.pardir,\"libpython\"+sysconfig.get_python_version()+\".dylib\"))'"; 53 const char cmdline3[] = "-c 'import os, sysconfig; print(os.path.join(sysconfig.get_config_var(\"LIBPL\"),sysconfig.get_config_var(\"LDLIBRARY\")))'"; 54 const char cmdline4[] = "-c 'import sysconfig; print(sysconfig.get_config_var(\"LIBPYTHON\"))'"; 55 const char cmdline5[] = "-c 'import os, sysconfig; import sys;print(os.path.join(sysconfig.get_config_var(\"LIBDIR\"),\"libpython\"+sys.version[:3]+\".so\"))'"; 56 57 PetscBool found = PETSC_FALSE; 58 59 PetscFunctionBegin; 60 #if defined(PETSC_PYTHON_LIB) 61 PetscCall(PetscStrncpy(pythonlib, PETSC_PYTHON_LIB, pl)); 62 PetscFunctionReturn(PETSC_SUCCESS); 63 #endif 64 65 PetscCall(PetscPythonFindLibraryName(pythonexe, cmdline1, pythonlib, pl, &found)); 66 if (!found) PetscCall(PetscPythonFindLibraryName(pythonexe, cmdline2, pythonlib, pl, &found)); 67 if (!found) PetscCall(PetscPythonFindLibraryName(pythonexe, cmdline3, pythonlib, pl, &found)); 68 if (!found) PetscCall(PetscPythonFindLibraryName(pythonexe, cmdline4, pythonlib, pl, &found)); 69 if (!found) PetscCall(PetscPythonFindLibraryName(pythonexe, cmdline5, pythonlib, pl, &found)); 70 PetscCall(PetscInfo(NULL, "Python library %s found %d\n", pythonlib, found)); 71 PetscFunctionReturn(PETSC_SUCCESS); 72 } 73 74 /* ---------------------------------------------------------------- */ 75 76 typedef struct _Py_object_t PyObject; /* fake definition */ 77 78 static PyObject *Py_None = NULL; 79 80 static const char *(*Py_GetVersion)(void); 81 82 static int (*Py_IsInitialized)(void); 83 static void (*Py_InitializeEx)(int); 84 static void (*Py_Finalize)(void); 85 86 static void (*PySys_SetArgv)(int, void *); 87 static PyObject *(*PySys_GetObject)(const char *); 88 static PyObject *(*PyObject_CallMethod)(PyObject *, const char *, const char *, ...); 89 static PyObject *(*PyImport_ImportModule)(const char *); 90 91 static void (*Py_IncRef)(PyObject *); 92 static void (*Py_DecRef)(PyObject *); 93 94 static void (*PyErr_Clear)(void); 95 static PyObject *(*PyErr_Occurred)(void); 96 static void (*PyErr_Fetch)(PyObject **, PyObject **, PyObject **); 97 static void (*PyErr_NormalizeException)(PyObject **, PyObject **, PyObject **); 98 static void (*PyErr_Display)(PyObject *, PyObject *, PyObject *); 99 static void (*PyErr_Restore)(PyObject *, PyObject *, PyObject *); 100 101 #define PetscDLPyLibOpen(libname) PetscDLLibraryAppend(PETSC_COMM_SELF, &PetscDLLibrariesLoaded, libname) 102 #define PetscDLPyLibSym(symbol, value) PetscDLLibrarySym(PETSC_COMM_SELF, &PetscDLLibrariesLoaded, NULL, symbol, (void **)value) 103 #define PetscDLPyLibClose(comm) \ 104 do { \ 105 } while (0) 106 107 static PetscErrorCode PetscPythonLoadLibrary(const char pythonlib[]) 108 { 109 PetscFunctionBegin; 110 /* open the Python dynamic library */ 111 PetscCall(PetscDLPyLibOpen(pythonlib)); 112 PetscCall(PetscInfo(NULL, "Python: loaded dynamic library %s\n", pythonlib)); 113 /* look required symbols from the Python C-API */ 114 PetscCall(PetscDLPyLibSym("_Py_NoneStruct", &Py_None)); 115 PetscCall(PetscDLPyLibSym("Py_GetVersion", &Py_GetVersion)); 116 PetscCall(PetscDLPyLibSym("Py_IsInitialized", &Py_IsInitialized)); 117 PetscCall(PetscDLPyLibSym("Py_InitializeEx", &Py_InitializeEx)); 118 PetscCall(PetscDLPyLibSym("Py_Finalize", &Py_Finalize)); 119 PetscCall(PetscDLPyLibSym("PySys_GetObject", &PySys_GetObject)); 120 PetscCall(PetscDLPyLibSym("PySys_SetArgv", &PySys_SetArgv)); 121 PetscCall(PetscDLPyLibSym("PyObject_CallMethod", &PyObject_CallMethod)); 122 PetscCall(PetscDLPyLibSym("PyImport_ImportModule", &PyImport_ImportModule)); 123 PetscCall(PetscDLPyLibSym("Py_IncRef", &Py_IncRef)); 124 PetscCall(PetscDLPyLibSym("Py_DecRef", &Py_DecRef)); 125 PetscCall(PetscDLPyLibSym("PyErr_Clear", &PyErr_Clear)); 126 PetscCall(PetscDLPyLibSym("PyErr_Occurred", &PyErr_Occurred)); 127 PetscCall(PetscDLPyLibSym("PyErr_Fetch", &PyErr_Fetch)); 128 PetscCall(PetscDLPyLibSym("PyErr_NormalizeException", &PyErr_NormalizeException)); 129 PetscCall(PetscDLPyLibSym("PyErr_Display", &PyErr_Display)); 130 PetscCall(PetscDLPyLibSym("PyErr_Restore", &PyErr_Restore)); 131 /* XXX TODO: check that ALL symbols were there !!! */ 132 PetscCheck(Py_None, PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: failed to load symbols from Python dynamic library %s", pythonlib); 133 PetscCheck(Py_GetVersion, PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: failed to load symbols from Python dynamic library %s", pythonlib); 134 PetscCheck(Py_IsInitialized, PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: failed to load symbols from Python dynamic library %s", pythonlib); 135 PetscCheck(Py_InitializeEx, PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: failed to load symbols from Python dynamic library %s", pythonlib); 136 PetscCheck(Py_Finalize, PETSC_COMM_SELF, PETSC_ERR_LIB, "Python: failed to load symbols from Python dynamic library %s", pythonlib); 137 PetscCall(PetscInfo(NULL, "Python: all required symbols loaded from Python dynamic library %s\n", pythonlib)); 138 PetscFunctionReturn(PETSC_SUCCESS); 139 } 140 141 /* ---------------------------------------------------------------- */ 142 143 static char PetscPythonExe[PETSC_MAX_PATH_LEN] = {0}; 144 static char PetscPythonLib[PETSC_MAX_PATH_LEN] = {0}; 145 static PetscBool PetscBeganPython = PETSC_FALSE; 146 147 /*@C 148 PetscPythonFinalize - Finalize PETSc for use with Python. 149 150 Level: intermediate 151 152 .seealso: `PetscPythonInitialize()`, `PetscPythonPrintError()` 153 @*/ 154 PetscErrorCode PetscPythonFinalize(void) 155 { 156 PetscFunctionBegin; 157 if (PetscBeganPython) { 158 if (Py_IsInitialized()) Py_Finalize(); 159 } 160 PetscBeganPython = PETSC_FALSE; 161 PetscFunctionReturn(PETSC_SUCCESS); 162 } 163 164 /*@C 165 PetscPythonInitialize - Initialize Python for use with PETSc and import petsc4py. 166 167 Input Parameters: 168 + pyexe - path to the Python interpreter executable, or NULL. 169 - pylib - full path to the Python dynamic library, or NULL. 170 171 Level: intermediate 172 173 .seealso: `PetscPythonFinalize()`, `PetscPythonPrintError()` 174 @*/ 175 PetscErrorCode PetscPythonInitialize(const char pyexe[], const char pylib[]) 176 { 177 PyObject *module = NULL; 178 179 PetscFunctionBegin; 180 if (PetscBeganPython) PetscFunctionReturn(PETSC_SUCCESS); 181 /* Python executable */ 182 if (pyexe && pyexe[0] != 0) { 183 PetscCall(PetscStrncpy(PetscPythonExe, pyexe, sizeof(PetscPythonExe))); 184 } else { 185 PetscCall(PetscPythonFindExecutable(PetscPythonExe, sizeof(PetscPythonExe))); 186 } 187 /* Python dynamic library */ 188 if (pylib && pylib[0] != 0) { 189 PetscCall(PetscStrncpy(PetscPythonLib, pylib, sizeof(PetscPythonLib))); 190 } else { 191 PetscCall(PetscPythonFindLibrary(PetscPythonExe, PetscPythonLib, sizeof(PetscPythonLib))); 192 } 193 /* dynamically load Python library */ 194 PetscCall(PetscPythonLoadLibrary(PetscPythonLib)); 195 /* initialize Python */ 196 PetscBeganPython = PETSC_FALSE; 197 if (!Py_IsInitialized()) { 198 static PetscBool registered = PETSC_FALSE; 199 const char *py_version; 200 PyObject *sys_path; 201 char path[PETSC_MAX_PATH_LEN] = {0}; 202 203 /* initialize Python. Py_InitializeEx() prints an error and EXITS the program if it is not successful! */ 204 PetscCall(PetscInfo(NULL, "Calling Py_InitializeEx(0);\n")); 205 Py_InitializeEx(0); /* 0: do not install signal handlers */ 206 PetscCall(PetscInfo(NULL, "Py_InitializeEx(0) called successfully;\n")); 207 208 /* build 'sys.argv' list */ 209 py_version = Py_GetVersion(); 210 if (py_version[0] == '2') { 211 int argc = 0; 212 char *argv[1] = {NULL}; 213 PySys_SetArgv(argc, argv); 214 } 215 if (py_version[0] == '3') { 216 int argc = 0; 217 wchar_t *argv[1] = {NULL}; 218 PySys_SetArgv(argc, argv); 219 } 220 /* add PETSC_LIB_DIR in front of 'sys.path' */ 221 sys_path = PySys_GetObject("path"); 222 if (sys_path) { 223 PetscCall(PetscStrreplace(PETSC_COMM_SELF, "${PETSC_LIB_DIR}", path, sizeof(path))); 224 Py_DecRef(PyObject_CallMethod(sys_path, "insert", "is", (int)0, (char *)path)); 225 #if defined(PETSC_PETSC4PY_INSTALL_PATH) 226 { 227 char *rpath; 228 PetscCall(PetscStrallocpy(PETSC_PETSC4PY_INSTALL_PATH, &rpath)); 229 Py_DecRef(PyObject_CallMethod(sys_path, "insert", "is", (int)0, rpath)); 230 PetscCall(PetscFree(rpath)); 231 } 232 #endif 233 } 234 /* register finalizer */ 235 if (!registered) { 236 PetscCall(PetscRegisterFinalize(PetscPythonFinalize)); 237 registered = PETSC_TRUE; 238 } 239 PetscBeganPython = PETSC_TRUE; 240 PetscCall(PetscInfo(NULL, "Python initialize completed.\n")); 241 } 242 /* import 'petsc4py.PETSc' module */ 243 module = PyImport_ImportModule("petsc4py.PETSc"); 244 if (module) { 245 PetscCall(PetscInfo(NULL, "Python: successfully imported module 'petsc4py.PETSc'\n")); 246 Py_DecRef(module); 247 module = NULL; 248 } else { 249 PetscCall(PetscPythonPrintError()); 250 SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Python: could not import module 'petsc4py.PETSc', perhaps your PYTHONPATH does not contain it"); 251 } 252 PetscFunctionReturn(PETSC_SUCCESS); 253 } 254 255 /*@C 256 PetscPythonPrintError - Print any current Python errors. 257 258 Level: developer 259 260 .seealso: `PetscPythonInitialize()`, `PetscPythonFinalize()` 261 @*/ 262 PetscErrorCode PetscPythonPrintError(void) 263 { 264 PyObject *exc = NULL, *val = NULL, *tb = NULL; 265 266 PetscFunctionBegin; 267 if (!PetscBeganPython) PetscFunctionReturn(PETSC_SUCCESS); 268 if (!PyErr_Occurred()) PetscFunctionReturn(PETSC_SUCCESS); 269 PyErr_Fetch(&exc, &val, &tb); 270 PyErr_NormalizeException(&exc, &val, &tb); 271 PyErr_Display(exc ? exc : Py_None, val ? val : Py_None, tb ? tb : Py_None); 272 PyErr_Restore(exc, val, tb); 273 PetscFunctionReturn(PETSC_SUCCESS); 274 } 275 276 /* ---------------------------------------------------------------- */ 277 278 PETSC_EXTERN PetscErrorCode (*PetscPythonMonitorSet_C)(PetscObject, const char[]); 279 PetscErrorCode (*PetscPythonMonitorSet_C)(PetscObject, const char[]) = NULL; 280 281 /*@C 282 PetscPythonMonitorSet - Set a Python monitor for a `PetscObject` 283 284 Level: developer 285 286 .seealso: `PetscPythonInitialize()`, `PetscPythonFinalize()`, `PetscPythonPrintError()` 287 @*/ 288 PetscErrorCode PetscPythonMonitorSet(PetscObject obj, const char url[]) 289 { 290 PetscFunctionBegin; 291 PetscValidHeader(obj, 1); 292 PetscValidCharPointer(url, 2); 293 if (!PetscPythonMonitorSet_C) { 294 PetscCall(PetscPythonInitialize(NULL, NULL)); 295 PetscCheck(PetscPythonMonitorSet_C, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Couldn't initialize Python support for monitors"); 296 } 297 PetscCall(PetscPythonMonitorSet_C(obj, url)); 298 PetscFunctionReturn(PETSC_SUCCESS); 299 } 300 301 /* ---------------------------------------------------------------- */ 302