Re: Using Lua in an embedded hardware environment (toward a porting guide)

[Rici Lake <lua@...>]

On 26-Dec-06, at 8:58 PM, Tom Bates wrote:

> OK, here's my first contribution to a porting guide.
>  
> When porting to a limited resource environment, such as an embedded 
> hardware platform, here’s something to watch out for.
>  
> The lexical parsing in the Lua core needs a sizable chunk of stack 
> space for such language elements as function definitions. I’ve found 
> that in this case, the function chunk, which presumably is responsible 
> for parsing a chunk of Lua code, winds up calling the function body 
> that allocates the largish structure FuncState on the stack. This 
> function in turn calls chunk again, so if there’s a nested function 
> definition (admittedly pretty complex Lua code), you’ll need another 
> chunk of stack (pardon the pun). I bumped our shell task’s stack size 
> from 4K to 8K to surmount this issue. (FuncState, on my platform, is 
> 0x5D8 bytes in size.)

I suppose you're using lua 5.0.2 for some reason. In version 5.1.1, 
that struct is only 572 bytes (on x86, which also reports 1496 bytes 
for FuncState in 5.0.2, so I suppose the primitive datatypes are the 
same size.)

You can tune the size of a FuncState structure on both versions, by 
adjusting the defines of (LUAI_) MAXUPVALUES and MAXVARS. In 5.0.2, 
these are found in llimits.h and in 5.1.1 they're found in luaconf.h 
(and are prefixed with LUAI_).

MAXUPVALUES is the maximum number of upvalues in a single function, and 
is set by default to 32 in v5.0.2 and 60 in 5.1.1; it is probably also 
the biggest contributor to the size of a FuncState in 5.0.2, about 20 
bytes per entry. In 5.1.1, it's only two bytes per entry. MAXVARS is 
the maximum number of locals and temporaries in any single function. I 
would think that it would be safe to decrease MAXUPVALUES to 16 and 
MAXVARS to 100 (or even 60). If you set them too low, you'll start 
getting error messages when you compile complicated functions, but the 
parser shouldn't crash (as far as I know).

On the whole, I'd say your best bet is to use 5.1.1, though.

>  
> I know this isn’t relevant if you’ve removed the parsing and are just 
> running compiled code through the Lua VM, but I’m not far enough along 
> to know what stack space requirements the VM has. (BTW, if you’ve done 
> this, please pass along any pointers that might help.)

In both 5.0.2 and 5.1.1, the VM avoids recursive calls into itself, and 
in any event the basic call doesn't use very much stack. You'll get 
recursive calls in the following circumstances:

-- metamethod invocations
-- 'for' loops with iterators
-- pcall
-- error functions
-- callbacks into Lua from CFunctions

lua_pcall (and anything else which does a protected call) will allocate 
a jmp_buf on the stack, amongst other things; depending on your 
architecture, that can take up quite a bit of space. (or not).

You can also adjust (at compile time) the maximum depth of nested VM 
calls; you'll find the relevant #define in the same place as the ones I 
mentioned above.