Some questions about memory leaks

[CoderHusk]

If the value is cleared what is left? I did a quick check with getfenv() doing what you suggested and it wasnt in the environment

[SteamG00B (Qatar Hero)]

An OOP class may seem like it’s got it’s own rules, but it really doesn’t, if the scope they were initialized in ends, then it behaves just like any other function or module on roblox.

[angrybino]

A function’s scope ends when it has finished running.

@CoderHusk

That is what I meant, the value is set to nil, therefore it won’t be available. But it’s memory still remains, and will be cleared when the scope it was allocated in ends.

[CoderHusk]

I’m so confused if it isnt in the environment how could I view it in memory?

[angrybino]

You can’t, this is a good read: Understanding Lua's Garbage Collection

[Crystalflxme (Crystalflame)]

Check out the Lua guide about this topic.

Lua does automatic memory management. A program only creates objects (tables, functions, etc.); there is no function to delete objects. Lua automatically deletes objects that become garbage, using garbage collection . That frees you from most of the burden of memory management and, more important, frees you from most of the bugs related to that activity, such as dangling pointers and memory leaks.

A garbage collector can collect only what it can be sure is garbage; it cannot know what you consider garbage. A typical example is a stack, implemented with an array and an index to the top. You know that the valid part of the array goes only up to the top, but Lua does not. If you pop an element by simply decrementing the top, the object left in the array is not garbage for Lua. Similarly, any object stored in a global variable is not garbage for Lua, even if your program will never use it again. In both cases, it is up to you (i.e., your program) to assign nil to these positions so that they do not lock an otherwise free object.

However, simply cleaning your references is not always enough. Some constructions need extra collaboration between you and the collector. A typical example happens when you want to keep a collection of all live objects of some kind (e.g., files) in your program. That seems a simple task: All you have to do is to insert each new object into the collection. However, once the object is inside the collection, it will never be collected! Even if no one else points to it, the collection does. Lua cannot know that this reference should not prevent the reclamation of the object, unless you tell Lua about that.

Setting to nil doesn’t delete it from memory right then and there. It just allows the Lua garbage collector to know that it’s garbage.

[CoderHusk]

Could you quote specifically where in that thing you linked which supports what you said?

[SteamG00B (Qatar Hero)]

Yes. That is why I said what I said. Marking for collection, is not the same as garbage collection.

[SteamG00B (Qatar Hero)]

@Crystalflxme

Relating to the last question, do functions get garbage collected when stored in tables?

So do you have any other questions? Because to me, it seems like your question has been answered a long time ago.

[angrybino]

That is just an demonstration on how lua garbage collector works. The Lua source code + reputable members of StackOverFlow and this forum support all what I said. You can search up more.

[CoderHusk]

Well I asked where did you hear that from that you cant view it why cant you just show me what exactly you are referring to instead of using those links as proxys?

[angrybino]

Obviously you can’t view it from memory, there is no way. You can clearly test this out your self.

[Crystalflxme (Crystalflame)]

It would appear that there was a bit of a misunderstanding.

@Crystalflxme

Lua manages memory for you, so setting something to nil and expecting it to be removed from memory isn’t how it works. That’s why clearing the references to it is needed. You need to make sure the garbage collector knows that the given Lua object is OK to get rid of.

This statement without the last two sentences is somewhat misleading, I apologize for that. The question that I was trying to ask here has essentially been answered by @SilentsReplacement.

In regards to the topic’s solution, I’ll pick the post that has the most answers towards the ones asked in the first post. For anybody who comes later to read this, I recommend checking out the whole topic.

[Wyzloc]

data[workspace.Part] = nil

This is all you need to do, so yes it works. Also you can do things like;

local bla = {}
bla["A"] = true
function blabla()
bla = {}
end

and this will overwrite your old table with a new one so the old one will no longer exist.