CODEWITHSUNDEEP
memory-leaksgarbage-collectionlua
Igorio
Igorio

Reputation: 948

Are numbers, bools or nils garbage collected in Lua?

This article implies that all types beside numbers, bools and nil are garbage collected.

The field gc is used for the other values (strings, tables, functions, heavy userdata, and threads), which are those subject to garbage collection.

Would this mean under certain circumstances that overusing these non-gc types might result in memory leaks?

Upvotes: 4

Views: 517

Answers (2)

hugomg
hugomg

Reputation: 69944

In the article you linked to they write down the C code that shows how values are represented:

/*You can also find this in lobject.h in the Lua source*/
/*I paraphrased a bit to remove some macro magic*/

/*unions in C store one of the values at a time*/
union Value {
  GCObject *gc;    /* collectable objects */
  void *p;         /* light userdata */
  int b;           /* booleans */
  lua_CFunction f; /* light C functions */
  numfield         /* numbers */
};

typedef union Value Value;

/*the _tt tagtells what kind of value is actually stored in the union*/
struct lua_TObject {
  int _tt;
  Value value_;
};

As you can see in here, booleans and numbers are stored directly in the TObject struct. Since they are not "heap-allocated" it means that they can never "leak" and therefore garbage collecting them would have made no sense.

One interesting to note, however, is that the garbage collector does not collect references created to things on the C side of things (userdata and C C functions). These need to be manually managed from the C-side of things but that is sort of to be expected since in that case you are writing C instead of Lua.

Upvotes: 1

jpjacobs
jpjacobs

Reputation: 9549

In Lua, you have actually 2 kinds of types: Ones which are always passed by value, and ones passed by reference ( as per chapter 2.1 in the Lua Manual ).

The ones you cite are all of the "passed-by-value" type, hence they are directly stored in a variable. If you delete the variable, the value will be gone instantly.

So it will not start leaking memory, unless, of course, you keep generating new variables containing new values. But in that case it's your own fault ;).

Upvotes: 2

Related Questions