efficiency

[malcolm-ffi at cs.york.ac.uk]

> > To me it seems as if we should seperate conversion from
> > [Char] to [CChar] from the actual marshalling of CChar.
> > Why is it an advantage to lump it all together?
> 
> Efficiency, and the fact that combined conversion+marshalling
> operations are convenient anyway.

I don't want to talk about [Char] -> [CChar] specifically, but the
mention of efficiency reminds me of something that has been bothering
me for a little while.

In the current design of the FFI, it is assumed that most of the
marshalling work is going to be done in Haskell.  For example, to
return more than one result from a C function, the results are packaged
as a C struct, passed as an Addr (or Ptr) to Haskell, which then
dereferences from the Addr to each individual component of the struct.

Now in GHC, the treatment of the IO monad may make this acceptably
fast, but in other implementations (like nhc98 (of course)), this
is just horribly inefficient, and can slow up FFI calls by an order
of magnitude or more.  (Comparing to previous implementations using
either the builtin 'primitive' mechanism or GreenCard.)  I agree that
it is better in principle to have the marshalling code in Haskell
because it has much better type-safety than C.  But in practice,
I have found other ways to do the marshalling, mainly because of the
efficiency question.

Do other people have any thoughts about the efficiency of the current
scheme?

Regards,
    Malcolm