Yesterday, I read a great article about value and reference types and how their performance behaves. I want to share my notes with you.
- 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.
- 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
@escapingclosures or if the struct is stored by a
- Possible for the
structto perform worse than a
class when it comes to copying
- Value types, that store heap allocated
classobjects, 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.
- 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
class that contain many reference type objects:
- The next snippet will create
HugeStructmany times and check how long the creation takes
- Result: the
structneeds more time then
class, because it uses copy-on-assignment, in comparison to the
classwhich 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
HugeStruct), the more reference counting overhead is added on copying it.
- 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
structwith its Copy-On-Write behavior or if a
classwould fit you better