Add test_perf_accessors (to be merged into test_pytypes).

Author: rwgk

include/pybind11/pytypes.h

@@ -180,6 +180,10 @@ class object_api : public pyobject_tag {
 
 PYBIND11_NAMESPACE_END(detail)
 
+#if !defined(PYBIND11_HANDLE_REF_DEBUG) && !defined(NDEBUG)
+#    define PYBIND11_HANDLE_REF_DEBUG
+#endif
+
 /** \rst
     Holds a reference to a Python object (no reference counting)
 
@@ -209,6 +213,9 @@ class handle : public detail::object_api<handle> {
         this function automatically. Returns a reference to itself.
     \endrst */
     const handle &inc_ref() const & {
+#ifdef PYBIND11_HANDLE_REF_DEBUG
+        inc_ref_counter(1);
+#endif
         Py_XINCREF(m_ptr);
         return *this;
     }
@@ -244,6 +251,18 @@ class handle : public detail::object_api<handle> {
 
 protected:
     PyObject *m_ptr = nullptr;
+
+#ifdef PYBIND11_HANDLE_REF_DEBUG
+private:
+    std::size_t static inc_ref_counter(std::size_t add) {
+        static std::size_t counter = 0;
+        counter += add;
+        return counter;
+    }
+
+public:
+    std::size_t static inc_ref_counter() { return inc_ref_counter(0); }
+#endif
 };
 
 /** \rst

tests/CMakeLists.txt

@@ -145,6 +145,7 @@ set(PYBIND11_TEST_FILES
     test_numpy_vectorize
     test_opaque_types
     test_operator_overloading
+    test_perf_accessors
     test_pickling
     test_pytypes
     test_sequences_and_iterators

tests/test_perf_accessors.cpp

@@ -0,0 +1,44 @@
+#include "pybind11_tests.h"
+
+namespace test_perf_accessors {
+
+py::object perf_list_accessor(std::size_t num_iterations, int test_id) {
+    py::list l;
+    l.append(0);
+    auto var = l[0]; // Type of var is list accessor.
+    py::int_ answer(42);
+    var = answer; // Detach var from list, which releases a reference.
+#ifdef PYBIND11_HANDLE_REF_DEBUG
+    if (num_iterations == 0) {
+        py::list return_list;
+        std::size_t inc_refs = py::handle::inc_ref_counter();
+        var = answer;
+        inc_refs = py::handle::inc_ref_counter() - inc_refs;
+        return_list.append(inc_refs);
+        inc_refs = py::handle::inc_ref_counter();
+        var = 42;
+        inc_refs = py::handle::inc_ref_counter() - inc_refs;
+        return_list.append(inc_refs);
+        return return_list;
+    }
+#endif
+    if (test_id == 0) {
+        while (num_iterations != 0u) {
+            var = answer;
+            num_iterations--;
+        }
+    } else {
+        while (num_iterations != 0u) {
+            var = 42;
+            num_iterations--;
+        }
+    }
+    return py::none();
+}
+
+} // namespace test_perf_accessors
+
+TEST_SUBMODULE(perf_accessors, m) {
+    using namespace test_perf_accessors;
+    m.def("perf_list_accessor", perf_list_accessor);
+}

tests/test_perf_accessors.py

@@ -0,0 +1,51 @@
+import time
+
+from pybind11_tests import perf_accessors as m
+
+
+def find_num_iterations(
+    callable,
+    callable_args,
+    num_iterations_first_pass,
+    num_iterations_target_elapsed_secs,
+    time_delta_floor=1.0e-6,
+    target_elapsed_secs_multiplier=1.05,  # Empirical.
+    target_elapsed_secs_tolerance=0.05,
+    search_max_iterations=100,
+):
+    td_target = num_iterations_target_elapsed_secs * target_elapsed_secs_multiplier
+    num_iterations = num_iterations_first_pass
+    for _ in range(search_max_iterations):
+        t0 = time.time()
+        callable(num_iterations, *callable_args)
+        td = time.time() - t0
+        num_iterations = max(
+            1, int(td_target * num_iterations / max(td, time_delta_floor))
+        )
+        if abs(td - td_target) / td_target < target_elapsed_secs_tolerance:
+            return num_iterations
+    raise RuntimeError("find_num_iterations failure: search_max_iterations exceeded.")
+
+
+def test_perf_list_accessor():
+    print(flush=True)
+    inc_refs = m.perf_list_accessor(0, 0)
+    print(f"{inc_refs=}", flush=True)
+    if inc_refs is not None:
+        assert inc_refs == [1, 1]
+    num_iterations = find_num_iterations(
+        callable=m.perf_list_accessor,
+        callable_args=(0,),
+        num_iterations_first_pass=100000,
+        num_iterations_target_elapsed_secs=2.0,
+    )
+    for test_id in range(2):
+        t0 = time.time()
+        m.perf_list_accessor(num_iterations, test_id)
+        secs = time.time() - t0
+        u_secs = secs * 10e6
+        per_call = u_secs / num_iterations
+        print(
+            f"PERF {test_id},{num_iterations},{secs:.3f}s,{per_call:.6f}μs",
+            flush=True,
+        )