What are the pros and cons of using the Garbage Collector in Nelua?

[ghost]

What are the pros and cons of using the Garbage Collector in nelua?

[edubart]

Well, the garbage collector makes life easier when prototyping code quickly, because you don't need to care about cleaning memory allocations when it's not used anymore, it also may protect you from programming mistakes because manual memory management can be difficult and it is common to make mistakes. However, the payoff is runtime cost in terms of efficiency and memory, because the program may pause a while to scan the whole memory for references that are not referenced anymore (to free its memory). Here are some lists of advantages and disadvantages, though this topic is popular and you can also research on the web:

Advantages of using GC:

• No need to cleanup new allocations (because it does this automatically)
• By not deallocating memory manually, you are safe to use after free mistakes and memory leaks
• You can prototype code quickly and with less cognitive load, because you don't need to think or care about memory cleanup
• You can make code where references would have cycle between them, without elaborating a system on how to cleanup that

Disadvantages of using GC:

• The GC will pause the whole program (stop the world) for scanning unused references every time the memory usage doubles
• The GC uses more memory to mark all references
• The GC will add more runtime code and overhead on every new allocation

Here I will also list some common mistakes when doing manual memory management and not using the GC:

• If you forget to deallocate a new allocation (memory leak), the program memory will increase indefinitely, until reaching out of memory error
• If you use a reference after it has been deallocated (use after free), will cause undefined behavior, that can lead to crashes, odd bugs, or corrupt program memory

Where using GC can be recommended:

• Programs that total runtime cost matters more than real-time stability
• Programs that run and exits immediately (command line programs, scripts)
• Programs that does not use much memory, nor have many thousands of allocations (memory usage below 1GB)
• Simple game engines, that manages few hundreds objects and resources

Where using the GC is not recommended:

• Real time programs, where any global pause will degrade the program quality (for example real-time audio related stuff)
• Programs with lots of references and small allocations (memory usage above 1GB)
• Big game engines, that manages many thousands of objects and resources

For me the biggest advantage is that we can prototype code fast, in case we want to optimize we can always upgrade the code later by adding cleanup routines, or maybe we don't even need to because things may be efficient enough already. I typically use the GC when prototyping new stuff.