mirror of https://github.com/python/cpython.git
314 lines
10 KiB
C
314 lines
10 KiB
C
/* This file contains the struct definitions for the runtime, interpreter
|
|
* and thread states, plus all smaller structs contained therein */
|
|
|
|
#ifndef Py_INTERNAL_RUNTIME_STRUCTS_H
|
|
#define Py_INTERNAL_RUNTIME_STRUCTS_H
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "pycore_interp_structs.h" // _PyGC_Head_UNUSED
|
|
#include "pycore_obmalloc.h" // struct _obmalloc_global_state
|
|
|
|
/************ Runtime state ************/
|
|
|
|
typedef struct {
|
|
/* We tag each block with an API ID in order to tag API violations */
|
|
char api_id;
|
|
PyMemAllocatorEx alloc;
|
|
} debug_alloc_api_t;
|
|
|
|
struct _pymem_allocators {
|
|
PyMutex mutex;
|
|
struct {
|
|
PyMemAllocatorEx raw;
|
|
PyMemAllocatorEx mem;
|
|
PyMemAllocatorEx obj;
|
|
} standard;
|
|
struct {
|
|
debug_alloc_api_t raw;
|
|
debug_alloc_api_t mem;
|
|
debug_alloc_api_t obj;
|
|
} debug;
|
|
int is_debug_enabled;
|
|
PyObjectArenaAllocator obj_arena;
|
|
};
|
|
|
|
enum _py_float_format_type {
|
|
_py_float_format_unknown,
|
|
_py_float_format_ieee_big_endian,
|
|
_py_float_format_ieee_little_endian,
|
|
};
|
|
|
|
struct _Py_float_runtime_state {
|
|
enum _py_float_format_type float_format;
|
|
enum _py_float_format_type double_format;
|
|
};
|
|
|
|
struct pyhash_runtime_state {
|
|
struct {
|
|
#ifndef MS_WINDOWS
|
|
int fd;
|
|
dev_t st_dev;
|
|
ino_t st_ino;
|
|
#else
|
|
// This is a placeholder so the struct isn't empty on Windows.
|
|
int _not_used;
|
|
#endif
|
|
} urandom_cache;
|
|
};
|
|
|
|
#include "pycore_tracemalloc.h" // struct _tracemalloc_runtime_state
|
|
|
|
struct _fileutils_state {
|
|
int force_ascii;
|
|
};
|
|
|
|
#include "pycore_interpframe_structs.h" // _PyInterpreterFrame
|
|
#include "pycore_debug_offsets.h" // _Py_DebugOffsets
|
|
#include "pycore_signal.h" // struct _signals_runtime_state
|
|
#include "pycore_faulthandler.h" // struct _faulthandler_runtime_state
|
|
#include "pycore_ast.h" // struct _expr
|
|
|
|
#ifdef Py_DEBUG
|
|
#define _PYPEGEN_NSTATISTICS 2000
|
|
#endif
|
|
|
|
struct _parser_runtime_state {
|
|
#ifdef Py_DEBUG
|
|
long memo_statistics[_PYPEGEN_NSTATISTICS];
|
|
#ifdef Py_GIL_DISABLED
|
|
PyMutex mutex;
|
|
#endif
|
|
#else
|
|
int _not_used;
|
|
#endif
|
|
struct _expr dummy_name;
|
|
};
|
|
|
|
typedef struct {
|
|
PyTime_t numer;
|
|
PyTime_t denom;
|
|
} _PyTimeFraction;
|
|
|
|
struct _Py_time_runtime_state {
|
|
#if defined(MS_WINDOWS) || defined(__APPLE__)
|
|
_PyTimeFraction base;
|
|
#else
|
|
char _unused;
|
|
#endif
|
|
};
|
|
|
|
|
|
struct _Py_cached_objects {
|
|
// XXX We could statically allocate the hashtable.
|
|
_Py_hashtable_t *interned_strings;
|
|
};
|
|
|
|
// These would be in pycore_long.h if it weren't for an include cycle.
|
|
#define _PY_NSMALLPOSINTS 257
|
|
#define _PY_NSMALLNEGINTS 5
|
|
|
|
#include "pycore_global_strings.h" // struct _Py_global_strings
|
|
|
|
struct _Py_static_objects {
|
|
struct {
|
|
/* Small integers are preallocated in this array so that they
|
|
* can be shared.
|
|
* The integers that are preallocated are those in the range
|
|
* -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (exclusive).
|
|
*/
|
|
PyLongObject small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS];
|
|
|
|
PyBytesObject bytes_empty;
|
|
struct {
|
|
PyBytesObject ob;
|
|
char eos;
|
|
} bytes_characters[256];
|
|
|
|
struct _Py_global_strings strings;
|
|
|
|
_PyGC_Head_UNUSED _tuple_empty_gc_not_used;
|
|
PyTupleObject tuple_empty;
|
|
|
|
_PyGC_Head_UNUSED _hamt_bitmap_node_empty_gc_not_used;
|
|
PyHamtNode_Bitmap hamt_bitmap_node_empty;
|
|
_PyContextTokenMissing context_token_missing;
|
|
} singletons;
|
|
};
|
|
|
|
/* Full Python runtime state */
|
|
|
|
/* _PyRuntimeState holds the global state for the CPython runtime.
|
|
That data is exported by the internal API as a global variable
|
|
(_PyRuntime, defined near the top of pylifecycle.c).
|
|
*/
|
|
struct pyruntimestate {
|
|
/* This field must be first to facilitate locating it by out of process
|
|
* debuggers. Out of process debuggers will use the offsets contained in this
|
|
* field to be able to locate other fields in several interpreter structures
|
|
* in a way that doesn't require them to know the exact layout of those
|
|
* structures.
|
|
*
|
|
* IMPORTANT:
|
|
* This struct is **NOT** backwards compatible between minor version of the
|
|
* interpreter and the members, order of members and size can change between
|
|
* minor versions. This struct is only guaranteed to be stable between patch
|
|
* versions for a given minor version of the interpreter.
|
|
*/
|
|
_Py_DebugOffsets debug_offsets;
|
|
|
|
/* Has been initialized to a safe state.
|
|
|
|
In order to be effective, this must be set to 0 during or right
|
|
after allocation. */
|
|
int _initialized;
|
|
|
|
/* Is running Py_PreInitialize()? */
|
|
int preinitializing;
|
|
|
|
/* Is Python preinitialized? Set to 1 by Py_PreInitialize() */
|
|
int preinitialized;
|
|
|
|
/* Is Python core initialized? Set to 1 by _Py_InitializeCore() */
|
|
int core_initialized;
|
|
|
|
/* Is Python fully initialized? Set to 1 by Py_Initialize() */
|
|
int initialized;
|
|
|
|
/* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize()
|
|
is called again.
|
|
|
|
Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing()
|
|
to access it, don't access it directly. */
|
|
PyThreadState *_finalizing;
|
|
/* The ID of the OS thread in which we are finalizing. */
|
|
unsigned long _finalizing_id;
|
|
|
|
struct pyinterpreters {
|
|
PyMutex mutex;
|
|
/* The linked list of interpreters, newest first. */
|
|
PyInterpreterState *head;
|
|
/* The runtime's initial interpreter, which has a special role
|
|
in the operation of the runtime. It is also often the only
|
|
interpreter. */
|
|
PyInterpreterState *main;
|
|
/* next_id is an auto-numbered sequence of small
|
|
integers. It gets initialized in _PyInterpreterState_Enable(),
|
|
which is called in Py_Initialize(), and used in
|
|
PyInterpreterState_New(). A negative interpreter ID
|
|
indicates an error occurred. The main interpreter will
|
|
always have an ID of 0. Overflow results in a RuntimeError.
|
|
If that becomes a problem later then we can adjust, e.g. by
|
|
using a Python int. */
|
|
int64_t next_id;
|
|
} interpreters;
|
|
|
|
/* Platform-specific identifier and PyThreadState, respectively, for the
|
|
main thread in the main interpreter. */
|
|
unsigned long main_thread;
|
|
PyThreadState *main_tstate;
|
|
|
|
/* ---------- IMPORTANT ---------------------------
|
|
The fields above this line are declared as early as
|
|
possible to facilitate out-of-process observability
|
|
tools. */
|
|
|
|
/* cross-interpreter data and utils */
|
|
_PyXI_global_state_t xi;
|
|
|
|
struct _pymem_allocators allocators;
|
|
struct _obmalloc_global_state obmalloc;
|
|
struct pyhash_runtime_state pyhash_state;
|
|
struct _pythread_runtime_state threads;
|
|
struct _signals_runtime_state signals;
|
|
|
|
/* Used instead of PyThreadState.trash when there is not current tstate. */
|
|
Py_tss_t trashTSSkey;
|
|
|
|
PyWideStringList orig_argv;
|
|
|
|
struct _parser_runtime_state parser;
|
|
|
|
struct _atexit_runtime_state atexit;
|
|
|
|
struct _import_runtime_state imports;
|
|
struct _ceval_runtime_state ceval;
|
|
struct _gilstate_runtime_state {
|
|
/* bpo-26558: Flag to disable PyGILState_Check().
|
|
If set to non-zero, PyGILState_Check() always return 1. */
|
|
int check_enabled;
|
|
/* The single PyInterpreterState used by this process'
|
|
GILState implementation
|
|
*/
|
|
/* TODO: Given interp_main, it may be possible to kill this ref */
|
|
PyInterpreterState *autoInterpreterState;
|
|
} gilstate;
|
|
struct _getargs_runtime_state {
|
|
struct _PyArg_Parser *static_parsers;
|
|
} getargs;
|
|
struct _fileutils_state fileutils;
|
|
struct _faulthandler_runtime_state faulthandler;
|
|
struct _tracemalloc_runtime_state tracemalloc;
|
|
struct _reftracer_runtime_state ref_tracer;
|
|
|
|
// The rwmutex is used to prevent overlapping global and per-interpreter
|
|
// stop-the-world events. Global stop-the-world events lock the mutex
|
|
// exclusively (as a "writer"), while per-interpreter stop-the-world events
|
|
// lock it non-exclusively (as "readers").
|
|
_PyRWMutex stoptheworld_mutex;
|
|
struct _stoptheworld_state stoptheworld;
|
|
|
|
PyPreConfig preconfig;
|
|
|
|
// Audit values must be preserved when Py_Initialize()/Py_Finalize()
|
|
// is called multiple times.
|
|
Py_OpenCodeHookFunction open_code_hook;
|
|
void *open_code_userdata;
|
|
struct {
|
|
PyMutex mutex;
|
|
struct _Py_AuditHookEntry *head;
|
|
} audit_hooks;
|
|
|
|
struct _py_object_runtime_state object_state;
|
|
struct _Py_float_runtime_state float_state;
|
|
struct _Py_unicode_runtime_state unicode_state;
|
|
struct _types_runtime_state types;
|
|
struct _Py_time_runtime_state time;
|
|
|
|
#if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE)
|
|
// Used in "Python/emscripten_trampoline.c" to choose between type
|
|
// reflection trampoline and EM_JS trampoline.
|
|
int (*emscripten_count_args_function)(PyCFunctionWithKeywords func);
|
|
#endif
|
|
|
|
/* All the objects that are shared by the runtime's interpreters. */
|
|
struct _Py_cached_objects cached_objects;
|
|
struct _Py_static_objects static_objects;
|
|
|
|
/* The following fields are here to avoid allocation during init.
|
|
The data is exposed through _PyRuntimeState pointer fields.
|
|
These fields should not be accessed directly outside of init.
|
|
|
|
All other _PyRuntimeState pointer fields are populated when
|
|
needed and default to NULL.
|
|
|
|
For now there are some exceptions to that rule, which require
|
|
allocation during init. These will be addressed on a case-by-case
|
|
basis. Most notably, we don't pre-allocated the several mutex
|
|
(PyThread_type_lock) fields, because on Windows we only ever get
|
|
a pointer type.
|
|
*/
|
|
|
|
/* _PyRuntimeState.interpreters.main */
|
|
PyInterpreterState _main_interpreter;
|
|
// _main_interpreter should be the last field of _PyRuntimeState.
|
|
// See https://github.com/python/cpython/issues/127117.
|
|
};
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* Py_INTERNAL_RUNTIME_STRUCTS_H */
|