How to get current function call stack depth in Lua? - lua

Question

I want to get current function call stack efficiently, Is there a api or sth to do this?
I tried a method like this, but its too slow.
local function GetStackDepth()
local depth = 0
while true do
if not debug.getinfo(3 + depth) then
break
end
depth = depth + 1
end
return depth
end
edit:
The really problem is Im writing a profiler tool, and using debug.sethook do sth in call and return event. but on lua5.1 or lua-jit situation, when a tail return happend i got two call event and just one return event like this:
call ------ the 1st call event
call
return
so my solution to this problem is get the call stack depth of the current event, on a return event when the depth is less than the 1st call event's depth, i know its a tail return, then i can handle it properly.
But I found the GetStackDepth() its self cost a lot time (too slow), which affect my profiler result.
i can't change the lua version.

Answer 1

For tail calls, you get a different event (or get istailcall in the activation record). I have to admit I am using the C API for the profiling code, but it should not be too tricky to translate that into native lua; although if you have performance issues, note that Roberto Ierusalimschy writes in Programming in Lua, 3rd ed, chapter 24 “The Debug Library”:
For performance reasons, the official interface to these primitives is through the C API.
I have a main C-style debug hook that forwards calls to event handlers:
void debugHook(lua_State * const ls, lua_Debug * const ar)
{
ASSERT(ls != nullptr);
ASSERT(ar != nullptr);
CallGraphTracker & dbg = getCallGraphTracker();
switch(ar->event)
{
case LUA_HOOKCALL:
dbg.handleEventCall(ls, ar);
break;
case LUA_HOOKTAILCALL:
dbg.handleEventTailCall(ls, ar);
break;
case LUA_HOOKRET:
dbg.handleEventReturn(ls, ar);
break;
default:
SHOULD_NEVER_BE_REACHED();
}
}
The event handlers, in my case, build a call graph based on the lua function pointers; the CallGraphTracker has Nodes (one root node and the further ones being added as subNodes) and keeps track of the curNode. (Actually, I also build function infos, but I have removed that code, to keep this simple. Obviously, the Nodes could store all kinds of additional info, too.)
The function Node::addCall just increases a number if a subnode for the same function pointer (luaPtr), line (ar->currentline), and “tailcall-ness” (true or false) already exists, otherwise a new Node is created. In both cases, the relevant subnode is returned and used as the new currentNode.
void CallGraphTracker::handleEventCall(lua_State * ls, lua_Debug * ar)
{
// Get function info and transform into simple function pointer.
lua_getinfo(ls, "f", ar);
ASSERT(lua_isfunction(ls, -1));
void const * luaPtr = lua_topointer(ls, -1);
ASSERT(luaPtr != nullptr);
// Add call.
lua_getstack(ls, 1, ar);
lua_getinfo(ls, "l", ar);
curNode = curNode->addCall(luaPtr, ar->currentline, false);
}
void CallGraphTracker::handleEventTailCall(lua_State * ls, lua_Debug * ar)
{
// Get function info and transform into simple function pointer.
lua_getinfo(ls, "nSf", ar);
ASSERT(lua_isfunction(ls, -1));
void const * luaPtr = lua_topointer(ls, -1);
ASSERT(luaPtr != nullptr);
// Add tail call.
lua_getstack(ls, 1, ar);
lua_getinfo(ls, "l", ar);
curNode = curNode->addCall(luaPtr, ar->currentline, true);
}
void CallGraphTracker::handleEventReturn(lua_State *, lua_Debug *)
{
while(curNode->isTailCall())
{
ASSERT(curNode->getCallerNode() != nullptr);
curNode = curNode->getCallerNode();
}
ASSERT(curNode->getCallerNode() != nullptr);
curNode = curNode->getCallerNode();
}
You'll notice that in handleEventReturn I traverse back the tailcalls first and then do the “proper” return. You can't assume a fixed number of tailcalls (strictly speaking) in case of tailcall-recursion of the form
function f(num)
if num == 0 then
return
end
-- Do something
return f(num-1)
end
Unfortunately, while this handles the tailcalls correctly, my current problem is that under error handling there can still be a mismatch between calls and returns, so I was hoping to be able to ask lua directly for the depth of the call stack, rather than having to do the slow “trial and error”.
My current plan (I have not yet implemented it) is to keep track of my expected call depth, then get information on that level. If that is what I expected, great, no further tests nececssary, moderate cost involved, otherwise I walk up (or is that down?) the stack until I get to a point where my stored call graph information fits the info returned from lua for that stack depth.