You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

249 lines
10 KiB

  1. #pragma once
  2. /*
  3. tests/constructor_stats.h -- framework for printing and tracking object
  4. instance lifetimes in example/test code.
  5. Copyright (c) 2016 Jason Rhinelander <jason@imaginary.ca>
  6. All rights reserved. Use of this source code is governed by a
  7. BSD-style license that can be found in the LICENSE file.
  8. This header provides a few useful tools for writing examples or tests that want to check and/or
  9. display object instance lifetimes. It requires that you include this header and add the following
  10. function calls to constructors:
  11. class MyClass {
  12. MyClass() { ...; print_default_created(this); }
  13. ~MyClass() { ...; print_destroyed(this); }
  14. MyClass(const MyClass &c) { ...; print_copy_created(this); }
  15. MyClass(MyClass &&c) { ...; print_move_created(this); }
  16. MyClass(int a, int b) { ...; print_created(this, a, b); }
  17. MyClass &operator=(const MyClass &c) { ...; print_copy_assigned(this); }
  18. MyClass &operator=(MyClass &&c) { ...; print_move_assigned(this); }
  19. ...
  20. }
  21. You can find various examples of these in several of the existing example .cpp files. (Of course
  22. you don't need to add any of the above constructors/operators that you don't actually have, except
  23. for the destructor).
  24. Each of these will print an appropriate message such as:
  25. ### MyClass @ 0x2801910 created via default constructor
  26. ### MyClass @ 0x27fa780 created 100 200
  27. ### MyClass @ 0x2801910 destroyed
  28. ### MyClass @ 0x27fa780 destroyed
  29. You can also include extra arguments (such as the 100, 200 in the output above, coming from the
  30. value constructor) for all of the above methods which will be included in the output.
  31. For testing, each of these also keeps track the created instances and allows you to check how many
  32. of the various constructors have been invoked from the Python side via code such as:
  33. from example import ConstructorStats
  34. cstats = ConstructorStats.get(MyClass)
  35. print(cstats.alive())
  36. print(cstats.default_constructions)
  37. Note that `.alive()` should usually be the first thing you call as it invokes Python's garbage
  38. collector to actually destroy objects that aren't yet referenced.
  39. For everything except copy and move constructors and destructors, any extra values given to the
  40. print_...() function is stored in a class-specific values list which you can retrieve and inspect
  41. from the ConstructorStats instance `.values()` method.
  42. In some cases, when you need to track instances of a C++ class not registered with pybind11, you
  43. need to add a function returning the ConstructorStats for the C++ class; this can be done with:
  44. m.def("get_special_cstats", &ConstructorStats::get<SpecialClass>, py::return_value_policy::reference)
  45. Finally, you can suppress the output messages, but keep the constructor tracking (for
  46. inspection/testing in python) by using the functions with `print_` replaced with `track_` (e.g.
  47. `track_copy_created(this)`).
  48. */
  49. #include "pybind11_tests.h"
  50. #include <unordered_map>
  51. #include <list>
  52. #include <typeindex>
  53. #include <sstream>
  54. class ConstructorStats {
  55. protected:
  56. std::unordered_map<void*, int> _instances; // Need a map rather than set because members can shared address with parents
  57. std::list<std::string> _values; // Used to track values (e.g. of value constructors)
  58. public:
  59. int default_constructions = 0;
  60. int copy_constructions = 0;
  61. int move_constructions = 0;
  62. int copy_assignments = 0;
  63. int move_assignments = 0;
  64. void copy_created(void *inst) {
  65. created(inst);
  66. copy_constructions++;
  67. }
  68. void move_created(void *inst) {
  69. created(inst);
  70. move_constructions++;
  71. }
  72. void default_created(void *inst) {
  73. created(inst);
  74. default_constructions++;
  75. }
  76. void created(void *inst) {
  77. ++_instances[inst];
  78. };
  79. void destroyed(void *inst) {
  80. if (--_instances[inst] < 0)
  81. throw std::runtime_error("cstats.destroyed() called with unknown instance; potential double-destruction or a missing cstats.created()");
  82. }
  83. int alive() {
  84. // Force garbage collection to ensure any pending destructors are invoked:
  85. py::module::import("gc").attr("collect")();
  86. int total = 0;
  87. for (const auto &p : _instances) if (p.second > 0) total += p.second;
  88. return total;
  89. }
  90. void value() {} // Recursion terminator
  91. // Takes one or more values, converts them to strings, then stores them.
  92. template <typename T, typename... Tmore> void value(const T &v, Tmore &&...args) {
  93. std::ostringstream oss;
  94. oss << v;
  95. _values.push_back(oss.str());
  96. value(std::forward<Tmore>(args)...);
  97. }
  98. // Move out stored values
  99. py::list values() {
  100. py::list l;
  101. for (const auto &v : _values) l.append(py::cast(v));
  102. _values.clear();
  103. return l;
  104. }
  105. // Gets constructor stats from a C++ type index
  106. static ConstructorStats& get(std::type_index type) {
  107. static std::unordered_map<std::type_index, ConstructorStats> all_cstats;
  108. return all_cstats[type];
  109. }
  110. // Gets constructor stats from a C++ type
  111. template <typename T> static ConstructorStats& get() {
  112. return get(typeid(T));
  113. }
  114. // Gets constructor stats from a Python class
  115. static ConstructorStats& get(py::object class_) {
  116. auto &internals = py::detail::get_internals();
  117. const std::type_index *t1 = nullptr, *t2 = nullptr;
  118. try {
  119. auto *type_info = internals.registered_types_py.at(class_.ptr());
  120. for (auto &p : internals.registered_types_cpp) {
  121. if (p.second == type_info) {
  122. if (t1) {
  123. t2 = &p.first;
  124. break;
  125. }
  126. t1 = &p.first;
  127. }
  128. }
  129. }
  130. catch (std::out_of_range) {}
  131. if (!t1) throw std::runtime_error("Unknown class passed to ConstructorStats::get()");
  132. auto &cs1 = get(*t1);
  133. // If we have both a t1 and t2 match, one is probably the trampoline class; return whichever
  134. // has more constructions (typically one or the other will be 0)
  135. if (t2) {
  136. auto &cs2 = get(*t2);
  137. int cs1_total = cs1.default_constructions + cs1.copy_constructions + cs1.move_constructions + (int) cs1._values.size();
  138. int cs2_total = cs2.default_constructions + cs2.copy_constructions + cs2.move_constructions + (int) cs2._values.size();
  139. if (cs2_total > cs1_total) return cs2;
  140. }
  141. return cs1;
  142. }
  143. };
  144. // To track construction/destruction, you need to call these methods from the various
  145. // constructors/operators. The ones that take extra values record the given values in the
  146. // constructor stats values for later inspection.
  147. template <class T> void track_copy_created(T *inst) { ConstructorStats::get<T>().copy_created(inst); }
  148. template <class T> void track_move_created(T *inst) { ConstructorStats::get<T>().move_created(inst); }
  149. template <class T, typename... Values> void track_copy_assigned(T *, Values &&...values) {
  150. auto &cst = ConstructorStats::get<T>();
  151. cst.copy_assignments++;
  152. cst.value(std::forward<Values>(values)...);
  153. }
  154. template <class T, typename... Values> void track_move_assigned(T *, Values &&...values) {
  155. auto &cst = ConstructorStats::get<T>();
  156. cst.move_assignments++;
  157. cst.value(std::forward<Values>(values)...);
  158. }
  159. template <class T, typename... Values> void track_default_created(T *inst, Values &&...values) {
  160. auto &cst = ConstructorStats::get<T>();
  161. cst.default_created(inst);
  162. cst.value(std::forward<Values>(values)...);
  163. }
  164. template <class T, typename... Values> void track_created(T *inst, Values &&...values) {
  165. auto &cst = ConstructorStats::get<T>();
  166. cst.created(inst);
  167. cst.value(std::forward<Values>(values)...);
  168. }
  169. template <class T, typename... Values> void track_destroyed(T *inst) {
  170. ConstructorStats::get<T>().destroyed(inst);
  171. }
  172. template <class T, typename... Values> void track_values(T *, Values &&...values) {
  173. ConstructorStats::get<T>().value(std::forward<Values>(values)...);
  174. }
  175. /// Don't cast pointers to Python, print them as strings
  176. inline const char *format_ptrs(const char *p) { return p; }
  177. template <typename T>
  178. py::str format_ptrs(T *p) { return "{:#x}"_s.format(reinterpret_cast<std::uintptr_t>(p)); }
  179. template <typename T>
  180. auto format_ptrs(T &&x) -> decltype(std::forward<T>(x)) { return std::forward<T>(x); }
  181. template <class T, typename... Output>
  182. void print_constr_details(T *inst, const std::string &action, Output &&...output) {
  183. py::print("###", py::type_id<T>(), "@", format_ptrs(inst), action,
  184. format_ptrs(std::forward<Output>(output))...);
  185. }
  186. // Verbose versions of the above:
  187. template <class T, typename... Values> void print_copy_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
  188. print_constr_details(inst, "created via copy constructor", values...);
  189. track_copy_created(inst);
  190. }
  191. template <class T, typename... Values> void print_move_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
  192. print_constr_details(inst, "created via move constructor", values...);
  193. track_move_created(inst);
  194. }
  195. template <class T, typename... Values> void print_copy_assigned(T *inst, Values &&...values) {
  196. print_constr_details(inst, "assigned via copy assignment", values...);
  197. track_copy_assigned(inst, values...);
  198. }
  199. template <class T, typename... Values> void print_move_assigned(T *inst, Values &&...values) {
  200. print_constr_details(inst, "assigned via move assignment", values...);
  201. track_move_assigned(inst, values...);
  202. }
  203. template <class T, typename... Values> void print_default_created(T *inst, Values &&...values) {
  204. print_constr_details(inst, "created via default constructor", values...);
  205. track_default_created(inst, values...);
  206. }
  207. template <class T, typename... Values> void print_created(T *inst, Values &&...values) {
  208. print_constr_details(inst, "created", values...);
  209. track_created(inst, values...);
  210. }
  211. template <class T, typename... Values> void print_destroyed(T *inst, Values &&...values) { // Prints but doesn't store given values
  212. print_constr_details(inst, "destroyed", values...);
  213. track_destroyed(inst);
  214. }
  215. template <class T, typename... Values> void print_values(T *inst, Values &&...values) {
  216. print_constr_details(inst, ":", values...);
  217. track_values(inst, values...);
  218. }