How does Garbage Collection on Tables work?

Help and Feedback Scripting Support
#1

I was testing out garbage collection behaviors with this script:

game:GetService("RunService").Heartbeat:Connect(function()
	print(gcinfo())
end)

task.wait(1)

local srcTbl = {}

task.wait(1)

for i = 1, 1000000, 1 do
	srcTbl[i] = {
		AValue = "Hello World!"
	}
end

task.wait(3)

table.clear(srcTbl)
print("Cleared")

But for some reason, after clearing, some memory still didn’t get cleaned up.

Before the tables creation (expected):
image
After the tables creation (expected):
image
After srcTable was cleared (unexpected):
image

Could someone please explain why this is happening? Thank you in advance.

2 Likes
Whats the best way to clear a table?
#2

I’m also slightly confused. Does setting srcTbl to nil change any behavior?

1 Like
#3

It’s worse, actually. The memory use stays the same before and after setting it to nil.

image

3 Likes
#4

Im having some difficulty with my game too.

What I’m doing with every table is I created a function that cleans it deeply and removes every key.

So it’s like

Function DeepClean

function DeepCleanTable(t)
  for k, v in pairs(t) do
    if type(v) == "table" then
      DeepCleanTable(v)
    end
    t[k] = nil
  end
end
2 Likes
#5

I believe table.clear functions the same way.

2 Likes
#6

It won’t, because you are only clearing the 1st level keys.

If you have a table inside of a table inside of a table

then table.clear wont delete the other 2 tables

#7

Oh, I see. Table.clear only works with an array and the method you listed works with dictionaries.

1 Like
#8

Might be a 2 month old post but perhaps using the debug library will yield different results than gcinfo() as gcinfo is total memory heap and seems to be global across all scripts also you cannot really confirm if garbage collection will happen after the task.wait(3) or only after the script stops running and perhaps needs to be measured with another script instance, not much documentation on gcinfo as well for this type of usage.

#9

I know this is an old post, but for anyone wondering, I believe it has to do with the use of table.clear() as opposed to setting values to nil. Per the documentation:

"Sets the value for all keys within the given table to nil. This causes the # operator to return 0 for the given table. The allocated capacity of the table’s array portion is maintained, which allows for efficient re-use of the space.

local grades = {95, 82, 71, 92, 100, 60}
print(grades[4], #grades) --> 92, 6
table.clear(grades)
print(grades[4], #grades) --> nil, 0
-- If grades is filled again with the same number of entries,
-- no potentially expensive array resizing will occur
-- because the capacity was maintained by table.clear.

This function does not delete/destroy the table provided to it. This function is meant to be used specifically for tables that are to be re-used."

4 Likes