LCOV - code coverage report
Current view: top level - Include/internal - pycore_runtime.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 5 5 100.0 %
Date: 2023-03-20 08:15:36 Functions: 2 2 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : #ifndef Py_INTERNAL_RUNTIME_H
       2                 :            : #define Py_INTERNAL_RUNTIME_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_atomic.h"          /* _Py_atomic_address */
      12                 :            : #include "pycore_ceval_state.h"     // struct _ceval_runtime_state
      13                 :            : #include "pycore_floatobject.h"     // struct _Py_float_runtime_state
      14                 :            : #include "pycore_faulthandler.h"    // struct _faulthandler_runtime_state
      15                 :            : #include "pycore_global_objects.h"  // struct _Py_global_objects
      16                 :            : #include "pycore_import.h"          // struct _import_runtime_state
      17                 :            : #include "pycore_interp.h"          // PyInterpreterState
      18                 :            : #include "pycore_parser.h"          // struct _parser_runtime_state
      19                 :            : #include "pycore_pymem.h"           // struct _pymem_allocators
      20                 :            : #include "pycore_pyhash.h"          // struct pyhash_runtime_state
      21                 :            : #include "pycore_pythread.h"        // struct _pythread_runtime_state
      22                 :            : #include "pycore_obmalloc.h"        // struct obmalloc_state
      23                 :            : #include "pycore_signal.h"          // struct _signals_runtime_state
      24                 :            : #include "pycore_time.h"            // struct _time_runtime_state
      25                 :            : #include "pycore_tracemalloc.h"     // struct _tracemalloc_runtime_state
      26                 :            : #include "pycore_unicodeobject.h"   // struct _Py_unicode_runtime_ids
      27                 :            : 
      28                 :            : struct _getargs_runtime_state {
      29                 :            :     PyThread_type_lock mutex;
      30                 :            :     struct _PyArg_Parser *static_parsers;
      31                 :            : };
      32                 :            : 
      33                 :            : /* ceval state */
      34                 :            : 
      35                 :            : /* GIL state */
      36                 :            : 
      37                 :            : struct _gilstate_runtime_state {
      38                 :            :     /* bpo-26558: Flag to disable PyGILState_Check().
      39                 :            :        If set to non-zero, PyGILState_Check() always return 1. */
      40                 :            :     int check_enabled;
      41                 :            :     /* The single PyInterpreterState used by this process'
      42                 :            :        GILState implementation
      43                 :            :     */
      44                 :            :     /* TODO: Given interp_main, it may be possible to kill this ref */
      45                 :            :     PyInterpreterState *autoInterpreterState;
      46                 :            : };
      47                 :            : 
      48                 :            : /* Runtime audit hook state */
      49                 :            : 
      50                 :            : typedef struct _Py_AuditHookEntry {
      51                 :            :     struct _Py_AuditHookEntry *next;
      52                 :            :     Py_AuditHookFunction hookCFunction;
      53                 :            :     void *userData;
      54                 :            : } _Py_AuditHookEntry;
      55                 :            : 
      56                 :            : /* Full Python runtime state */
      57                 :            : 
      58                 :            : /* _PyRuntimeState holds the global state for the CPython runtime.
      59                 :            :    That data is exposed in the internal API as a static variable (_PyRuntime).
      60                 :            :    */
      61                 :            : typedef struct pyruntimestate {
      62                 :            :     /* Has been initialized to a safe state.
      63                 :            : 
      64                 :            :        In order to be effective, this must be set to 0 during or right
      65                 :            :        after allocation. */
      66                 :            :     int _initialized;
      67                 :            : 
      68                 :            :     /* Is running Py_PreInitialize()? */
      69                 :            :     int preinitializing;
      70                 :            : 
      71                 :            :     /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */
      72                 :            :     int preinitialized;
      73                 :            : 
      74                 :            :     /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */
      75                 :            :     int core_initialized;
      76                 :            : 
      77                 :            :     /* Is Python fully initialized? Set to 1 by Py_Initialize() */
      78                 :            :     int initialized;
      79                 :            : 
      80                 :            :     /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize()
      81                 :            :        is called again.
      82                 :            : 
      83                 :            :        Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing()
      84                 :            :        to access it, don't access it directly. */
      85                 :            :     _Py_atomic_address _finalizing;
      86                 :            : 
      87                 :            :     struct _pymem_allocators allocators;
      88                 :            :     struct _obmalloc_state obmalloc;
      89                 :            :     struct pyhash_runtime_state pyhash_state;
      90                 :            :     struct _time_runtime_state time;
      91                 :            :     struct _pythread_runtime_state threads;
      92                 :            :     struct _signals_runtime_state signals;
      93                 :            : 
      94                 :            :     struct pyinterpreters {
      95                 :            :         PyThread_type_lock mutex;
      96                 :            :         /* The linked list of interpreters, newest first. */
      97                 :            :         PyInterpreterState *head;
      98                 :            :         /* The runtime's initial interpreter, which has a special role
      99                 :            :            in the operation of the runtime.  It is also often the only
     100                 :            :            interpreter. */
     101                 :            :         PyInterpreterState *main;
     102                 :            :         /* next_id is an auto-numbered sequence of small
     103                 :            :            integers.  It gets initialized in _PyInterpreterState_Enable(),
     104                 :            :            which is called in Py_Initialize(), and used in
     105                 :            :            PyInterpreterState_New().  A negative interpreter ID
     106                 :            :            indicates an error occurred.  The main interpreter will
     107                 :            :            always have an ID of 0.  Overflow results in a RuntimeError.
     108                 :            :            If that becomes a problem later then we can adjust, e.g. by
     109                 :            :            using a Python int. */
     110                 :            :         int64_t next_id;
     111                 :            :     } interpreters;
     112                 :            :     // XXX Remove this field once we have a tp_* slot.
     113                 :            :     struct _xidregistry {
     114                 :            :         PyThread_type_lock mutex;
     115                 :            :         struct _xidregitem *head;
     116                 :            :     } xidregistry;
     117                 :            : 
     118                 :            :     unsigned long main_thread;
     119                 :            : 
     120                 :            :     /* Assuming the current thread holds the GIL, this is the
     121                 :            :        PyThreadState for the current thread. */
     122                 :            :     _Py_atomic_address tstate_current;
     123                 :            :     /* Used for the thread state bound to the current thread. */
     124                 :            :     Py_tss_t autoTSSkey;
     125                 :            : 
     126                 :            :     /* Used instead of PyThreadState.trash when there is not current tstate. */
     127                 :            :     Py_tss_t trashTSSkey;
     128                 :            : 
     129                 :            :     PyWideStringList orig_argv;
     130                 :            : 
     131                 :            :     struct _parser_runtime_state parser;
     132                 :            : 
     133                 :            : #define NEXITFUNCS 32
     134                 :            :     void (*exitfuncs[NEXITFUNCS])(void);
     135                 :            :     int nexitfuncs;
     136                 :            : 
     137                 :            :     struct _import_runtime_state imports;
     138                 :            :     struct _ceval_runtime_state ceval;
     139                 :            :     struct _gilstate_runtime_state gilstate;
     140                 :            :     struct _getargs_runtime_state getargs;
     141                 :            :     struct _fileutils_state fileutils;
     142                 :            :     struct _faulthandler_runtime_state faulthandler;
     143                 :            :     struct _tracemalloc_runtime_state tracemalloc;
     144                 :            : 
     145                 :            :     PyPreConfig preconfig;
     146                 :            : 
     147                 :            :     // Audit values must be preserved when Py_Initialize()/Py_Finalize()
     148                 :            :     // is called multiple times.
     149                 :            :     Py_OpenCodeHookFunction open_code_hook;
     150                 :            :     void *open_code_userdata;
     151                 :            :     _Py_AuditHookEntry *audit_hook_head;
     152                 :            : 
     153                 :            :     struct _Py_float_runtime_state float_state;
     154                 :            :     struct _Py_unicode_runtime_state unicode_state;
     155                 :            : 
     156                 :            :     struct {
     157                 :            :         /* Used to set PyTypeObject.tp_version_tag */
     158                 :            :         // bpo-42745: next_version_tag remains shared by all interpreters
     159                 :            :         // because of static types.
     160                 :            :         unsigned int next_version_tag;
     161                 :            :     } types;
     162                 :            : 
     163                 :            :     /* All the objects that are shared by the runtime's interpreters. */
     164                 :            :     struct _Py_cached_objects cached_objects;
     165                 :            :     struct _Py_static_objects static_objects;
     166                 :            : 
     167                 :            :     /* The following fields are here to avoid allocation during init.
     168                 :            :        The data is exposed through _PyRuntimeState pointer fields.
     169                 :            :        These fields should not be accessed directly outside of init.
     170                 :            : 
     171                 :            :        All other _PyRuntimeState pointer fields are populated when
     172                 :            :        needed and default to NULL.
     173                 :            : 
     174                 :            :        For now there are some exceptions to that rule, which require
     175                 :            :        allocation during init.  These will be addressed on a case-by-case
     176                 :            :        basis.  Most notably, we don't pre-allocated the several mutex
     177                 :            :        (PyThread_type_lock) fields, because on Windows we only ever get
     178                 :            :        a pointer type.
     179                 :            :        */
     180                 :            : 
     181                 :            :     /* PyInterpreterState.interpreters.main */
     182                 :            :     PyInterpreterState _main_interpreter;
     183                 :            : } _PyRuntimeState;
     184                 :            : 
     185                 :            : 
     186                 :            : /* other API */
     187                 :            : 
     188                 :            : PyAPI_DATA(_PyRuntimeState) _PyRuntime;
     189                 :            : 
     190                 :            : PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime);
     191                 :            : PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime);
     192                 :            : 
     193                 :            : #ifdef HAVE_FORK
     194                 :            : extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime);
     195                 :            : #endif
     196                 :            : 
     197                 :            : /* Initialize _PyRuntimeState.
     198                 :            :    Return NULL on success, or return an error message on failure. */
     199                 :            : PyAPI_FUNC(PyStatus) _PyRuntime_Initialize(void);
     200                 :            : 
     201                 :            : PyAPI_FUNC(void) _PyRuntime_Finalize(void);
     202                 :            : 
     203                 :            : 
     204                 :            : static inline PyThreadState*
     205                 :      60385 : _PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) {
     206                 :      60385 :     return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->_finalizing);
     207                 :            : }
     208                 :            : 
     209                 :            : static inline void
     210                 :         54 : _PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) {
     211                 :         54 :     _Py_atomic_store_relaxed(&runtime->_finalizing, (uintptr_t)tstate);
     212                 :         54 : }
     213                 :            : 
     214                 :            : #ifdef __cplusplus
     215                 :            : }
     216                 :            : #endif
     217                 :            : #endif /* !Py_INTERNAL_RUNTIME_H */

Generated by: LCOV version 1.14