D programs typically use a garbage collector that can make memory management both easier and more efficient. With the garbage collector, you don't have to keep track of object ownership and can defer free memory to a later point, which can boost performance.
However, while the garbage collector is useful, it doesn't absolve you of all thought in the area of memory management, especially when performance is important. In tight loops, you'll want to avoid the garbage collector. The way to do this is to avoid garbage collection allocations. No garbage collection allocation means no garbage collection cycle.
In order to avoid the garbage collector, perform the following steps:
- Find the hotspots in your application. Typically, this means focusing on your innermost loops.
- Remove functions and operations that call into the GC:
- Array literals, except the ones initializing a variable marked static
- Array append or concatenation
- Array length assignment
- Any associative array operation or literal
- The
newexpression - Closures, except the ones marked
scopein the function's parameter list - Nested structs that use local variables that are returned from a function
- Any function that does one of these things
- Move the allocations outside the hotspot or replace them with alternatives:
- Make
staticandimmutablearray literal initializers - Use static array buffers when possible instead of dynamically allocated arrays
- Use stack-allocated classes
- Mark delegate arguments
scopein the function definition
- Make
The D garbage collector only runs at program termination and when a garbage collector allocation is attempted. It doesn't have enough available memory to fulfil the request. Garbage collector allocations are not necessarily easy to find. The syntax may not stand out or they may be hidden behind library functions; however, if you successfully avoid these language constructs, you will successfully avoid the garbage collector.
You'll still have to manage your resources. We'll look at various techniques to help with this throughout the rest of this chapter.
Note
Can we write a program without a garbage collector at all? Yes, in fact, we can write D programs that use the majority of the language, yet don't use the full D runtime or standard library at all and will even work on bare metal without an operating system. However, since this severely limits your library choices, it isn't always a practical option.