ctypes and garbage collection

[Joakim Hove]

Hello,

I have used ctypes to wrap a C-library - it has been a really painless
experience!

The C-library instantiates a quite large "container-like" structure.
There are then several functions to inspect the content of the
container, get at items and free the whole thing:

/* C - code */
c_container_type * c_container_alloc( const char * filename );
c_node_type * c_container_get_node( c_container_type *
container , const char * node_id );
void c_container_free( c_container_type *
container );
.....

Observe that the c_container_get_node() function does _not_ allocate
memory, it just returns a opaque handle to a node structure, still
fully owned by the container structure. I have wrapped this with
Python/ctypes roughly like this (severly trimmed pseudo code):

class Container:
def __init__(self , filename):
self.c_ptr = c_container_alloc( filename )

def __del__( self ):
c_container_free( self.c_ptr )

def get_node( self , node_id):
Node( c_container_get_node( self , node_id ))


class Node:
def __init__( self , c_ptr ):
self.c_ptr = c_ptr

def __del__( self ):
pass


Now, a use scenario might be like this:

1. Instantiate a Container() instance.
2. Instantiate a Node() instance with the Container.get_node()
function.
3. Forget about the Container instance and work happily with the Node
instance.
4. Out of the blue comes the gc - and then? Will the Node instance be
enough to protect the Container instance from beeing garbage
collected?

I thought maybe the get_node() function should have something like a
incref() call, and the Node.__del__() function a corresponding
decref()? Or ??


Regards

Joakim Hove

 

[Ulrich Eckhardt]

I have used ctypes to wrap a C-library
[...]
Observe that the c_container_get_node() function does _not_ allocate
memory, it just returns a opaque handle to a node structure, still
fully owned by the container structure. [...]

class Container:
def __init__(self , filename):
self.c_ptr = c_container_alloc( filename )

def __del__( self ):
c_container_free( self.c_ptr )

def get_node( self , node_id):
Node( c_container_get_node( self , node_id ))


class Node:
def __init__( self , c_ptr ):
self.c_ptr = c_ptr

def __del__( self ):
pass


Now, a use scenario might be like this:

1. Instantiate a Container() instance.
2. Instantiate a Node() instance with the Container.get_node()
function.
3. Forget about the Container instance and work happily with the Node
instance.
4. Out of the blue comes the gc - and then? Will the Node instance be
enough to protect the Container instance from beeing garbage
collected?

No. You should be able to even see that by logging calls to alloc/free of
your library.

I thought maybe the get_node() function should have something like a
incref() call, and the Node.__del__() function a corresponding
decref()? Or ??

I'd add an "__owner" field to the node, initialised with the owning
container instance.

Uli

 

[Joakim Hove]

I'd add an "__owner" field to the node, initialised with the owning

container instance.

I will - thank you!

Joakim