LCOV - code coverage report
Current view: | top level - Include/internal - pycore_pystate.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 27 | 28 | 96.4 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 10 | 10 | 100.0 %
|  |  | Branches: | 7 | 14 | 50.0 %

               Branch data     Line data    Source code
           1                 :            : #ifndef Py_INTERNAL_PYSTATE_H
           2                 :            : #define Py_INTERNAL_PYSTATE_H
           3                 :            : #ifdef __cplusplus
           4                 :            : extern "C" {
           5                 :            : #endif
           6                 :            :
           7                 :            : #ifndef Py_BUILD_CORE
           8                 :            : #  error "this header requires Py_BUILD_CORE define"
           9                 :            : #endif
          10                 :            :
          11                 :            : #include "pycore_runtime.h"   /* PyRuntimeState */
          12                 :            :
          13                 :            :
          14                 :            : /* Check if the current thread is the main thread.
          15                 :            :    Use _Py_IsMainInterpreter() to check if it's the main interpreter. */
          16                 :            : static inline int
          17                 :    4802668 : _Py_IsMainThread(void)
          18                 :            : {
          19                 :    4802668 :     unsigned long thread = PyThread_get_thread_ident();
          20                 :    4802668 :     return (thread == _PyRuntime.main_thread);
          21                 :            : }
          22                 :            :
          23                 :            :
          24                 :            : static inline PyInterpreterState *
          25                 :    4803622 : _PyInterpreterState_Main(void)
          26                 :            : {
          27                 :    4803622 :     return _PyRuntime.interpreters.main;
          28                 :            : }
          29                 :            :
          30                 :            : static inline int
          31                 :    4803622 : _Py_IsMainInterpreter(PyInterpreterState *interp)
          32                 :            : {
          33                 :    4803622 :     return (interp == _PyInterpreterState_Main());
          34                 :            : }
          35                 :            :
          36                 :            :
          37                 :            : static inline const PyConfig *
          38                 :            : _Py_GetMainConfig(void)
          39                 :            : {
          40                 :            :     PyInterpreterState *interp = _PyInterpreterState_Main();
          41                 :            :     if (interp == NULL) {
          42                 :            :         return NULL;
          43                 :            :     }
          44                 :            :     return _PyInterpreterState_GetConfig(interp);
          45                 :            : }
          46                 :            :
          47                 :            :
          48                 :            : /* Only handle signals on the main thread of the main interpreter. */
          49                 :            : static inline int
          50                 :    4802646 : _Py_ThreadCanHandleSignals(PyInterpreterState *interp)
          51                 :            : {
          52   [ +  -  +  - ]:    4802646 :     return (_Py_IsMainThread() && _Py_IsMainInterpreter(interp));
          53                 :            : }
          54                 :            :
          55                 :            :
          56                 :            : /* Only execute pending calls on the main thread. */
          57                 :            : static inline int
          58                 :         22 : _Py_ThreadCanHandlePendingCalls(void)
          59                 :            : {
          60                 :         22 :     return _Py_IsMainThread();
          61                 :            : }
          62                 :            :
          63                 :            :
          64                 :            : /* Variable and macro for in-line access to current thread
          65                 :            :    and interpreter state */
          66                 :            :
          67                 :            : static inline PyThreadState*
          68                 :  102394867 : _PyRuntimeState_GetThreadState(_PyRuntimeState *runtime)
          69                 :            : {
          70                 :  102394867 :     return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);
          71                 :            : }
          72                 :            :
          73                 :            : /* Get the current Python thread state.
          74                 :            :
          75                 :            :    Efficient macro reading directly the 'tstate_current' atomic
          76                 :            :    variable. The macro is unsafe: it does not check for error and it can
          77                 :            :    return NULL.
          78                 :            :
          79                 :            :    The caller must hold the GIL.
          80                 :            :
          81                 :            :    See also PyThreadState_Get() and _PyThreadState_UncheckedGet(). */
          82                 :            : static inline PyThreadState*
          83                 :  102394842 : _PyThreadState_GET(void)
          84                 :            : {
          85                 :  102394842 :     return _PyRuntimeState_GetThreadState(&_PyRuntime);
          86                 :            : }
          87                 :            :
          88                 :            : static inline void
          89                 :    1870115 : _Py_EnsureFuncTstateNotNULL(const char *func, PyThreadState *tstate)
          90                 :            : {
          91         [ -  + ]:    1870115 :     if (tstate == NULL) {
          92                 :          0 :         _Py_FatalErrorFunc(func,
          93                 :            :             "the function must be called with the GIL held, "
          94                 :            :             "after Python initialization and before Python finalization, "
          95                 :            :             "but the GIL is released (the current Python thread state is NULL)");
          96                 :            :     }
          97                 :    1870115 : }
          98                 :            :
          99                 :            : // Call Py_FatalError() if tstate is NULL
         100                 :            : #define _Py_EnsureTstateNotNULL(tstate) \
         101                 :            :     _Py_EnsureFuncTstateNotNULL(__func__, (tstate))
         102                 :            :
         103                 :            :
         104                 :            : /* Get the current interpreter state.
         105                 :            :
         106                 :            :    The macro is unsafe: it does not check for error and it can return NULL.
         107                 :            :
         108                 :            :    The caller must hold the GIL.
         109                 :            :
         110                 :            :    See also _PyInterpreterState_Get()
         111                 :            :    and _PyGILState_GetInterpreterStateUnsafe(). */
         112                 :   55157887 : static inline PyInterpreterState* _PyInterpreterState_GET(void) {
         113                 :   55157887 :     PyThreadState *tstate = _PyThreadState_GET();
         114                 :            : #ifdef Py_DEBUG
         115                 :            :     _Py_EnsureTstateNotNULL(tstate);
         116                 :            : #endif
         117                 :   55157887 :     return tstate->interp;
         118                 :            : }
         119                 :            :
         120                 :            :
         121                 :            : // PyThreadState functions
         122                 :            :
         123                 :            : PyAPI_FUNC(PyThreadState *) _PyThreadState_New(PyInterpreterState *interp);
         124                 :            : PyAPI_FUNC(void) _PyThreadState_Bind(PyThreadState *tstate);
         125                 :            : // We keep this around exclusively for stable ABI compatibility.
         126                 :            : PyAPI_FUNC(void) _PyThreadState_Init(
         127                 :            :     PyThreadState *tstate);
         128                 :            : PyAPI_FUNC(void) _PyThreadState_DeleteExcept(PyThreadState *tstate);
         129                 :            :
         130                 :            :
         131                 :            : static inline void
         132                 :        638 : _PyThreadState_UpdateTracingState(PyThreadState *tstate)
         133                 :            : {
         134                 :        638 :     bool use_tracing =
         135         [ +  - ]:       1276 :         (tstate->tracing == 0) &&
         136   [ +  -  -  + ]:        638 :         (tstate->c_tracefunc != NULL || tstate->c_profilefunc != NULL);
         137         [ -  + ]:        638 :     tstate->cframe->use_tracing = (use_tracing ? 255 : 0);
         138                 :        638 : }
         139                 :            :
         140                 :            :
         141                 :            : /* Other */
         142                 :            :
         143                 :            : PyAPI_FUNC(PyThreadState *) _PyThreadState_Swap(
         144                 :            :     _PyRuntimeState *runtime,
         145                 :            :     PyThreadState *newts);
         146                 :            :
         147                 :            : PyAPI_FUNC(PyStatus) _PyInterpreterState_Enable(_PyRuntimeState *runtime);
         148                 :            :
         149                 :            : #ifdef HAVE_FORK
         150                 :            : extern PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime);
         151                 :            : extern void _PySignal_AfterFork(void);
         152                 :            : #endif
         153                 :            :
         154                 :            :
         155                 :            : PyAPI_FUNC(int) _PyState_AddModule(
         156                 :            :     PyThreadState *tstate,
         157                 :            :     PyObject* module,
         158                 :            :     PyModuleDef* def);
         159                 :            :
         160                 :            :
         161                 :            : PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState *tstate);
         162                 :            :
         163                 :            : #define HEAD_LOCK(runtime) \
         164                 :            :     PyThread_acquire_lock((runtime)->interpreters.mutex, WAIT_LOCK)
         165                 :            : #define HEAD_UNLOCK(runtime) \
         166                 :            :     PyThread_release_lock((runtime)->interpreters.mutex)
         167                 :            :
         168                 :            :
         169                 :            : #ifdef __cplusplus
         170                 :            : }
         171                 :            : #endif
         172                 :            : #endif /* !Py_INTERNAL_PYSTATE_H */

Generated by: LCOV version 1.14