Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2025-02-22 08:29:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Start pybind11v3: Remove all code for PYBIND11_INTERNALS_VERSIONs 4 and 5 (#5530)

Browse Source 
* Start pybind11v3

* Remove all code for PYBIND11_INTERNALS_VERSION 4 and 5

* Fix oversight: pybind11/_version.py needs to be updated as well.

* Add @pytest.mark.skipif("env.GRAALPY", reason="TODO debug segfault")
This commit is contained in:
Ralf W. Grosse-Kunstleve 2025-02-19 09:24:02 -08:00 committed by GitHub
parent 241524223a
commit b7c33009ac
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 36 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/pybind11/detail/common.h
View File

@ -14,13 +14,13 @@
# error "PYTHON < 3.8 IS UNSUPPORTED. pybind11 v2.13 was the last to support Python 3.7." # error "PYTHON < 3.8 IS UNSUPPORTED. pybind11 v2.13 was the last to support Python 3.7."
#endif #endif
#define PYBIND11_VERSION_MAJOR 2 #define PYBIND11_VERSION_MAJOR 3
#define PYBIND11_VERSION_MINOR 14 #define PYBIND11_VERSION_MINOR 0
#define PYBIND11_VERSION_PATCH 0.dev1 #define PYBIND11_VERSION_PATCH 0.dev1
// Similar to Python's convention: https://docs.python.org/3/c-api/apiabiversion.html // Similar to Python's convention: https://docs.python.org/3/c-api/apiabiversion.html
// Additional convention: 0xD = dev // Additional convention: 0xD = dev
#define PYBIND11_VERSION_HEX 0x020E00D1 #define PYBIND11_VERSION_HEX 0x030000D1
// Define some generic pybind11 helper macros for warning management. // Define some generic pybind11 helper macros for warning management.
// //

118
include/pybind11/detail/internals.h
View File

@ -40,11 +40,9 @@
# define PYBIND11_INTERNALS_VERSION 6 # define PYBIND11_INTERNALS_VERSION 6
#endif #endif
// This requirement is mainly to reduce the support burden (see PR #4570). #if PYBIND11_INTERNALS_VERSION < 6
static_assert(PY_VERSION_HEX < 0x030C0000 || PYBIND11_INTERNALS_VERSION >= 5, # error "PYBIND11_INTERNALS_VERSION 6 is the minimum for all platforms for pybind11v3."
"pybind11 ABI version 5 is the minimum for Python 3.12+"); #endif
static_assert(PYBIND11_INTERNALS_VERSION >= 4,
"pybind11 ABI version 4 is the minimum for all platforms.");
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
@ -63,40 +61,29 @@ inline PyObject *make_object_base_type(PyTypeObject *metaclass);
// Thread Specific Storage (TSS) API. // Thread Specific Storage (TSS) API.
// Avoid unnecessary allocation of `Py_tss_t`, since we cannot use // Avoid unnecessary allocation of `Py_tss_t`, since we cannot use
// `Py_LIMITED_API` anyway. // `Py_LIMITED_API` anyway.
#if PYBIND11_INTERNALS_VERSION > 4 #define PYBIND11_TLS_KEY_REF Py_tss_t &
# define PYBIND11_TLS_KEY_REF Py_tss_t & #if defined(__clang__)
# if defined(__clang__) # define PYBIND11_TLS_KEY_INIT(var) \
# define PYBIND11_TLS_KEY_INIT(var) \ _Pragma("clang diagnostic push") /**/ \
_Pragma("clang diagnostic push") /**/ \ _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") /**/ \
_Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") /**/ \ Py_tss_t var \
Py_tss_t var \ = Py_tss_NEEDS_INIT; \
= Py_tss_NEEDS_INIT; \ _Pragma("clang diagnostic pop")
_Pragma("clang diagnostic pop") #elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
# elif defined(__GNUC__) && !defined(__INTEL_COMPILER) # define PYBIND11_TLS_KEY_INIT(var) \
# define PYBIND11_TLS_KEY_INIT(var) \ _Pragma("GCC diagnostic push") /**/ \
_Pragma("GCC diagnostic push") /**/ \ _Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") /**/ \
_Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") /**/ \ Py_tss_t var \
Py_tss_t var \ = Py_tss_NEEDS_INIT; \
= Py_tss_NEEDS_INIT; \ _Pragma("GCC diagnostic pop")
_Pragma("GCC diagnostic pop")
# else
# define PYBIND11_TLS_KEY_INIT(var) Py_tss_t var = Py_tss_NEEDS_INIT;
# endif
# define PYBIND11_TLS_KEY_CREATE(var) (PyThread_tss_create(&(var)) == 0)
# define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get(&(key))
# define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set(&(key), (value))
# define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set(&(key), nullptr)
# define PYBIND11_TLS_FREE(key) PyThread_tss_delete(&(key))
#else #else
# define PYBIND11_TLS_KEY_REF Py_tss_t * # define PYBIND11_TLS_KEY_INIT(var) Py_tss_t var = Py_tss_NEEDS_INIT;
# define PYBIND11_TLS_KEY_INIT(var) Py_tss_t *var = nullptr;
# define PYBIND11_TLS_KEY_CREATE(var) \
(((var) = PyThread_tss_alloc()) != nullptr && (PyThread_tss_create((var)) == 0))
# define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get((key))
# define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set((key), (value))
# define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set((key), nullptr)
# define PYBIND11_TLS_FREE(key) PyThread_tss_free(key)
#endif #endif
#define PYBIND11_TLS_KEY_CREATE(var) (PyThread_tss_create(&(var)) == 0)
#define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get(&(key))
#define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set(&(key), (value))
#define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set(&(key), nullptr)
#define PYBIND11_TLS_FREE(key) PyThread_tss_delete(&(key))
// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly // Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly
// other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module // other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module
@ -104,8 +91,7 @@ inline PyObject *make_object_base_type(PyTypeObject *metaclass);
// libstdc++, this doesn't happen: equality and the type_index hash are based on the type name, // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
// which works. If not under a known-good stl, provide our own name-based hash and equality // which works. If not under a known-good stl, provide our own name-based hash and equality
// functions that use the type name. // functions that use the type name.
#if (PYBIND11_INTERNALS_VERSION <= 4 && defined(__GLIBCXX__)) \ #if !defined(_LIBCPP_VERSION)
|| (PYBIND11_INTERNALS_VERSION >= 5 && !defined(_LIBCPP_VERSION))
inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; } inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
using type_hash = std::hash<std::type_index>; using type_hash = std::hash<std::type_index>;
using type_equal_to = std::equal_to<std::type_index>; using type_equal_to = std::equal_to<std::type_index>;
@ -193,35 +179,26 @@ struct internals {
std::forward_list<ExceptionTranslator> registered_exception_translators; std::forward_list<ExceptionTranslator> registered_exception_translators;
std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across
// extensions // extensions
#if PYBIND11_INTERNALS_VERSION == 4 std::forward_list<std::string> static_strings; // Stores the std::strings backing
std::vector<PyObject *> unused_loader_patient_stack_remove_at_v5; // detail::c_str()
#endif
std::forward_list<std::string> static_strings; // Stores the std::strings backing
// detail::c_str()
PyTypeObject *static_property_type; PyTypeObject *static_property_type;
PyTypeObject *default_metaclass; PyTypeObject *default_metaclass;
PyObject *instance_base; PyObject *instance_base;
// Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined: // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
PYBIND11_TLS_KEY_INIT(tstate) PYBIND11_TLS_KEY_INIT(tstate)
#if PYBIND11_INTERNALS_VERSION > 4
PYBIND11_TLS_KEY_INIT(loader_life_support_tls_key) PYBIND11_TLS_KEY_INIT(loader_life_support_tls_key)
#endif // PYBIND11_INTERNALS_VERSION > 4
// Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined: // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
PyInterpreterState *istate = nullptr; PyInterpreterState *istate = nullptr;
#if PYBIND11_INTERNALS_VERSION > 4
// Note that we have to use a std::string to allocate memory to ensure a unique address // Note that we have to use a std::string to allocate memory to ensure a unique address
// We want unique addresses since we use pointer equality to compare function records // We want unique addresses since we use pointer equality to compare function records
std::string function_record_capsule_name = internals_function_record_capsule_name; std::string function_record_capsule_name = internals_function_record_capsule_name;
#endif
internals() = default; internals() = default;
internals(const internals &other) = delete; internals(const internals &other) = delete;
internals &operator=(const internals &other) = delete; internals &operator=(const internals &other) = delete;
~internals() { ~internals() {
#if PYBIND11_INTERNALS_VERSION > 4
PYBIND11_TLS_FREE(loader_life_support_tls_key); PYBIND11_TLS_FREE(loader_life_support_tls_key);
#endif // PYBIND11_INTERNALS_VERSION > 4
// This destructor is called *after* Py_Finalize() in finalize_interpreter(). // This destructor is called *after* Py_Finalize() in finalize_interpreter().
// That *SHOULD BE* fine. The following details what happens when PyThread_tss_free is // That *SHOULD BE* fine. The following details what happens when PyThread_tss_free is
@ -386,7 +363,7 @@ inline void translate_local_exception(std::exception_ptr p) {
inline object get_python_state_dict() { inline object get_python_state_dict() {
object state_dict; object state_dict;
#if PYBIND11_INTERNALS_VERSION <= 4 || defined(PYPY_VERSION) || defined(GRAALVM_PYTHON) #if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
state_dict = reinterpret_borrow<object>(PyEval_GetBuiltins()); state_dict = reinterpret_borrow<object>(PyEval_GetBuiltins());
#else #else
# if PY_VERSION_HEX < 0x03090000 # if PY_VERSION_HEX < 0x03090000
@ -484,13 +461,12 @@ PYBIND11_NOINLINE internals &get_internals() {
} }
PYBIND11_TLS_REPLACE_VALUE(internals_ptr->tstate, tstate); PYBIND11_TLS_REPLACE_VALUE(internals_ptr->tstate, tstate);
#if PYBIND11_INTERNALS_VERSION > 4
// NOLINTNEXTLINE(bugprone-assignment-in-if-condition) // NOLINTNEXTLINE(bugprone-assignment-in-if-condition)
if (!PYBIND11_TLS_KEY_CREATE(internals_ptr->loader_life_support_tls_key)) { if (!PYBIND11_TLS_KEY_CREATE(internals_ptr->loader_life_support_tls_key)) {
pybind11_fail("get_internals: could not successfully initialize the " pybind11_fail("get_internals: could not successfully initialize the "
"loader_life_support TSS key!"); "loader_life_support TSS key!");
} }
#endif
internals_ptr->istate = tstate->interp; internals_ptr->istate = tstate->interp;
state_dict[PYBIND11_INTERNALS_ID] = capsule(reinterpret_cast<void *>(internals_pp)); state_dict[PYBIND11_INTERNALS_ID] = capsule(reinterpret_cast<void *>(internals_pp));
internals_ptr->registered_exception_translators.push_front(&translate_exception); internals_ptr->registered_exception_translators.push_front(&translate_exception);
@ -520,40 +496,6 @@ PYBIND11_NOINLINE internals &get_internals() {
struct local_internals { struct local_internals {
type_map<type_info *> registered_types_cpp; type_map<type_info *> registered_types_cpp;
std::forward_list<ExceptionTranslator> registered_exception_translators; std::forward_list<ExceptionTranslator> registered_exception_translators;
#if PYBIND11_INTERNALS_VERSION == 4
// For ABI compatibility, we can't store the loader_life_support TLS key in
// the `internals` struct directly. Instead, we store it in `shared_data` and
// cache a copy in `local_internals`. If we allocated a separate TLS key for
// each instance of `local_internals`, we could end up allocating hundreds of
// TLS keys if hundreds of different pybind11 modules are loaded (which is a
// plausible number).
PYBIND11_TLS_KEY_INIT(loader_life_support_tls_key)
// Holds the shared TLS key for the loader_life_support stack.
struct shared_loader_life_support_data {
PYBIND11_TLS_KEY_INIT(loader_life_support_tls_key)
shared_loader_life_support_data() {
// NOLINTNEXTLINE(bugprone-assignment-in-if-condition)
if (!PYBIND11_TLS_KEY_CREATE(loader_life_support_tls_key)) {
pybind11_fail("local_internals: could not successfully initialize the "
"loader_life_support TLS key!");
}
}
// We can't help but leak the TLS key, because Python never unloads extension modules.
};
local_internals() {
auto &internals = get_internals();
// Get or create the `loader_life_support_stack_key`.
auto &ptr = internals.shared_data["_life_support"];
if (!ptr) {
ptr = new shared_loader_life_support_data;
}
loader_life_support_tls_key
= static_cast<shared_loader_life_support_data *>(ptr)->loader_life_support_tls_key;
}
#endif // PYBIND11_INTERNALS_VERSION == 4
}; };
/// Works like `get_internals`, but for things which are locally registered. /// Works like `get_internals`, but for things which are locally registered.
@ -660,7 +602,7 @@ const char *c_str(Args &&...args) {
inline const char *get_function_record_capsule_name() { inline const char *get_function_record_capsule_name() {
// On GraalPy, pointer equality of the names is currently not guaranteed // On GraalPy, pointer equality of the names is currently not guaranteed
#if PYBIND11_INTERNALS_VERSION > 4 && !defined(GRAALVM_PYTHON) #if !defined(GRAALVM_PYTHON)
return get_internals().function_record_capsule_name.c_str(); return get_internals().function_record_capsule_name.c_str();
#else #else
return nullptr; return nullptr;

4
include/pybind11/detail/type_caster_base.h
View File

@ -43,11 +43,7 @@ private:
// Store stack pointer in thread-local storage. // Store stack pointer in thread-local storage.
static PYBIND11_TLS_KEY_REF get_stack_tls_key() { static PYBIND11_TLS_KEY_REF get_stack_tls_key() {
#if PYBIND11_INTERNALS_VERSION == 4
return get_local_internals().loader_life_support_tls_key;
#else
return get_internals().loader_life_support_tls_key; return get_internals().loader_life_support_tls_key;
#endif
} }
static loader_life_support *get_stack_top() { static loader_life_support *get_stack_top() {
return static_cast<loader_life_support *>(PYBIND11_TLS_GET_VALUE(get_stack_tls_key())); return static_cast<loader_life_support *>(PYBIND11_TLS_GET_VALUE(get_stack_tls_key()));

2
pybind11/_version.py
View File

@ -8,5 +8,5 @@ def _to_int(s: str) -> int | str:
return s return s
__version__ = "2.14.0.dev1" __version__ = "3.0.0.dev1"
version_info = tuple(_to_int(s) for s in __version__.split(".")) version_info = tuple(_to_int(s) for s in __version__.split("."))

5
tests/test_callbacks.cpp
View File

@ -269,12 +269,7 @@ TEST_SUBMODULE(callbacks, m) {
rec_capsule.set_name(rec_capsule_name); rec_capsule.set_name(rec_capsule_name);
m.add_object("custom_function", PyCFunction_New(custom_def, rec_capsule.ptr())); m.add_object("custom_function", PyCFunction_New(custom_def, rec_capsule.ptr()));
// This test requires a new ABI version to pass
#if PYBIND11_INTERNALS_VERSION > 4 && !defined(GRAALVM_PYTHON)
// rec_capsule with nullptr name // rec_capsule with nullptr name
py::capsule rec_capsule2(std::malloc(1), [](void *data) { std::free(data); }); py::capsule rec_capsule2(std::malloc(1), [](void *data) { std::free(data); });
m.add_object("custom_function2", PyCFunction_New(custom_def, rec_capsule2.ptr())); m.add_object("custom_function2", PyCFunction_New(custom_def, rec_capsule2.ptr()));
#else
m.add_object("custom_function2", py::none());
#endif
} }

4
tests/test_callbacks.py
View File

@ -217,9 +217,7 @@ def test_custom_func():
assert m.roundtrip(m.custom_function)(4) == 36 assert m.roundtrip(m.custom_function)(4) == 36
@pytest.mark.skipif( @pytest.mark.skipif("env.GRAALPY", reason="TODO debug segfault")
m.custom_function2 is None, reason="Current PYBIND11_INTERNALS_VERSION too low"
)
def test_custom_func2(): def test_custom_func2():
assert m.custom_function2(3) == 27 assert m.custom_function2(3) == 27
assert m.roundtrip(m.custom_function2)(3) == 27 assert m.roundtrip(m.custom_function2)(3) == 27

1
tests/test_unnamed_namespace_a.cpp
View File

@ -10,7 +10,6 @@ TEST_SUBMODULE(unnamed_namespace_a, m) {
} else { } else {
m.attr("unnamed_namespace_a_any_struct") = py::none(); m.attr("unnamed_namespace_a_any_struct") = py::none();
} }
m.attr("PYBIND11_INTERNALS_VERSION") = PYBIND11_INTERNALS_VERSION;
m.attr("defined_WIN32_or__WIN32") = m.attr("defined_WIN32_or__WIN32") =
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
true; true;

8
tests/test_unnamed_namespace_a.py
View File

@ -5,13 +5,7 @@ import pytest
from pybind11_tests import unnamed_namespace_a as m from pybind11_tests import unnamed_namespace_a as m
from pybind11_tests import unnamed_namespace_b as mb from pybind11_tests import unnamed_namespace_b as mb
XFAIL_CONDITION = ( XFAIL_CONDITION = "not m.defined_WIN32_or__WIN32 and (m.defined___clang__ or m.defined__LIBCPP_VERSION)"
"(m.PYBIND11_INTERNALS_VERSION <= 4 and (m.defined___clang__ or not m.defined___GLIBCXX__))"
" or "
"(m.PYBIND11_INTERNALS_VERSION >= 5 and not m.defined_WIN32_or__WIN32"
" and "
"(m.defined___clang__ or m.defined__LIBCPP_VERSION))"
)
XFAIL_REASON = "Known issues: https://github.com/pybind/pybind11/pull/4319" XFAIL_REASON = "Known issues: https://github.com/pybind/pybind11/pull/4319"