Improve constructor/destructor tracking

example/CMakeLists.txt

@@ -60,9 +60,6 @@ foreach(CompilerFlag ${CompilerFlags})
 endforeach()
 
 set(RUN_TEST ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py)
-if(MSVC OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
-  set(RUN_TEST ${RUN_TEST} --relaxed)
-endif()
 
 foreach(VALUE ${PYBIND11_EXAMPLES})
   string(REGEX REPLACE "^(.+).cpp$" "\\1" EXAMPLE_NAME "${VALUE}")

example/constructor-stats.h

@@ -0,0 +1,243 @@
+#pragma once
+/*
+    example/constructor-stats.h -- framework for printing and tracking object
+    instance lifetimes in example/test code.
+
+    Copyright (c) 2016 Jason Rhinelander <jason@imaginary.ca>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+
+This header provides a few useful tools for writing examples or tests that want to check and/or
+display object instance lifetimes.  It requires that you include this header and add the following
+function calls to constructors:
+
+    class MyClass {
+        MyClass() { ...; print_default_created(this); }
+        ~MyClass() { ...; print_destroyed(this); }
+        MyClass(const MyClass &c) { ...; print_copy_created(this); }
+        MyClass(MyClass &&c) { ...; print_move_created(this); }
+        MyClass(int a, int b) { ...; print_created(this, a, b); }
+        MyClass &operator=(const MyClass &c) { ...; print_copy_assigned(this); }
+        MyClass &operator=(MyClass &&c) { ...; print_move_assigned(this); }
+
+        ...
+    }
+
+You can find various examples of these in several of the existing example .cpp files.  (Of course
+you don't need to add any of the above constructors/operators that you don't actually have, except
+for the destructor).
+
+Each of these will print an appropriate message such as:
+
+    ### MyClass @ 0x2801910 created via default constructor
+    ### MyClass @ 0x27fa780 created 100 200
+    ### MyClass @ 0x2801910 destroyed
+    ### MyClass @ 0x27fa780 destroyed
+
+You can also include extra arguments (such as the 100, 200 in the output above, coming from the
+value constructor) for all of the above methods which will be included in the output.
+
+For testing, each of these also keeps track the created instances and allows you to check how many
+of the various constructors have been invoked from the Python side via code such as:
+
+    from example import ConstructorStats
+    cstats = ConstructorStats.get(MyClass)
+    print(cstats.alive())
+    print(cstats.default_constructions)
+
+Note that `.alive()` should usually be the first thing you call as it invokes Python's garbage
+collector to actually destroy objects that aren't yet referenced.
+
+For everything except copy and move constructors and destructors, any extra values given to the
+print_...() function is stored in a class-specific values list which you can retrieve and inspect
+from the ConstructorStats instance `.values()` method.
+
+In some cases, when you need to track instances of a C++ class not registered with pybind11, you
+need to add a function returning the ConstructorStats for the C++ class; this can be done with:
+
+    m.def("get_special_cstats", &ConstructorStats::get<SpecialClass>, py::return_value_policy::reference_internal)
+
+Finally, you can suppress the output messages, but keep the constructor tracking (for
+inspection/testing in python) by using the functions with `print_` replaced with `track_` (e.g.
+`track_copy_created(this)`).
+
+*/
+
+#include "example.h"
+#include <unordered_map>
+#include <list>
+#include <typeindex>
+#include <sstream>
+
+class ConstructorStats {
+protected:
+    std::unordered_map<void*, int> _instances; // Need a map rather than set because members can shared address with parents
+    std::list<std::string> _values; // Used to track values (e.g. of value constructors)
+public:
+    int default_constructions = 0;
+    int copy_constructions = 0;
+    int move_constructions = 0;
+    int copy_assignments = 0;
+    int move_assignments = 0;
+
+    void copy_created(void *inst) {
+        created(inst);
+        copy_constructions++;
+    }
+    void move_created(void *inst) {
+        created(inst);
+        move_constructions++;
+    }
+    void default_created(void *inst) {
+        created(inst);
+        default_constructions++;
+    }
+    void created(void *inst) {
+        ++_instances[inst];
+    };
+    void destroyed(void *inst) {
+        if (--_instances[inst] < 0)
+            throw std::runtime_error("cstats.destroyed() called with unknown instance; potential double-destruction or a missing cstats.created()");
+    }
+
+    int alive() {
+        // Force garbage collection to ensure any pending destructors are invoked:
+        py::module::import("gc").attr("collect").operator py::object()();
+        int total = 0;
+        for (const auto &p : _instances) if (p.second > 0) total += p.second;
+        return total;
+    }
+
+    void value() {} // Recursion terminator
+    // Takes one or more values, converts them to strings, then stores them.
+    template <typename T, typename... Tmore> void value(const T &v, Tmore &&...args) {
+        std::ostringstream oss;
+        oss << v;
+        _values.push_back(oss.str());
+        value(std::forward<Tmore>(args)...);
+    }
+    py::list values() {
+        py::list l;
+        for (const auto &v : _values) l.append(py::cast(v));
+        return l;
+    }
+
+    // Gets constructor stats from a C++ type index
+    static ConstructorStats& get(std::type_index type) {
+        static std::unordered_map<std::type_index, ConstructorStats> all_cstats;
+        return all_cstats[type];
+    }
+
+    // Gets constructor stats from a C++ type
+    template <typename T> static ConstructorStats& get() {
+        return get(typeid(T));
+    }
+
+    // Gets constructor stats from a Python class
+    static ConstructorStats& get(py::object class_) {
+        auto &internals = py::detail::get_internals();
+        const std::type_index *t1 = nullptr, *t2 = nullptr;
+        try {
+            auto *type_info = internals.registered_types_py.at(class_.ptr());
+            for (auto &p : internals.registered_types_cpp) {
+                if (p.second == type_info) {
+                    if (t1) {
+                        t2 = &p.first;
+                        break;
+                    }
+                    t1 = &p.first;
+                }
+            }
+        }
+        catch (std::out_of_range) {}
+        if (!t1) throw std::runtime_error("Unknown class passed to ConstructorStats::get()");
+        auto &cs1 = get(*t1);
+        // If we have both a t1 and t2 match, one is probably the trampoline class; return whichever
+        // has more constructions (typically one or the other will be 0)
+        if (t2) {
+            auto &cs2 = get(*t2);
+            int cs1_total = cs1.default_constructions + cs1.copy_constructions + cs1.move_constructions + (int) cs1._values.size();
+            int cs2_total = cs2.default_constructions + cs2.copy_constructions + cs2.move_constructions + (int) cs2._values.size();
+            if (cs2_total > cs1_total) return cs2;
+        }
+        return cs1;
+    }
+};
+
+// To track construction/destruction, you need to call these methods from the various
+// constructors/operators.  The ones that take extra values record the given values in the
+// constructor stats values for later inspection.
+template <class T> void track_copy_created(T *inst) { ConstructorStats::get<T>().copy_created(inst); }
+template <class T> void track_move_created(T *inst) { ConstructorStats::get<T>().move_created(inst); }
+template <class T, typename... Values> void track_copy_assigned(T *, Values &&...values) {
+    auto &cst = ConstructorStats::get<T>();
+    cst.copy_assignments++;
+    cst.value(std::forward<Values>(values)...);
+}
+template <class T, typename... Values> void track_move_assigned(T *, Values &&...values) {
+    auto &cst = ConstructorStats::get<T>();
+    cst.move_assignments++;
+    cst.value(std::forward<Values>(values)...);
+}
+template <class T, typename... Values> void track_default_created(T *inst, Values &&...values) {
+    auto &cst = ConstructorStats::get<T>();
+    cst.default_created(inst);
+    cst.value(std::forward<Values>(values)...);
+}
+template <class T, typename... Values> void track_created(T *inst, Values &&...values) {
+    auto &cst = ConstructorStats::get<T>();
+    cst.created(inst);
+    cst.value(std::forward<Values>(values)...);
+}
+template <class T, typename... Values> void track_destroyed(T *inst) {
+    ConstructorStats::get<T>().destroyed(inst);
+}
+template <class T, typename... Values> void track_values(T *, Values &&...values) {
+    ConstructorStats::get<T>().value(std::forward<Values>(values)...);
+}
+
+inline void print_constr_details_more() { std::cout << std::endl; }
+template <typename Head, typename... Tail> void print_constr_details_more(const Head &head, Tail &&...tail) {
+    std::cout << " " << head;
+    print_constr_details_more(std::forward<Tail>(tail)...);
+}
+template <class T, typename... Output> void print_constr_details(T *inst, const std::string &action, Output &&...output) {
+    std::cout << "### " << py::type_id<T>() << " @ " << inst << " " << action;
+    print_constr_details_more(std::forward<Output>(output)...);
+}
+
+// Verbose versions of the above:
+template <class T, typename... Values> void print_copy_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
+    print_constr_details(inst, "created via copy constructor", values...);
+    track_copy_created(inst);
+}
+template <class T, typename... Values> void print_move_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
+    print_constr_details(inst, "created via move constructor", values...);
+    track_move_created(inst);
+}
+template <class T, typename... Values> void print_copy_assigned(T *inst, Values &&...values) {
+    print_constr_details(inst, "assigned via copy assignment", values...);
+    track_copy_assigned(inst, values...);
+}
+template <class T, typename... Values> void print_move_assigned(T *inst, Values &&...values) {
+    print_constr_details(inst, "assigned via move assignment", values...);
+    track_move_assigned(inst, values...);
+}
+template <class T, typename... Values> void print_default_created(T *inst, Values &&...values) {
+    print_constr_details(inst, "created via default constructor", values...);
+    track_default_created(inst, values...);
+}
+template <class T, typename... Values> void print_created(T *inst, Values &&...values) {
+    print_constr_details(inst, "created", values...);
+    track_created(inst, values...);
+}
+template <class T, typename... Values> void print_destroyed(T *inst, Values &&...values) { // Prints but doesn't store given values
+    print_constr_details(inst, "destroyed", values...);
+    track_destroyed(inst);
+}
+template <class T, typename... Values> void print_values(T *inst, Values &&...values) {
+    print_constr_details(inst, ":", values...);
+    track_values(inst, values...);
+}
+

