FFI Ptr question

[paul@theV.net]

Thank you for the explanation!

So am I right to draw a picture like this?

 ---------        --------- 
| Haskell |      | Foreign |
| Ptr     |----->| Data    |
| Block   |      | Block   |
 ---------        --------- 

1. If I allocate the data block in a foreign language and returns
   the pointer as Ptr through FFI, I have to free it in the 
   foreign language after use.

2. If I allocate the data block through Marshal.Alloc, then I
   need to use Haskell free to deallocate it. (why the difference?
   GHC not using the default malloc/free in C lib?)

3. If the Haskell Ptr is no longer in use, the Haskell GC will
   collect it, regardless of whether it has a dangling pointer
   to Foreign Data Block.

I only hope the Ptr part of FFI documentation can include some
of the malloc/free guidelines, otherwise it is quite confusing
for beginners.

Regards,
.paul.

On Thu, Jul 03, 2003 at 03:49:21AM -0400, Derek Elkins wrote:
> On Thu, 3 Jul 2003 15:04:26 +0800
> paul@theV.net wrote:
> 
> > On Thu, Jul 03, 2003 at 01:40:46AM -0400, Derek Elkins wrote:
> > > On Thu, 3 Jul 2003 11:34:08 +0800
> > > paul@theV.net wrote:
> > > 
> > > > If a C function returns a (void*), let's say:
> > > > 
> > > > data MyObj = MyObj
> > > > 
> > > > foreign import ccall "static myobj_ffi.h new_obj" newMyObject ::
> > > > IO(Ptr MyObj)
> > > > 
> > > > ptr <- newMyObject
> > > > 
> > > > should I free the ptr afterwards or not?
> > > 
> > > Assuming that it should be freed even in C and nothing else is
> > > managing it then I believe the answer is yes.  You can use a
> > > finalizer to do it.
> > 
> > The wierd thing is, I cannot use the the function
> > Foreign.Marshal.Alloc.free to free the ptr. I must
> > use my own C function to do a simple free() call.
> 
> You didn't allocate it with the Foreign library, why would you expect to
> free it with it?  Actually, I'm kind of surprised it doesn't work,
> nevertheless I don't believe that the intent of the Alloc module is to
> free memory allocated by a foreign language, or allocate memory that
> will be freed by a foreign language.  If you need to create/destroy a
> foreign value in Haskell, you typically provide both a creation and
> destruction function.
> 
> > > > If I have another imported C function:
> > > > 
> > > > foreign import ccall "static myobj_ffi.h print_obj" printMyObject
> > > > :: Ptr MyObj -> IO ()
> > > > 
> > > > Can I safely assume the C function print_obj(void *) always get
> > > > the same pointer even if I call (printMyObject ptr) multiple
> > > > times?
> > > 
> > > What other pointer would it pass?
> > 
> > The same Haskell ptr. I wonder if they'll ever change after
> > creation.
> > 
> > My question is, if Ptr is equivalent to a raw void* pointer in 
> > C, and pointers created in foreign language (which is later
> > passed to Haskell as Ptr) has to be freed in the foreign
> > language, then can I safely assume that Ptr isn't affected
> > by Haskell's GC cycle? And what the real difference between Ptr
> > and StablePtr?
> 
> The GC won't free the memory pointed at by the void * unless you attach
> a finalizer, in which case you obviously shouldn't be freeing it in the
> foreign code.  The Ptr you get will be freed by Haskell's GC if it
> becomes unreferenced, but that won't affect what it points at. 
> StablePtr's are for pointing at -Haskell- values.
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe