C binding strategy

  • From: Francisco Tolmasky <tolmasky@xxxxxxxxx>
  • To: luajit@xxxxxxxxxxxxx
  • Date: Wed, 15 Aug 2012 17:46:50 -0700

I asked a question similar to this on the normal lua mailing list, and one of 
the primary suggestions was to first switch to luajit to be able to take 
advantage of the very cool ffi feature. I took yesterday to port my project to 
luajit and now am hoping the luajit community can provide some guidance in the 
next steps.

Basically, I am trying to bridge events from C into Lua. For example, lets say 
a Point class (containing x and y). These points get used internally by the C 
code to do graphics stuff, etc (or say Quaternions, etc.). The point is, I'm 
referring to simple objects that you might use a struct for, would rarely have 
a pointer for in C or a non-trivial lifetime like an "Image" class or something.

1. I would *like* to have as much be done in Lua as possible. As such one 
strategy is from C to use the lua APIs to create a traditional table in lua 
code, then when I need something in C, operate on the table using the old API 
loa_gettable etc. So for example, I'll have a table with x and y keys in Lua, 
then when I pass it to one of the graphics library functions, it checks its 
metatable to make sure its the right kind of object (or maybe even just check 
that it has number x and y), and use whatever it needs from it. This is 
certainly more in the "spirit" of lua I feel, and I don't mind the extra work 
of writing it. Similarly, when I need to return a point from C, I actually 
create the table (or load a chunk that calls the "constructor" defined in Lua). 
Hence, all my objects are always "real" Lua objects (and easy to reason about 
with regard to gc etc):

void mouseUpdated(point p)
        // Make a Point. "Point" is defined in Lua land
        lua_getglobal(L, "Point");
        lua_pushnumber(L, p.x);
        lua_pushnumber(L, p.y);
        lua_pcall(L, 2, 1, 0);

        // Send it on over as the sole argument to mouseUpdated
        lua_getglobal(L, "mouseUpdated");
        lua_pcall(L, 1, 0, 0);

2. However, in some runtimes, the general advice is "the more you can have in 
C, the better". For example, in JavaScriptCore "doing JS from C++" (or even 
ObjC) is almost always way faster than having it happen as interpreted code in 
the interpreter. This is true even given the cost of bridging JS strings to 
NSString etc. As such, in the Point example, another approach would be to use 
the FFI to bridge over point structs for instance (as I believe there is an 
example on the website), and also map over all the methods to C functions. From 
the vanilla lua implementations (and libraries like LuaBind) I got the 
impression that this might not be as beneficial in Lua though.

So basically, either dealing with a C exposed object in Lua, or dealing with a 
Lua table in C. From the examples given on the website, I can see the obvious 
benefits for large arrays of doubles and alternatively for complex C/C++ 
objects, but I am not sure about these kinds of "in between" objects. Is FFI so 
much better/faster that I should just go for it? For objects like 
points/quaternions/mouseevents/whatever will I be saving a ton of memory? Also, 
although FFI certainly seems faster than the traditional Lua C bindings, its 
still not clear to me if its faster than normal code, if that makes sense.

Apologies if some of this stuff has been covered already, I am new to Lua so 
I'm not sure if one is obviously better than the other. I would like to gain an 
intuition for when its desirable to bridge to C and when not.



Other related posts: