Yesterday, I read a great article about value and reference types and how their performance behaves. I want to share my notes with you.

Stack Allocation

Fast and simple place to store data
Uses a stack pointer that points to the top of the stack
Each scope provides the amount of memory it needs to run before it gets executed, then the stack pointer is moved and the scope is executed. Now, the scope can add and remove data to the memory it got allocated.
When the scope is done, the stack pointer is decreased and its data deallocated
Very little costs as only an integer (the pointer) needs to be increased/decreased
Some forms of value types can be stored directly on the stack, as long as their sizes are known at compile time
They also must not be contained by a reference type or contain one, as it would require reference counting
Absence of reference counting overhead leads to an increased performance
When a value type is assigned, it gets copied (called Copy-On-Assignment). However, the copy is performed in a constant time.

Heap Allocations

Used for objects that are flexible in size and whose lifetime can be longer than the scopes
Pointers point to the object in memory
When a resource should be allocated, the memory management is asked to reserve a certain amount of memory for that resource
If the resource is not used anymore, its memory can be freed (managed for us by ARC)
Heap allocation is slower than stack allocation because the data structure is more complex (page tables, …) and it needs to be thread save (in comparison: every thread has its own stack)

Unfortunately, it is not as easy as ’value types go on the stack and reference typed to the heap’.

Value Types on the Heap

Every struct whose size is not known at compile time must be stored on the heap.
Heap allocation is necessary when the struct contains a reference type or is contained by one (or even recursively, meaning it stores a value type object that stores a reference type)
Common situation when for example storing @escaping closures or if the struct is stored by a class directly
Possible for the struct to perform worse than a class when it comes to copying
Value types, that store heap allocated class objects, will not be per-se stored on the heap but will gain a reference counting overhead
Stack allocated value types are copied in constant time, heap allocated value types are not and will take more time.
Copy-On-Write (COW) prevents it from being problematic and many Standard Libraries data structures make heavy use of it (e.g. Array, Dictionary and Set)
With COW, an assigned property will not be copied immediately but only if its content get mutated

Problems with Value Types that store Reference Types

Consider the following struct and class that contain many reference type objects:

The next snippet will create HugeClass and HugeStruct many times and check how long the creation takes
Result: the struct needs more time then class, because it uses copy-on-assignment, in comparison to the class which just increases a reference count
If executed not only 10_000_000 but 20_000_000 times, the struct needs more than twice the time than before, the time of class only merely increases
The more reference types a value type contains (more instances of EmptyClass in HugeStruct), the more reference counting overhead is added on copying it.

Takeaway

Improve the performance by replacing unnecessary references with proper static size value types
For example, this:
May be replaced by this:
Now, the struct is statically sized and the reference counting overhead is removed.
Also keep asking yourself if you really need a struct with its Copy-On-Write behavior or if a class would fit you better