:c:func:`Py_Initialize`: :c:func:`Py_EncodeLocale`, :c:func:`Py_GetPath`,
:c:func:`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`,
:c:func:`Py_GetProgramFullPath`, :c:func:`Py_GetPythonHome`,
- :c:func:`Py_GetProgramName` and :c:func:`PyEval_InitThreads`.
+ and :c:func:`Py_GetProgramName`.
.. _global-conf-vars:
.. c:function:: void Py_Initialize()
.. index::
- single: PyEval_InitThreads()
single: modules (in module sys)
single: path (in module sys)
pair: module; builtins
this thread's interpreter state.
-.. c:function:: void PyEval_InitThreads()
-
- .. index::
- single: PyEval_AcquireThread()
- single: PyEval_ReleaseThread()
- single: PyEval_SaveThread()
- single: PyEval_RestoreThread()
-
- Deprecated function which does nothing.
-
- In Python 3.6 and older, this function created the GIL if it didn't exist.
-
- .. versionchanged:: 3.9
- The function now does nothing.
-
- .. versionchanged:: 3.7
- This function is now called by :c:func:`Py_Initialize()`, so you don't
- have to call it yourself anymore.
-
- .. versionchanged:: 3.2
- This function cannot be called before :c:func:`Py_Initialize()` anymore.
-
- .. deprecated:: 3.9
-
- .. index:: pair: module; _thread
-
-
-.. c:function:: int PyEval_ThreadsInitialized()
-
- Returns a non-zero value if :c:func:`PyEval_InitThreads` has been called. This
- function can be called without holding the GIL, and therefore can be used to
- avoid calls to the locking API when running single-threaded.
-
- .. versionchanged:: 3.7
- The :term:`GIL` is now initialized by :c:func:`Py_Initialize()`.
-
- .. deprecated:: 3.9
-
-
.. c:function:: PyThreadState* PyEval_SaveThread()
Release the global interpreter lock (if it has been created) and reset the
available (even when threads have not been initialized).
-.. c:function:: void PyEval_AcquireLock()
-
- Acquire the global interpreter lock. The lock must have been created earlier.
- If this thread already has the lock, a deadlock ensues.
-
- .. deprecated:: 3.2
- This function does not update the current thread state. Please use
- :c:func:`PyEval_RestoreThread` or :c:func:`PyEval_AcquireThread`
- instead.
-
- .. note::
- Calling this function from a thread when the runtime is finalizing
- will terminate the thread, even if the thread was not created by Python.
- You can use :c:func:`_Py_IsFinalizing` or :func:`sys.is_finalizing` to
- check if the interpreter is in process of being finalized before calling
- this function to avoid unwanted termination.
-
- .. versionchanged:: 3.8
- Updated to be consistent with :c:func:`PyEval_RestoreThread`,
- :c:func:`Py_END_ALLOW_THREADS`, and :c:func:`PyGILState_Ensure`,
- and terminate the current thread if called while the interpreter is finalizing.
-
-
-.. c:function:: void PyEval_ReleaseLock()
-
- Release the global interpreter lock. The lock must have been created earlier.
-
- .. deprecated:: 3.2
- This function does not update the current thread state. Please use
- :c:func:`PyEval_SaveThread` or :c:func:`PyEval_ReleaseThread`
- instead.
-
-
.. _sub-interpreter-support:
Sub-interpreter support
PyErr_WriteUnraisable:void:::
PyErr_WriteUnraisable:PyObject*:obj:0:
-PyEval_AcquireLock:void:::
-
PyEval_AcquireThread:void:::
PyEval_AcquireThread:PyThreadState*:tstate::
PyEval_GetFuncName:const char*:::
PyEval_GetFuncName:PyObject*:func:0:
-PyEval_InitThreads:void:::
-
-PyEval_ReleaseLock:void:::
-
PyEval_ReleaseThread:void:::
PyEval_ReleaseThread:PyThreadState*:tstate::
function,PyErr_WarnExplicit,3.2,,
function,PyErr_WarnFormat,3.2,,
function,PyErr_WriteUnraisable,3.2,,
-function,PyEval_AcquireLock,3.2,,
function,PyEval_AcquireThread,3.2,,
function,PyEval_EvalCode,3.2,,
function,PyEval_EvalCodeEx,3.2,,
function,PyEval_GetFuncName,3.2,,
function,PyEval_GetGlobals,3.2,,
function,PyEval_GetLocals,3.2,,
-function,PyEval_InitThreads,3.2,,
-function,PyEval_ReleaseLock,3.2,,
function,PyEval_ReleaseThread,3.2,,
function,PyEval_RestoreThread,3.2,,
function,PyEval_SaveThread,3.2,,
-function,PyEval_ThreadsInitialized,3.2,,
var,PyExc_ArithmeticError,3.2,,
var,PyExc_AssertionError,3.2,,
var,PyExc_AttributeError,3.2,,
Use the new :c:type:`PyConfig` API of the :ref:`Python Initialization
Configuration <init-config>` instead (:pep:`587`), added to Python 3.8.
(Contributed by Victor Stinner in :gh:`105145`.)
+
+* Remove ``PyEval_InitThreads()`` and ``PyEval_ThreadsInitialized()``
+ functions, deprecated in Python 3.9. Since Python 3.7, ``Py_Initialize()``
+ always creates the GIL: calling ``PyEval_InitThreads()`` did nothing and
+ ``PyEval_ThreadsInitialized()`` always returned non-zero.
+ (Contributed by Victor Stinner in :gh:`105182`.)
+
+* Remove ``PyEval_AcquireLock()`` and ``PyEval_ReleaseLock()`` functions,
+ deprecated in Python 3.2. They didn't update the current thread state.
+ They can be replaced with:
+
+ * :c:func:`PyEval_SaveThread` and :c:func:`PyEval_RestoreThread`;
+ * low-level :c:func:`PyEval_AcquireThread` and :c:func:`PyEval_RestoreThread`;
+ * or :c:func:`PyGILState_Ensure` and :c:func:`PyGILState_Release`.
+
+ (Contributed by Victor Stinner in :gh:`105182`.)
PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
-Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
-Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void);
-/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI.
- * They will be removed from this header file in the future version.
- * But they will be remained in ABI until Python 4.0.
- */
-Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void);
-Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void);
PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
regen-pegen-metaparser regen-pegen regen-test-frozenmain \
regen-test-levenshtein regen-global-objects
@echo
- @echo "Note: make regen-stdlib-module-names and make regen-configure should be run manually"
+ @echo "Note: make regen-stdlib-module-names, make regen-limited-abi"
+ @echo "and make regen-configure should be run manually"
############################################################################
# Special rules for object files
--- /dev/null
+Remove ``PyEval_InitThreads()`` and ``PyEval_ThreadsInitialized()``
+functions, deprecated in Python 3.9. Patch by Victor Stinner.
--- /dev/null
+Remove ``PyEval_AcquireLock()`` and ``PyEval_ReleaseLock()`` functions,
+deprecated in Python 3.2. Patch by Victor Stinner.
added = '3.2'
[function.PyEval_AcquireLock]
added = '3.2'
+ abi_only = true
[function.PyEval_AcquireThread]
added = '3.2'
[function.PyEval_CallFunction]
added = '3.2'
[function.PyEval_InitThreads]
added = '3.2'
+ abi_only = true
[function.PyEval_ReleaseLock]
added = '3.2'
+ abi_only = true
[function.PyEval_ReleaseThread]
added = '3.2'
[function.PyEval_RestoreThread]
added = '3.2'
[function.PyEval_ThreadsInitialized]
added = '3.2'
+ abi_only = true
[data.PyExc_ArithmeticError]
added = '3.2'
[data.PyExc_AssertionError]
# Will need to fix that.
#
-{
- Suppress leaking the GIL. Happens once per process, see comment in ceval.c.
- Memcheck:Leak
- fun:malloc
- fun:PyThread_allocate_lock
- fun:PyEval_InitThreads
-}
-
{
Suppress leaking the GIL after a fork.
Memcheck:Leak
return gil_created(gil);
}
-int
+// Function removed in the Python 3.13 API but kept in the stable ABI.
+PyAPI_FUNC(int)
PyEval_ThreadsInitialized(void)
{
return _PyEval_ThreadsInitialized();
interp->ceval.gil = NULL;
}
-void
+// Function removed in the Python 3.13 API but kept in the stable ABI.
+PyAPI_FUNC(void)
PyEval_InitThreads(void)
{
/* Do nothing: kept for backward compatibility */
_Py_PrintSpecializationStats(1);
#endif
}
-void
+
+// Function removed in the Python 3.13 API but kept in the stable ABI.
+PyAPI_FUNC(void)
PyEval_AcquireLock(void)
{
PyThreadState *tstate = _PyThreadState_GET();
take_gil(tstate);
}
-void
+// Function removed in the Python 3.13 API but kept in the stable ABI.
+PyAPI_FUNC(void)
PyEval_ReleaseLock(void)
{
PyThreadState *tstate = _PyThreadState_GET();
projects / thirdparty / Python / cpython.git / commitdiff
