ext: Update Pybind to Version 2.10.3
Updating Pybind11 is necessary for gem5 to compile correctly with Python 3.11. As of March 9th 2023, 2.10.3 is the latest version of Pybind11. Change-Id: I32c68c507770040d3fac2de442d88a8f46b48896 Issue-on: https://gem5.atlassian.net/browse/GEM5-1295 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/68818 Maintainer: Jason Lowe-Power <power.jg@gmail.com> Tested-by: kokoro <noreply+kokoro@google.com> Reviewed-by: Jason Lowe-Power <power.jg@gmail.com>
This commit is contained in:
Bobby R. Bruce
committed by
Bobby Bruce
Bobby Bruce
parent
b305019ac4
commit
07fca546e6
@@ -7,9 +7,12 @@
|
||||
BSD-style license that can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "pybind11_tests.h"
|
||||
#include "constructor_stats.h"
|
||||
#include <pybind11/operators.h>
|
||||
#include <pybind11/stl.h>
|
||||
|
||||
#include "constructor_stats.h"
|
||||
#include "pybind11_tests.h"
|
||||
|
||||
#include <functional>
|
||||
|
||||
class Vector2 {
|
||||
@@ -20,17 +23,24 @@ public:
|
||||
print_move_created(this);
|
||||
v.x = v.y = 0;
|
||||
}
|
||||
Vector2 &operator=(const Vector2 &v) { x = v.x; y = v.y; print_copy_assigned(this); return *this; }
|
||||
Vector2 &operator=(const Vector2 &v) {
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
print_copy_assigned(this);
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator=(Vector2 &&v) noexcept {
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
v.x = v.y = 0;
|
||||
print_move_assigned(this);
|
||||
return *this;
|
||||
}
|
||||
~Vector2() { print_destroyed(this); }
|
||||
|
||||
std::string toString() const { return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; }
|
||||
std::string toString() const {
|
||||
return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
|
||||
}
|
||||
|
||||
Vector2 operator-() const { return Vector2(-x, -y); }
|
||||
Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
|
||||
@@ -41,71 +51,100 @@ public:
|
||||
Vector2 operator/(float value) const { return Vector2(x / value, y / value); }
|
||||
Vector2 operator*(const Vector2 &v) const { return Vector2(x * v.x, y * v.y); }
|
||||
Vector2 operator/(const Vector2 &v) const { return Vector2(x / v.x, y / v.y); }
|
||||
Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
|
||||
Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; }
|
||||
Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
|
||||
Vector2& operator/=(float v) { x /= v; y /= v; return *this; }
|
||||
Vector2& operator*=(const Vector2 &v) { x *= v.x; y *= v.y; return *this; }
|
||||
Vector2& operator/=(const Vector2 &v) { x /= v.x; y /= v.y; return *this; }
|
||||
Vector2 &operator+=(const Vector2 &v) {
|
||||
x += v.x;
|
||||
y += v.y;
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator-=(const Vector2 &v) {
|
||||
x -= v.x;
|
||||
y -= v.y;
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator*=(float v) {
|
||||
x *= v;
|
||||
y *= v;
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator/=(float v) {
|
||||
x /= v;
|
||||
y /= v;
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator*=(const Vector2 &v) {
|
||||
x *= v.x;
|
||||
y *= v.y;
|
||||
return *this;
|
||||
}
|
||||
Vector2 &operator/=(const Vector2 &v) {
|
||||
x /= v.x;
|
||||
y /= v.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x, f + v.y); }
|
||||
friend Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x, f - v.y); }
|
||||
friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x, f * v.y); }
|
||||
friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); }
|
||||
|
||||
bool operator==(const Vector2 &v) const {
|
||||
return x == v.x && y == v.y;
|
||||
}
|
||||
bool operator!=(const Vector2 &v) const {
|
||||
return x != v.x || y != v.y;
|
||||
}
|
||||
bool operator==(const Vector2 &v) const { return x == v.x && y == v.y; }
|
||||
bool operator!=(const Vector2 &v) const { return x != v.x || y != v.y; }
|
||||
|
||||
private:
|
||||
float x, y;
|
||||
};
|
||||
|
||||
class C1 { };
|
||||
class C2 { };
|
||||
class C1 {};
|
||||
class C2 {};
|
||||
|
||||
int operator+(const C1 &, const C1 &) { return 11; }
|
||||
int operator+(const C2 &, const C2 &) { return 22; }
|
||||
int operator+(const C2 &, const C1 &) { return 21; }
|
||||
int operator+(const C1 &, const C2 &) { return 12; }
|
||||
|
||||
struct HashMe {
|
||||
std::string member;
|
||||
};
|
||||
|
||||
bool operator==(const HashMe &lhs, const HashMe &rhs) { return lhs.member == rhs.member; }
|
||||
|
||||
// Note: Specializing explicit within `namespace std { ... }` is done due to a
|
||||
// bug in GCC<7. If you are supporting compilers later than this, consider
|
||||
// specializing `using template<> struct std::hash<...>` in the global
|
||||
// namespace instead, per this recommendation:
|
||||
// https://en.cppreference.com/w/cpp/language/extending_std#Adding_template_specializations
|
||||
namespace std {
|
||||
template<>
|
||||
struct hash<Vector2> {
|
||||
// Not a good hash function, but easy to test
|
||||
size_t operator()(const Vector2 &) { return 4; }
|
||||
};
|
||||
template <>
|
||||
struct hash<Vector2> {
|
||||
// Not a good hash function, but easy to test
|
||||
size_t operator()(const Vector2 &) { return 4; }
|
||||
};
|
||||
|
||||
// HashMe has a hash function in C++ but no `__hash__` for Python.
|
||||
template <>
|
||||
struct hash<HashMe> {
|
||||
std::size_t operator()(const HashMe &selector) const {
|
||||
return std::hash<std::string>()(selector.member);
|
||||
}
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
// Not a good abs function, but easy to test.
|
||||
std::string abs(const Vector2&) {
|
||||
return "abs(Vector2)";
|
||||
}
|
||||
std::string abs(const Vector2 &) { return "abs(Vector2)"; }
|
||||
|
||||
// MSVC & Intel warns about unknown pragmas, and warnings are errors.
|
||||
#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
|
||||
#pragma GCC diagnostic push
|
||||
// clang 7.0.0 and Apple LLVM 10.0.1 introduce `-Wself-assign-overloaded` to
|
||||
// `-Wall`, which is used here for overloading (e.g. `py::self += py::self `).
|
||||
// Here, we suppress the warning using `#pragma diagnostic`.
|
||||
// Taken from: https://github.com/RobotLocomotion/drake/commit/aaf84b46
|
||||
// TODO(eric): This could be resolved using a function / functor (e.g. `py::self()`).
|
||||
#if defined(__APPLE__) && defined(__clang__)
|
||||
#if (__clang_major__ >= 10)
|
||||
#pragma GCC diagnostic ignored "-Wself-assign-overloaded"
|
||||
#endif
|
||||
#elif defined(__clang__)
|
||||
#if (__clang_major__ >= 7)
|
||||
#pragma GCC diagnostic ignored "-Wself-assign-overloaded"
|
||||
#endif
|
||||
#endif
|
||||
// clang 7.0.0 and Apple LLVM 10.0.1 introduce `-Wself-assign-overloaded` to
|
||||
// `-Wall`, which is used here for overloading (e.g. `py::self += py::self `).
|
||||
// Here, we suppress the warning
|
||||
// Taken from: https://github.com/RobotLocomotion/drake/commit/aaf84b46
|
||||
// TODO(eric): This could be resolved using a function / functor (e.g. `py::self()`).
|
||||
#if defined(__APPLE__) && defined(__clang__)
|
||||
# if (__clang_major__ >= 10)
|
||||
PYBIND11_WARNING_DISABLE_CLANG("-Wself-assign-overloaded")
|
||||
# endif
|
||||
#elif defined(__clang__)
|
||||
# if (__clang_major__ >= 7)
|
||||
PYBIND11_WARNING_DISABLE_CLANG("-Wself-assign-overloaded")
|
||||
# endif
|
||||
#endif
|
||||
|
||||
TEST_SUBMODULE(operators, m) {
|
||||
@@ -139,46 +178,52 @@ TEST_SUBMODULE(operators, m) {
|
||||
.def(py::hash(py::self))
|
||||
// N.B. See warning about usage of `py::detail::abs(py::self)` in
|
||||
// `operators.h`.
|
||||
.def("__abs__", [](const Vector2& v) { return abs(v); })
|
||||
;
|
||||
.def("__abs__", [](const Vector2 &v) { return abs(v); });
|
||||
|
||||
m.attr("Vector") = m.attr("Vector2");
|
||||
|
||||
// test_operators_notimplemented
|
||||
// #393: need to return NotSupported to ensure correct arithmetic operator behavior
|
||||
py::class_<C1>(m, "C1")
|
||||
.def(py::init<>())
|
||||
.def(py::self + py::self);
|
||||
py::class_<C1>(m, "C1").def(py::init<>()).def(py::self + py::self);
|
||||
|
||||
py::class_<C2>(m, "C2")
|
||||
.def(py::init<>())
|
||||
.def(py::self + py::self)
|
||||
.def("__add__", [](const C2& c2, const C1& c1) { return c2 + c1; })
|
||||
.def("__radd__", [](const C2& c2, const C1& c1) { return c1 + c2; });
|
||||
.def("__add__", [](const C2 &c2, const C1 &c1) { return c2 + c1; })
|
||||
.def("__radd__", [](const C2 &c2, const C1 &c1) { return c1 + c2; });
|
||||
|
||||
// test_nested
|
||||
// #328: first member in a class can't be used in operators
|
||||
struct NestABase { int value = -2; };
|
||||
struct NestABase {
|
||||
int value = -2;
|
||||
};
|
||||
py::class_<NestABase>(m, "NestABase")
|
||||
.def(py::init<>())
|
||||
.def_readwrite("value", &NestABase::value);
|
||||
|
||||
struct NestA : NestABase {
|
||||
int value = 3;
|
||||
NestA& operator+=(int i) { value += i; return *this; }
|
||||
NestA &operator+=(int i) {
|
||||
value += i;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
py::class_<NestA>(m, "NestA")
|
||||
.def(py::init<>())
|
||||
.def(py::self += int())
|
||||
.def("as_base", [](NestA &a) -> NestABase& {
|
||||
return (NestABase&) a;
|
||||
}, py::return_value_policy::reference_internal);
|
||||
.def(
|
||||
"as_base",
|
||||
[](NestA &a) -> NestABase & { return (NestABase &) a; },
|
||||
py::return_value_policy::reference_internal);
|
||||
m.def("get_NestA", [](const NestA &a) { return a.value; });
|
||||
|
||||
struct NestB {
|
||||
NestA a;
|
||||
int value = 4;
|
||||
NestB& operator-=(int i) { value -= i; return *this; }
|
||||
NestB &operator-=(int i) {
|
||||
value -= i;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
py::class_<NestB>(m, "NestB")
|
||||
.def(py::init<>())
|
||||
@@ -189,7 +234,10 @@ TEST_SUBMODULE(operators, m) {
|
||||
struct NestC {
|
||||
NestB b;
|
||||
int value = 5;
|
||||
NestC& operator*=(int i) { value *= i; return *this; }
|
||||
NestC &operator*=(int i) {
|
||||
value *= i;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
py::class_<NestC>(m, "NestC")
|
||||
.def(py::init<>())
|
||||
@@ -197,16 +245,15 @@ TEST_SUBMODULE(operators, m) {
|
||||
.def_readwrite("b", &NestC::b);
|
||||
m.def("get_NestC", [](const NestC &c) { return c.value; });
|
||||
|
||||
|
||||
// test_overriding_eq_reset_hash
|
||||
// #2191 Overriding __eq__ should set __hash__ to None
|
||||
struct Comparable {
|
||||
int value;
|
||||
bool operator==(const Comparable& rhs) const {return value == rhs.value;}
|
||||
bool operator==(const Comparable &rhs) const { return value == rhs.value; }
|
||||
};
|
||||
|
||||
struct Hashable : Comparable {
|
||||
explicit Hashable(int value): Comparable{value}{};
|
||||
explicit Hashable(int value) : Comparable{value} {};
|
||||
size_t hash() const { return static_cast<size_t>(value); }
|
||||
};
|
||||
|
||||
@@ -214,9 +261,7 @@ TEST_SUBMODULE(operators, m) {
|
||||
using Hashable::Hashable;
|
||||
};
|
||||
|
||||
py::class_<Comparable>(m, "Comparable")
|
||||
.def(py::init<int>())
|
||||
.def(py::self == py::self);
|
||||
py::class_<Comparable>(m, "Comparable").def(py::init<int>()).def(py::self == py::self);
|
||||
|
||||
py::class_<Hashable>(m, "Hashable")
|
||||
.def(py::init<int>())
|
||||
@@ -228,8 +273,9 @@ TEST_SUBMODULE(operators, m) {
|
||||
.def("__hash__", &Hashable::hash)
|
||||
.def(py::init<int>())
|
||||
.def(py::self == py::self);
|
||||
}
|
||||
|
||||
#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
// define __eq__ but not __hash__
|
||||
py::class_<HashMe>(m, "HashMe").def(py::self == py::self);
|
||||
|
||||
m.def("get_unhashable_HashMe_set", []() { return std::unordered_set<HashMe>{{"one"}}; });
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user