This document discusses .NET memory management and garbage collection. It provides an overview of common garbage collection strategies like mark-and-sweep and stop-and-copy. The document explains that .NET uses a mark-and-sweep approach with generational garbage collection. It also covers how objects are allocated in the managed heap and cleaned up deterministically using IDisposable and finalizers. Best practices for memory management like disposing of resources are presented.

1. Summer School 2012
Resources
& Memory
Yuriy Guts
R&D Engineer
yuriy.guts@eleks.com

2. Summer School 2012
.NET uses managed storage…
So why do I need do know this stuff?

3. Summer School 2012
Process memory layout (typical)

4. Summer School 2012
Storage management is hard

5. Summer School 2012
Manual vs. Automatic
• Fast • Easy to program
• Precise • Keeps you focused
• Deterministic • Heuristically optimized
BUT BUT
• Error-prone • Unpredictable
• Distracting • Causes noticeable delays
• Hard to debug • Sometimes leaks as well

6. Summer School 2012
Common GC strategies
Mark & Sweep
Stop & Copy
Reference Counting

7. Summer School 2012
Mark & Sweep

8. Summer School 2012
Advantages
• Keeps objects in their places
• Will work well with pointer arithmetics

9. Summer School 2012
Disadvantages
• Can cause heap fragmentation
• Must process every object in the heap
• May require O(n) space to execute

10. Summer School 2012
Stop & Copy

11. Summer School 2012
Advantages
• Fast allocation and collection
• Operates only on live objects
• Does not cause fragmentation

12. Summer School 2012
Disadvantages
• May require some time and space to rearrange
pointers on live objects
• Unsuitable for C / C++

13. Summer School 2012
Reference Counting
• Remember the number of references to each object
• Adjust it accordingly on every assignment

14. Summer School 2012
Advantages
• Easy to implement
• Collects garbage incrementally without
significant delays

15. Summer School 2012
Disadvantages
• Unable to clean up circular structures
• Requires atomic operations (expensive)
• Slows down assignment operations

16. Summer School 2012
?? ?
Which approach does .NET use?

17. Summer School 2012
.NET CLR Managed Heap
NextObjPtr
Managed
Object A Object B Object C Object D Object E Object F
heap
• Items are allocated consecutively.
• The only allocation overhead is about incrementing the pointer!
• When objects are destroyed, the managed heap gets automatically
condensed (except the Large Object Heap!).

18. Summer School 2012
CLR Object Lifecycle
Allocation (IL newobj)
Construction (.ctor)
Member usage (your code)
Cleanup (finalizer)
Deallocation (GC)

19. Object construction algorithm
Calculate the number of bytes required.
Append two system fields of type int.
Type pointer SyncBlockIndex
Make sure there is enough free storage space available in the managed heap.
Fill the block with zero bytes, call the constructor (pass NextObjPtr as this).
Increase NextObjPtr and return the address of newly created object.

20. Summer School 2012
Garbage Collection Triggers
1 • System is running low on memory
2 • A threshold of acceptable memory usage
has been exceeded on the managed heap.
3 • GC.Collect() has been called

21. Summer School 2012
Garbage Collection Algorithm
Suspend all threads except the one that triggered GC
Thread 1 [GC’ing] Thread 2 [suspended] Thread 3 [suspended]
Define application roots (live objects)
Stack roots GC handles Static objects CPU registers
Mark & Sweep
Heap Defragmentation (relocate objects).

22. Summer School 2012
GC Generations

23. Summer School 2012
Deterministic Cleanup: IDisposable
[ComVisibleAttribute(true)]
public interface IDisposable
{
void Dispose();
}
Dispose() — Performs application-defined tasks associated with freeing, releasing,
or resetting resources.

24. Summer School 2012
‘using’: syntactic sugar
using (Bitmap bitmap = new Bitmap(100, 100))
{
Console.WriteLine(bitmap.Height);
}
…is equivalent to:
Bitmap bitmap = null;
try
{
bitmap = new Bitmap(100, 100);
Console.WriteLine(bitmap.Height);
}
finally
{
if (bitmap != null)
{
(IDisposable)bitmap.Dispose();
}
}

25. Summer School 2012
Deterministic Cleanup: Finalization
Do NOT confuse with C++ destructor!!!
class UnmanagedResourceWrapper
{
// Declare and use an unmanaged resource...
~UnmanagedResourceWrapper()
{
// Clean up...
}
}

26. Summer School 2012

27. Summer School 2012
Some Best Practices
1 • DON’T use IDisposable and/or Finalize unless you really have to (see below).
• DON’T use Finalize if you do not have unmanaged resources (such as handles).
• Use IDisposable if your type works with managed resources or contains an
2 IDisposable member.
• Make sure you call base.Dispose() if base class is IDisposable.
3 • Use IDisposable AND Finalize if your type works with unmanaged resources.
• Finalize() should always release the resource and not throw any exceptions.

28. Summer School 2012
GCHandle Tricks
Lifetime monitoring & control
Pinning objects in memory
Weak references

29. Summer School 2012
?? ?
Q&A
yuriy.guts@eleks.com

30. Summer School 2012
Thank you!