Как правильно управлять временем жизни объектов C ++ в Cython? - PullRequest
Новая
       18

Как правильно управлять временем жизни объектов C ++ в Cython?

19 голосов
/ 21 декабря 2010

При написании оболочки Cython для библиотеки C ++ я столкнулся со случаем, когда неясно, как правильно решить, когда удалять определенные экземпляры C ++.

Библиотека C ++ выглядит примерно так: 

#include <stdio.h>
#include <string.h>

class Widget {
    char *name;
    public:
        Widget() : name(strdup("a widget")) {}
        ~Widget() { printf("Widget destruct\n"); }
        void foo() { printf("Widget::foo %s\n", this->name); }
};

class Sprocket {
    private:
        Widget *important;

    public:
        Sprocket(Widget* important) : important(important) {}
        ~Sprocket() { important->foo(); }
};

Важным аспектом этой библиотеки является то, что деструктор Sprocket использует заданный Widget*, поэтому Widget нельзя уничтожать до тех пор, пока не будет Sprocket.

Оболочка Cython, которую я написал, выглядит следующим образом: 

cdef extern from "somelib.h":
    cdef cppclass Widget:
        pass

    cdef cppclass Sprocket:
        Sprocket(Widget*)


cdef class PyWidget:
    cdef Widget *thisptr

    def __init__(self):
        self.thisptr = new Widget()

    def __dealloc__(self):
        print 'PyWidget dealloc'
        del self.thisptr


cdef class PySprocket:
    cdef PyWidget widget
    cdef Sprocket *thisptr

    def __init__(self, PyWidget widget):
        self.widget = widget
        self.thisptr = new Sprocket(self.widget.thisptr)


    def __dealloc__(self):
        print 'PySprocket dealloc with widget', self.widget
        del self.thisptr

После сборки Python сборка выглядит так: 

$ cython --cplus somelib.pyx 
$ g++ -I/usr/include/python2.6 -L/usr/lib somelib.cpp -shared -o somelib.so
$

В тривиальном случае, похоже, работает: 

$ python -c 'from somelib import PyWidget, PySprocket
spr = PySprocket(PyWidget())
del spr
'
PySprocket dealloc with widget <somelib.PyWidget object at 0xb7537080>
Widget::foo a widget
PyWidget dealloc
Widget destruct
$

Поле cdef Widget поддерживает PyWidget в живых до тех пор, пока PySprocket.__dealloc__ не уничтожит Sprocket. Однако, как только сборщик мусора в Python включается, функция Cython для tp_clear для PySprocket запутывает это: 

$ python -c 'from somelib import PyWidget, PySprocket
class BadWidget(PyWidget):
    pass
widget = BadWidget()
sprocket = PySprocket(widget)
widget.cycle = sprocket
del widget
del sprocket
'
PyWidget dealloc
Widget destruct
PySprocket dealloc with widget None
Widget::foo ��h�

Так как есть эталонный цикл, сборщик мусора вызывает tp_clear, чтобы попытаться разорвать цикл. Cython tp_clear отбрасывает все ссылки на объекты Python. Только после этого PySprocket.__dealloc__ запускается.

Документация Cython предупреждает о __dealloc__ (хотя мне потребовалось некоторое время, чтобы понять, о каких условиях он говорил, поскольку он не вдавался в подробности). Так что, возможно, этот подход совершенно неверен.

Может ли Cython поддерживать этот вариант использования?

Как (что я надеюсь) временное решение, я перешел к подходу, который выглядит примерно так: 

cdef class PySprocket:
    cdef void *widget
    cdef Sprocket *thisptr

    def __init__(self, PyWidget widget):
        Py_INCREF(widget)
        self.widget = <void*>widget
        self.thisptr = new Sprocket(self.widget.thisptr)


    def __dealloc__(self):
        del self.thisptr
        Py_DECREF(<object>self.widget)

Другими словами, скрытие ссылки от Cython, чтобы она все еще действовала в __dealloc__, и выполнение ссылок на нее вручную.

1 Ответ

5 голосов
/ 30 декабря 2010 
cdef extern from "somelib.h":
    cdef cppclass Widget:
        pass

    cdef cppclass Sprocket:
        Sprocket(Widget*)


cdef class PyWidget:
    cdef Widget *thisptr
    cdef set    sprockets

    def __init__(self):
        self.thisptr = new Widget()
        self.sprockets = set()

    def __dealloc__(self):
        print 'PyWidget dealloc'
        #PyWidget knows the sprockets and notifies them on destroy
        sprockets_to_dealloc = self.sprockets.copy()
        #with this solution spr items can call back to detach
        for spr in sprockets_to_dealloc:
          del spr
        del self.thisptr

    def attach(PySprocket spr):
        print 'PySprocket attach'
        self.sprockets.add(spr)

    def detach(PySprocket spr):
        print 'PySprocket detach'
        self.sprockets.remove(spr)

cdef class PySprocket:
    cdef PyWidget widget
    cdef Sprocket *thisptr

    def __init__(self, PyWidget widget):
        self.thisptr = new Sprocket(widget.thisptr)
        #You should be sure here that the widget exists
        widget.attach(self)
        self.widget = widget

    def __dealloc__(self):
        self.widget.detach(self)
        del self.thisptr

Я возвращаюсь немного позже, чтобы проверить, что я написал, потому что я очень устал, но вот что важно: дело в том, что вы хотите уведомить Sprockets при уничтожении Widget, и порокversa.

Это общее решение, может быть настроено.

Вы должны также включить обработку ошибок, я пропустил это абсолютно.Ничего общего с сборщиком мусора, в вашем коде была проблема с дизайном.

РЕДАКТИРОВАТЬ: эти коды эквивалентны:
A 

class BadWidget(PyWidget):
    pass
widget = BadWidget()
sprocket = PySprocket(widget)
widget.cycle = sprocket ###1
del widget ###2
del sprocket

B 

class BadWidget(PyWidget):
    pass
widget = BadWidget()
sprocket = PySprocket(widget)
sprocket.widget.cycle = sprocket ###1
del sprocket.widget ###2
del sprocket

###2 вызовет sprocket.widget.__deallocate__(), и он не освобождает sprocket.widget.cycle, поэтому звездочка выживет в виджете

...