[英]Python C-API Object Allocation
I want to use the new and delete operators for creating and destroying my objects. 我想使用new和delete运算符来创建和销毁我的对象。
The problem is python seems to break it into several stages. 问题是python似乎把它分成了几个阶段。 tp_new, tp_init and tp_alloc for creation and tp_del, tp_free and tp_dealloc for destruction. tp_new,tp_init和tp_alloc用于创建,tp_del,tp_free和tp_dealloc用于销毁。 However c++ just has new which allocates and fully constructs the object and delete which destructs and deallocates the object. 但是c ++只有new,它分配并完全构造对象和删除对象的析构和解除分配。
Which of the python tp_* methods do I need to provide and what must they do? 我需要提供哪些python tp_ *方法以及它们必须做什么?
Also I want to be able to create the object directly in c++ eg "PyObject *obj = new MyExtensionObject(args);" 此外,我希望能够直接在c ++中创建对象,例如“PyObject * obj = new MyExtensionObject(args);” Will I also need to overload the new operator in some way to support this? 我是否还需要以某种方式重载新运算符以支持此操作?
I also would like to be able to subclass my extension types in python, is there anything special I need to do to support this? 我也希望能够在python中继承我的扩展类型,我需要做些什么来支持这个?
I'm using python 3.0.1. 我正在使用python 3.0.1。
EDIT: ok, tp_init seems to make objects a bit too mutable for what I'm doing (eg take a Texture object, changing the contents after creation is fine, but change fundamental aspects of it such as, size, bitdept, etc will break lots of existing c++ stuff that assumes those sort of things are fixed). 编辑:好的,tp_init似乎使对象有点太可变了我正在做的事情(例如,取一个Texture对象,在创建后改变内容很好,但改变它的基本方面,如size,bitdept等会破坏许多现有的c ++东西,假设这些东西是固定的)。 If I dont implement it will it simply stop people calling __init__ AFTER its constructed (or at least ignore the call, like tuple does). 如果我没有实现它,它只会阻止人们在构造之后调用__init__(或者至少忽略调用,就像元组一样)。 Or should I have some flag that throws an exception or somthing if tp_init is called more than once on the same object? 或者,如果在同一个对象上多次调用tp_init,我是否应该有一些抛出异常或某事的标志?
Apart from that I think ive got most of the rest sorted. 除此之外,我认为其余的大部分已经排序。
extern "C"
{
//creation + destruction
PyObject* global_alloc(PyTypeObject *type, Py_ssize_t items)
{
return (PyObject*)new char[type->tp_basicsize + items*type->tp_itemsize];
}
void global_free(void *mem)
{
delete[] (char*)mem;
}
}
template<class T> class ExtensionType
{
PyTypeObject *t;
ExtensionType()
{
t = new PyTypeObject();//not sure on this one, what is the "correct" way to create an empty type object
memset((void*)t, 0, sizeof(PyTypeObject));
static PyVarObject init = {PyObject_HEAD_INIT, 0};
*((PyObject*)t) = init;
t->tp_basicsize = sizeof(T);
t->tp_itemsize = 0;
t->tp_name = "unknown";
t->tp_alloc = (allocfunc) global_alloc;
t->tp_free = (freefunc) global_free;
t->tp_new = (newfunc) T::obj_new;
t->tp_dealloc = (destructor)T::obj_dealloc;
...
}
...bunch of methods for changing stuff...
PyObject *Finalise()
{
...
}
};
template <class T> PyObjectExtension : public PyObject
{
...
extern "C" static PyObject* obj_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
{
void *mem = (void*)subtype->tp_alloc(subtype, 0);
return (PyObject*)new(mem) T(args, kwds)
}
extern "C" static void obj_dealloc(PyObject *obj)
{
~T();
obj->ob_type->tp_free(obj);//most of the time this is global_free(obj)
}
...
};
class MyObject : PyObjectExtension<MyObject>
{
public:
static PyObject* InitType()
{
ExtensionType<MyObject> extType();
...sets other stuff...
return extType.Finalise();
}
...
};
The documentation for these is at http://docs.python.org/3.0/c-api/typeobj.html and http://docs.python.org/3.0/extending/newtypes.html describes how to make your own type. 这些文档是在http://docs.python.org/3.0/c-api/typeobj.html和http://docs.python.org/3.0/extending/newtypes.html介绍如何使自己的类型。
tp_alloc does the low-level memory allocation for the instance. tp_alloc为实例执行低级别内存分配。 This is equivalent to malloc(), plus initialize the refcnt to 1. Python has it's own allocator, PyType_GenericAlloc, but a type can implement a specialized allocator. 这相当于malloc(),并将refcnt初始化为1.Python有自己的分配器PyType_GenericAlloc,但是一个类型可以实现一个专门的分配器。
tp_new is the same as Python's __new__. tp_new与Python的__new__相同。 It's usually used for immutable objects where the data is stored in the instance itself, as compared to a pointer to data. 它通常用于不可变对象,其中数据存储在实例本身中,与指向数据的指针相比。 For example, strings and tuples store their data in the instance, instead of using a char * or a PyTuple *. 例如,字符串和元组将它们的数据存储在实例中,而不是使用char *或PyTuple *。
For this case, tp_new figures out how much memory is needed, based on the input parameters, and calls tp_alloc to get the memory, then initializes the essential fields. 对于这种情况,tp_new根据输入参数计算出需要多少内存,并调用tp_alloc来获取内存,然后初始化基本字段。 tp_new does not need to call tp_alloc. tp_new不需要调用tp_alloc。 It can for example return a cached object. 例如,它可以返回一个缓存的对象。
tp_init is the same as Python's __init__. tp_init与Python的__init__相同。 Most of your initialization should be in this function. 您的大部分初始化应该在此函数中。
The distinction between __new__ and __init__ is called two-stage initialization , or two-phase initialization . __new__和__init__之间的区别称为两阶段初始化或两阶段初始化 。
You say " c++ just has new " but that's not correct. 你说“ c ++只是有新的 ”但这不正确。 tp_alloc corresponds a custom arena allocator in C++, __new__ corresponds to a custom type allocator (a factory function), and __init__ is more like the constructor. tp_alloc对应于C ++中的自定义竞技场分配器,__ new__对应于自定义类型分配器(工厂函数),__ init__更像是构造函数。 That last link discusses more about the parallels between C++ and Python style. 最后一个链接更多地讨论了C ++和Python风格之间的相似之处。
Also read http://www.python.org/download/releases/2.2/descrintro/ for details about how __new__ and __init__ interact. 另请阅读http://www.python.org/download/releases/2.2/descrintro/ ,了解__new__和__init__如何互动的详细信息。
You write that you want to "create the object directly in c++". 你写的是你想“直接用c ++创建对象”。 That's rather difficult because at the least you'll have to convert any Python exceptions that occurred during object instantiation into a C++ exception. 这是相当困难的,因为至少你必须将在对象实例化期间发生的任何Python异常转换为C ++异常。 You might try looking at Boost::Python for some help with this task. 您可以尝试查看Boost :: Python以获得有关此任务的一些帮助。 Or you can use a two-phase initialization. 或者您可以使用两阶段初始化。 ;) ;)
I don't know the python APIs at all, but if python splits up allocation and initialization, you should be able to use placement new. 我根本不知道python API,但如果python拆分分配和初始化,你应该能够使用placement new。
eg: 例如:
// tp_alloc
void *buffer = new char[sizeof(MyExtensionObject)];
// tp_init or tp_new (not sure what the distinction is there)
new (buffer) MyExtensionObject(args);
return static_cast<MyExtensionObject*>(buffer);
...
// tp_del
myExtensionObject->~MyExtensionObject(); // call dtor
// tp_dealloc (or tp_free? again I don't know the python apis)
delete [] (static_cast<char*>(static_cast<void*>(myExtensionObject)));
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.