Wrap boost::python::object

Solves a race condition on the destruction of instances of
boost::python::object

Author: ayllon

SEImplementation/src/lib/Configuration/ModelFittingConfig.cpp

@@ -36,7 +36,7 @@ namespace SExtractor {
  *  Elements::Exception if either the call or the extract throw a Python exception
  */
 template <typename R, typename ...T>
-R py_call_wrapper(py::object func, T... args) {
+R py_call_wrapper(const py::object& func, T... args) {
   try {
     return py::extract<R>(func(args...));
   }
@@ -45,13 +45,47 @@ R py_call_wrapper(py::object func, T... args) {
   }
 }
 
+/**
+ * @brief Hold a reference to a Python object
+ * @details
+ *  A boost::python::object contains a pointer to the underlying Python struct, which is
+ *  copied as-is (shared) when copied. When the boost::python::object is destroyed, it checks,
+ *  and then decrements, the reference count. This destruction is *not* thread safe, as the pointer
+ *  is not protected by a mutex or anything.
+ *  This class holds a single reference to the Python object, and relies on the mechanism of
+ *  std::shared_ptr to destroy the object once there is no one using it. std::shared_ptr *is*
+ *  thread safe, unlike boost::python::object.
+ */
+class PyObjectHolder {
+  public:
+    PyObjectHolder(py::object&& obj): m_obj_ptr(std::make_shared<py::object>(obj)) {}
+
+    PyObjectHolder(const PyObjectHolder&) = default;
+    PyObjectHolder(PyObjectHolder&&) = default;
+
+    operator const py::object&() const {
+      return *m_obj_ptr;
+    }
+
+    const py::object& operator *() const {
+      return *m_obj_ptr;
+    }
+
+    py::object attr(const char *name) {
+      return m_obj_ptr->attr(name);
+    }
+
+  private:
+    std::shared_ptr<py::object> m_obj_ptr;
+};
+
 ModelFittingConfig::ModelFittingConfig(long manager_id) : Configuration(manager_id) {
   declareDependency<PythonConfig>();
 }
 
 void ModelFittingConfig::initialize(const UserValues&) {
   for (auto& p : getDependency<PythonConfig>().getInterpreter().getConstantParameters()) {
-    py::object py_value_func = p.second.attr("get_value")();
+    auto py_value_func = PyObjectHolder(p.second.attr("get_value")());
     auto value_func = [py_value_func] (const SourceInterface& o) -> double {
       ObjectInfo oi {o};
       return py_call_wrapper<double>(py_value_func, oi);
@@ -61,25 +95,25 @@ void ModelFittingConfig::initialize(const UserValues&) {
   }
 
   for (auto& p : getDependency<PythonConfig>().getInterpreter().getFreeParameters()) {
-    py::object py_init_value_func = p.second.attr("get_init_value")();
+    auto py_init_value_func = PyObjectHolder(p.second.attr("get_init_value")());
     auto init_value_func = [py_init_value_func] (const SourceInterface& o) -> double {
       ObjectInfo oi {o};
       return py_call_wrapper<double>(py_init_value_func, oi);
     };
 
-    py::object py_range_obj = p.second.attr("get_range")();
+    auto py_range_obj = PyObjectHolder(p.second.attr("get_range")());
 
     std::shared_ptr<FlexibleModelFittingConverterFactory> converter;
     std::string type_string(py::extract<char const*>(py_range_obj.attr("__class__").attr("__name__")));
     if (type_string == "Unbounded") {
-      py::object py_factor_func = py_range_obj.attr("get_normalization_factor")();
+      auto py_factor_func = PyObjectHolder(py_range_obj.attr("get_normalization_factor")());
       auto factor_func = [py_factor_func] (double init, const SourceInterface& o) -> double {
         ObjectInfo oi {o};
         return py_call_wrapper<double>(py_factor_func, init, oi);
       };
       converter = std::make_shared<FlexibleModelFittingUnboundedConverterFactory>(factor_func);
     } else if (type_string == "Range") {
-      py::object py_range_func = py_range_obj.attr("get_limits")();
+      auto py_range_func = PyObjectHolder(py_range_obj.attr("get_limits")());
       auto range_func = [py_range_func] (double init, const SourceInterface& o) -> std::pair<double, double> {
         ObjectInfo oi {o};
         py::tuple range = py_call_wrapper<py::tuple>(py_range_func, init, oi);
@@ -102,7 +136,7 @@ void ModelFittingConfig::initialize(const UserValues&) {
   }
 
   for (auto& p : getDependency<PythonConfig>().getInterpreter().getDependentParameters()) {
-    py::object py_func = p.second.attr("func");
+    auto py_func = PyObjectHolder(p.second.attr("func"));
     std::vector<std::shared_ptr<FlexibleModelFittingParameter>> params {};
     py::list param_ids = py::extract<py::list>(p.second.attr("params"));
     for (int i = 0; i < py::len(param_ids); ++i) {
@@ -113,7 +147,7 @@ void ModelFittingConfig::initialize(const UserValues&) {
     auto dependent_func = [py_func](const std::shared_ptr<CoordinateSystem> &cs, const std::vector<double> &params) -> double {
       try {
         PythonInterpreter::getSingleton().setCoordinateSystem(cs);
-        return py::extract<double>(py_func(*py::tuple(params)));
+        return py::extract<double>((*py_func)(*py::tuple(params)));
       }
       catch (const py::error_already_set&) {
         throw pyToElementsException(logger);
@@ -182,12 +216,12 @@ void ModelFittingConfig::initialize(const UserValues&) {
     auto& prior = p.second;
     int param_id = py::extract<int>(prior.attr("param"));
     auto param = m_parameters[param_id];
-    py::object py_value_func = prior.attr("value");
+    auto py_value_func = PyObjectHolder(prior.attr("value"));
     auto value_func = [py_value_func] (const SourceInterface& o) -> double {
       ObjectInfo oi {o};
       return py_call_wrapper<double>(py_value_func, oi);
     };
-    py::object py_sigma_func = prior.attr("sigma");
+    auto py_sigma_func = PyObjectHolder(prior.attr("sigma"));
     auto sigma_func = [py_sigma_func] (const SourceInterface& o) -> double {
       ObjectInfo oi {o};
       return py_call_wrapper<double>(py_sigma_func, oi);