GC not worked

[satoren]

I'm writing benchmark. but I encountered a strange crash
this code using over 2GB memory and killed by OOM killer.

const char* lua_code =
    "local times = 5000000 \n"
    "obj = object_function()\n"
    "obj:set(3)\n"
    "if(obj:get() ~= 3)then\n"
    "  error('error')\n"
    "end\n"
    "for i=1,times do\n"
    "  obj = object_function()\n"
    "  object_compare(obj)\n"
    "end\n";
    Lua lua;
    LuaTable global = lua.GetGlobalEnvironment();
    auto object_f = lua.CreateFunction<LuaUserdata<TestClass>()>([&] {
        auto retobj = lua.CreateUserdata<TestClass>(new TestClass(object_function()));
        retobj.Bind("set", &TestClass::set);
        retobj.Bind("get", &TestClass::get);
        return retobj; });
    global.Set("object_function", object_f);

    auto object_compare_f = lua.CreateFunction<bool(LuaUserdata<TestClass>)>([](LuaUserdata<TestClass> userdata)
    {
        return object_compare(*userdata.GetPointer());
    });
    global.Set("object_compare", object_compare_f);
    lua.RunScript(lua_code);

full souce code
https://github.com/satoren/lua_binding_benchmark/blob/24a243fc396c4025db4e3623b9e93717f148e3b8/benchmark/return_class_object.hpp
https://github.com/satoren/lua_binding_benchmark/blob/24a243fc396c4025db4e3623b9e93717f148e3b8/test/luacppinterface.cpp

[davidsiaw]

Alright, thanks. I'll have a look

[tesla9]

Did you find any solution for this issue, I have problem with GC too. I can also try to fix it, but maybe you have any suggestions or ideas?

[ziab]

It looks like if you comment these bindings:

retobj.Bind("set", &TestClass::set);
retobj.Bind("get", &TestClass::get);

The memory leak issues goes away, well... at least it leaks much lesser. Also I don't see this finalizer being invoked when object goes away form a scope, this is only called when lua state is being destroyed:

    template<typename SIG>
    static int lua_finalizer(lua_State* state)
    {
        LuaFunction<SIG>** func = (LuaFunction<SIG>**)lua_touserdata(state, lua_upvalueindex(1));
        delete *func;
        return 0;
    };

It also appears like those function objects created within a VM scope and only referenced by a field within an object:

    template<typename TYPE>
    template<typename RET>
    void LuaUserdata<TYPE>::Bind(std::string name, RET(TYPE::*func)() )
    {
        using namespace std::placeholders;
        TYPE* t = RetrieveData();
        Lua lua(state);
        auto luaFunc = lua.CreateFunction<RET()>(std::bind(func, t));
        LuaTable table = GetMetaTable();
        table.Set(name, luaFunc);
    }

Since I'm not an expert of lua VM internals, I can't say anything in particular, hope @davidsiaw could comment on this.

[tesla9]

yes, I've observed, that lua garbage collector can not see object created this way, and this causes the leak. For example in this case:

obj = object_function()
obj = nil
collectgarbage()

the destructor of TestClass is not called.

I have found the workaround: I realized, that CollectGarbage function works good, so I can wrap it into Lua:

    auto collectGarbage = lua.CreateFunction< void () >(
    [&]()
    {
             lua.CollectGarbage();  
    }
    );
    lua.GetGlobalEnvironment().Set( "CollectGarbage", collectGarbage );

and now the destructor is calling for this lua script:

obj = object_function()
obj = nil
CollectGarbage()

But it's rather the hack, than a solution:/

[tesla9]

...but the problem still exists :(
It looks like GC doesn't clean function references binded to objects by a 'Bind' function, when the object is deleting, even if the destructor of TestClass was called.

[ziab]

@tesla9 the ~TestClass() is always called for me once an object leaves a scope. So yeah, it looks like the problem is function referencing. Currently I'm not sure how this mechanism works in Lua, but perhaps reading the Lua documentation can shed the light.

[davidsiaw]

Strange, the CollectGarbage function should be the same as the one in Lua.

[tesla9]

I am not sure if it's a problem with GC or general mem leak somewhere in the library.
Even if I delete the lua object, the memory is still allocated:

Lua * pLua = new Lua();
pLua->RunScript("...make some allocations...")       //~100MB
pLua->RunScript("  ...make  all objects to be nil...")
pLuta->RunScript(" ..call GC.." )   //destructors of TestClass ware called, but a lot of memory is still allocated  ~90MB
delete pLua;  // and even now memory is still allocated