1

我正在为我的项目编写 python 包装器，它使用 Eigen 进行数学计算。在测试基本操作后，在 python 中创建的 eigen 对象总是返回错误的结果。当我不尊重使用 Eigen 的数据对齐时，这通常发生在我身上。这是通过使用 Eigen::aligned_allocator 分配特征对象来解决的。如何告诉 boost 使用 Eigen::aligned_allocator 分配特征对象？

这是一个简单的测试：

C++

using namespace boost::python;
using namespace Eigen;
class_<Isometry3d>("Isometry3d", init<>())
    .def("__str__", make_function(IsometryToStr)) 
    .def_readonly("Identity", Isometry3d::Identity())
;

IsometryToStr 函数仅使用由 Eigen 定义的运算符 <<。

Python：

a = Isometry3d.Identity
print a

我们希望它打印单位矩阵，但结果总是不同的。

4

1 回答 1

1

要控制 C++ 类型的分配，请将工厂函数注册为 Python 对象的构造函数，使用make_constructor. 很多时候，自定义分配也意味着自定义解除分配，在这种情况下boost::shared_ptr可以用来管理对象的生命周期并调用自定义解除分配策略。这个答案更详细，但这是一个带有基本自定义分配器的完整示例。

#include <cstdlib>
#include <boost/python.hpp>
#include <boost/shared_ptr.hpp>

///  @brief Basic custom allocator.
template <typename T>
class custom_allocator
{
public:
  typedef size_t size_type;
  typedef T*     pointer;
  typedef T      value_type;
public:
  pointer allocate(size_type num, const void* hint = 0)
  {
    std::cout << "custom_allocator::allocate()" << std::endl;
    return reinterpret_cast<pointer>(
      std::malloc(num * sizeof(value_type)));
  }

  void deallocate(pointer p, size_type num)
  {
    std::cout << "custom_allocator::deallocate()" << std::endl;
    std::free(p);
  }
};

/// @brief Example class.
class foo
{
public:
  foo()         { std::cout << "foo()" << std::endl; }
  ~foo()        { std::cout << "~foo()" << std::endl; } 
  void action() { std::cout << "foo::action()" << std::endl; }
};

/// @brief Allocator for foo.
custom_allocator<foo> foo_allocator;

/// @brief Destroy a foo object.
void destroy_foo(foo* p)
{
  p->~foo();                      // Destruct.
  foo_allocator.deallocate(p, 1); // Deallocate.
}

/// @brief Factory function to create a foo object.
boost::shared_ptr<foo> create_foo()
{
  void* memory = foo_allocator.allocate(1); // Allocate.
  return boost::shared_ptr<foo>(
    new (memory) foo(), // Construct in allocated memory.
    &destroy_foo);      // Use custom deleter.
}

BOOST_PYTHON_MODULE(example) {
  namespace python = boost::python;
  // Expose foo, that will be managed by shared_ptr, and transparently
  // constructs the foo via a factory function to allow for a custom
  // deleter to use the custom allocator.
  python::class_<foo, boost::shared_ptr<foo>, 
                 boost::noncopyable>("Foo", python::no_init)
    .def("__init__", python::make_constructor(&create_foo))
    .def("action", &foo::action)
    ;
}

以及用法：

>>> import example
>>> f = example.Foo()
custom_allocator::allocate()
foo()
>>> f.action()
foo::action()
>>> f = None
~foo()
custom_allocator::deallocate()
于 2013-07-09T16:22:31.883 回答