example/example-buffers.cpp

@@ -8,35 +8,36 @@
 */
 
 #include "example.h"
+#include "constructor-stats.h"
 
 class Matrix {
 public:
     Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) {
-        std::cout << "Value constructor: Creating a " << rows << "x" << cols << " matrix " << std::endl;
+        print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
         m_data = new float[rows*cols];
         memset(m_data, 0, sizeof(float) * rows * cols);
     }
 
     Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
-        std::cout << "Copy constructor: Creating a " << m_rows << "x" << m_cols << " matrix " << std::endl;
+        print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
         m_data = new float[m_rows * m_cols];
         memcpy(m_data, s.m_data, sizeof(float) * m_rows * m_cols);
     }
 
     Matrix(Matrix &&s) : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
-        std::cout << "Move constructor: Creating a " << m_rows << "x" << m_cols << " matrix " << std::endl;
+        print_move_created(this);
         s.m_rows = 0;
         s.m_cols = 0;
         s.m_data = nullptr;
     }
 
     ~Matrix() {
-        std::cout << "Freeing a " << m_rows << "x" << m_cols << " matrix " << std::endl;
+        print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
         delete[] m_data;
     }
 
     Matrix &operator=(const Matrix &s) {
-        std::cout << "Assignment operator : Creating a " << s.m_rows << "x" << s.m_cols << " matrix " << std::endl;
+        print_copy_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
         delete[] m_data;
         m_rows = s.m_rows;
         m_cols = s.m_cols;
@@ -46,7 +47,7 @@ class Matrix {
     }
 
     Matrix &operator=(Matrix &&s) {
-        std::cout << "Move assignment operator : Creating a " << s.m_rows << "x" << s.m_cols << " matrix " << std::endl;
+        print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
         if (&s != this) {
             delete[] m_data;
             m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data;
@@ -111,5 +112,6 @@ void init_ex_buffers(py::module &m) {
                 { sizeof(float) * m.rows(),          /* Strides (in bytes) for each index */
                   sizeof(float) }
             );
-        });
+        })
+        ;
 }

