Using the C FFI to wrap an OCaml library

[Joel Stanley <jstanley@galois.com>]

Hi everyone,

I have a couple of questions about the OCaml FFI.  I'm attempting to
wrap up an existing OCaml library and provide a C API for it, as opposed
to the other way around, which seems to be much more common.

1. Can the CAMLparam*/CAMLlocal*/CAMLreturn macros be used to safely
carry values of type 'value' between C functions (even C functions that
have the appropriate CAMLparam/CAMLreturn invocations present)?  I
thought this worked, but more extensive testing has yielded some hangs
with the stack trace looking like:

     #0  0x00002b98 in caml_oldify_local_roots ()
     #1  0x00004dd7 in caml_empty_minor_heap ()
     #2  0x00004f28 in caml_minor_collection ()
     #3  0x00003501 in caml_garbage_collection ()
     #4  0x00011888 in caml_call_gc ()
     #5  0x00013577 in run_solver ()
     #6  0x00013cb4 in main ()

where run_solver here is the C function that is passed an opaque object
reference (elided by a value of type 'value') from another C function,
and is calling methods repeatedly on the provided object via  
caml_callback.

Looking at the macro expansions, I'm suspicious about the safety between
C functions, and wonder if the only way to carry data is use
caml_register_global_root (and manage my own memory if I need dynamic
allocation).

2. As a follow-up question to #1, the OCaml values may need to be
carried across yet another FFI, in this case, C <-> Poly/ML .  Even if
using the macros was a safe way to carry values between C functions, I"m
not sure I can easily replicate the macros on the other side of the FFI,
so am wondering if an explicit memory management approach using
caml_register_global_root will work.  E.g.,

   value* alloc_value() {
     value* p = malloc(sizeof(value));
     caml_register_global_root(p);
     return p;
   }

Any help is greatly appreciated.

--
Joel Stanley