Memory usage and variables

[Crowfeather]

As I´m not really happy with the memory usage of my addon I´d like to learn a bit about how lua allocates and releases memory for variables.

For example I´ve got a function that creates and fills a table adj. Every time the function is called some of the table values may have to be deleted, some new values may have come up and some existing values may have changed.
So far all I did was recreating the table with an local adj = {} statement and refill it with current values. Now from my testing it seems that doesn´t release the memory used by the original adj table but leaves it as garbage to be collected. Using if not adj then adj = {} end fixes the memory problem but that also means that anything that isn´t overwritten will remain in its old, obsolete state (eg. isn´t deleted).

I guess what I´m asking is, what´s the proper way to delete tables (or variables in general).

[Torhal]

The only way to "delete" anything in Lua is to do what you were doing before - set it up to be garbage-collected. However, you can either explicitly set the variables to nil, or use table.wipe() before re-filling the table.

[Crowfeather]

Thanks for the fast reply.

I´ve tried both

if adj then table.wipe(adj) else adj = {} end

and

local adj = nil
adj = {}

The latter didn´t change anything, the former alleviated the problem somewhat (memory growth down from 0,95% to 0.81%). Unfortunatly I can´t make the table local if I´m checking for its existance in an if clause because than it would be local in that if block only.

As a more general question assume I´ve got the following function

function foo()
  local a = 1
end

And this function is called frequently, does it always allocate new memory for the variable a? I´m asking because I´ve got a lot of statements like

local allDmgAdj, constDmgAdj, refreshDmgAdj, instantDmgAdj = 1, 1, 1, 1

[nightcracker]

You won't get around garbage collecting, that's just how Lua works. And even you won't like it now, it's actually pretty great.

[Crowfeather]

Originally Posted by nightcracker You won't get around garbage collecting, that's just how Lua works. And even you won't like it now, it's actually pretty great.

That´s not the point. I´m not complaining about the way lua handles garbage collection or memory allocation - quite the opposite. I think it´s much more likely that somehow, somewhere I´m still doing something horribly wrong and cause my addon to use much more memory than it ought to do.

Looking an profiling addon that watches memory usage and growth there´re a few bigger addons that take up much more memory but for none of them the memory usage grows as fast as for mine. That´s even though there´s not more data that needs to be stored but only the same variables that needs to be overwritten multiple times per second.

[Torhal]

Originally Posted by Crowfeather <snip> function foo() local a = 1 end And this function is called frequently, does it always allocate new memory for the variable a? I´m asking because I´ve got a lot of statements like local allDmgAdj, constDmgAdj, refreshDmgAdj, instantDmgAdj = 1, 1, 1, 1

No. The variable "a" would be allocated on the local stack (if applicable - strings, for example, are never released once allocated, so at that point "a" would simply be a reference to the segment of memory in which the string resides) and then promptly released when the function popped off of the stack.

[Seerah]

Though if you are calling it very frequently (in an OnUpdate, for example), then you may find it more beneficial to do this:

local a
function foo()
     a = 1
end

Here, the variable a is created outside of the function (thus its availability is not limited to the function's scope), but is only created once, as opposed to every time your function is called.

[ravagernl]

Originally Posted by Seerah Though if you are calling it very frequently (in an OnUpdate, for example), then you may find it more beneficial to do this: local a function foo() a = 1 end Here, the variable a is created outside of the function (thus its availability is not limited to the function's scope), but is only created once, as opposed to every time your function is called.

I've seen some authors use this trick:

local FunctionFoo
do
    local a
    FunctionFoo = function()
        a = 1
    end
end

What is the advantage of this method comparing yours?

[Torhal]

In Seerah's version, the "a" variable is visible to everything in the file below its declaration. In the do-block version, only the function defined directly below it knows about its existence.

[Crowfeather]

Thanks for all the answers, I think it already helped me lowering the memory usage of my addon significantly.