example/example-buffers.py

@@ -30,3 +30,16 @@
     for j in range(m4.cols()):
         print(m4[i, j], end = ' ')
     print()
+
+from example import ConstructorStats
+cstats = ConstructorStats.get(Matrix)
+print("Instances not destroyed:", cstats.alive())
+m = m4 = None
+print("Instances not destroyed:", cstats.alive())
+m2 = None # m2 holds an m reference
+print("Instances not destroyed:", cstats.alive())
+print("Constructor values:", cstats.values())
+print("Copy constructions:", cstats.copy_constructions)
+#print("Move constructions:", cstats.move_constructions >= 0) # Don't invoke any
+print("Copy assignments:", cstats.copy_assignments)
+print("Move assignments:", cstats.move_assignments)

example/example-buffers.ref

@@ -1,4 +1,4 @@
-Value constructor: Creating a 5x5 matrix 
+### Matrix @ 0x1df1920 created 5x5 matrix
 0.0
 4.0
 [[ 0.  0.  0.  0.  0.]
@@ -10,8 +10,15 @@ Value constructor: Creating a 5x5 matrix
 5.0
 [[ 1.  2.  3.]
  [ 4.  5.  6.]]
-Value constructor: Creating a 2x3 matrix 
+### Matrix @ 0x1fa8cf0 created 2x3 matrix
 1.0 2.0 3.0 
 4.0 5.0 6.0 
-Freeing a 2x3 matrix 
-Freeing a 5x5 matrix 
+Instances not destroyed: 2
+### Matrix @ 0x1fa8cf0 destroyed 2x3 matrix
+Instances not destroyed: 1
+### Matrix @ 0x1df1920 destroyed 5x5 matrix
+Instances not destroyed: 0
+Constructor values: ['5x5 matrix', '2x3 matrix']
+Copy constructions: 0
+Copy assignments: 0
+Move assignments: 0