1.
Exploring .NET
memory management
A trip down memory lane
Maarten Balliauw
@maartenballiauw
—

2.
Who am I?
Maarten Balliauw
Antwerp, Belgium
Developer Advocate, JetBrains
AZUG
Focus on web and .NET
ASP.NET MVC, Azure, SignalR, ...
Former MVP Azure & ASPInsider
https://blog.maartenballiauw.be
@maartenballiauw

3.
.NET runtime
Manages execution of programs
Just-in-time compilation: Intermediate Language (IL) ->machine code
Type safety
Exception handling
Security
Thread management
Memory management
Garbage collection (GC)

4.
Garbage Collector

5.
Memory management and GC
“Virtually unlimited memory for our applications”
Big chunk of memory pre-allocated
Runtime manages allocation in that chunk
Garbage Collector (GC) reclaims unused memory, making it available again

6.
.NET memory management 101
Memory allocation
Objects allocated in “managed heap” (big chunk of memory)
Allocating memory is fast, it’s just adding a pointer
Some unmanaged memory is also consumed (not GC-ed)
.NET CLR, Dynamic libraries, Graphics buffer, …
Memory release or “Garbage Collection” (GC)
Generations
Large Object Heap

7.
.NET memory management 101
Memory allocation
Memory release or “Garbage Collection” (GC)
GC releases objects no longer in use by examining application roots
GC builds a graph of all the objects that are reachable from these roots
Object unreachable? Remove object, release memory, compact heap
Takes time to scan all objects!
Generations
Large Object Heap

8.
.NET memory management 101
Memory allocation
Memory release or “Garbage Collection” (GC)
Generations
Large Object Heap
Generation 0 Generation 1 Generation 2
Short-lived objects (e.g. Local
variables)
In-between objects Long-lived objects (e.g. App’s
main form)

9.
.NET memory management 101
Memory allocation
Memory release or “Garbage Collection” (GC)
Generations
Large Object Heap (LOH)
Special segment for large objects (>85KB)
Collected only during full garbage collection
Not compacted (by default) -> fragmentation!
Fragmentation can cause OutOfMemoryException

10.
The .NET garbage collector
Runs very often for gen0
Short-lived objects, few references, fast to clean
Local variable, web request/response
Higher generation
Usually more references, slower to clean
GC pauses the running application to do its thing
Usually short, except when not…
Background GC (enabled by default)
Concurrent with application threads
May still introduce short locks/pauses, usually just for one thread

11.
The .NET garbage collector
When does it run? Vague… But usually:
Out of memory condition – when the system fails to allocate or re-allocate memory
After some significant allocation – if X memory is allocated since previous GC
Failure of allocating some native resources – internal to .NET
Profiler – when triggered from profiler API
Forced – when calling methods on System.GC
Application moves to background
GC is not guaranteed to run
http://blogs.msdn.com/b/oldnewthing/archive/2010/08/09/10047586.aspx
http://blogs.msdn.com/b/abhinaba/archive/2008/04/29/when-does-the-net-compact-framework-garbage-collector-run.aspx

12.
Helping the GC, avoid pauses
Optimize allocations (use struct when it makes sense, Span<T>, object pooling)
Don’t allocate when not needed
Make use of IDisposable / using statement
Clean up references, giving the GC an easy job
Weak references
Allow the GC to collect these objects, no need for checks
Finalizers
Beware! Moved to finalizer queue -> always gen++

13.
Helping the GC
DEMO
https://github.com/maartenba/memory-demos

14.
Allocations

15.
When is memory allocated?
Not for value types (int, bool, struct, decimal, enum, float, byte, long, …)
Allocated on stack, not on heap
Not managed by garbage collector
For reference types
When you new
When you load data into a variable, object, property, ...

16.
Hidden allocations!
Boxing!
Put an int in a box
Take an int out of a box
Lambda’s/closures
Allocate compiler-generated
DisplayClass to capture state
Params arrays
And more!
int i = 42;
// boxing - wraps the value type in an "object box"
// (allocating a System.Object)
object o = i;
// unboxing - unpacking the "object box" into an int again
// (CPU effort to unwrap)
int j = (int)o;

17.
How to find them?
Past experience
Intermediate Language (IL)
Profiler
“Heap allocations viewer”
ReSharper Heap Allocations Viewer plugin
Roslyn’s Heap Allocation Analyzer

18.
Hidden allocations
DEMO
https://github.com/maartenba/memory-demos
ReSharper Heap Allocations Viewer plugin
Roslyn’s Heap Allocation Analyzer

19.
Measure!
Don’t do premature optimization – measure!
Allocations don’t always matter (that much)
Measure!
How frequently are we allocating?
How frequently are we collecting?
What generation do we end up on?
Are our allocations introducing pauses?
www.jetbrains.com/dotmemory (and www.jetbrains.com/dottrace)

20.
Always Be Measuring
DEMO
https://github.com/maartenba/memory-demos

21.
[
{ ... },
{
"name": "Westmalle Tripel",
"brewery": "Brouwerij der Trappisten van Westmalle",
"votes": 17658,
"rating": 4.7
},
{ ... }
]

22.
Object pools / object re-use
Re-use objects / collections (when it makes sense)
Fewer allocations, fewer objects for the GC to scan
Less memory traffic that can trigger a full GC
Object pooling - object pool pattern
Create a pool of objects that can be re-used
https://www.codeproject.com/articles/20848/c-object-pooling
“Optimize ASP.NET Core” - https://github.com/aspnet/AspLabs/issues/3
System.Buffers.ArrayPool

23.
Garbage Collector summary
GC is optimized for high memory traffic in short-lived objects
Use that knowledge! Don’t fear allocations!
Don’t optimize what should not be optimized…
GC is the concept that makes .NET / C# tick – use it!
Know when allocations happen
GC is awesome
Gen2 collection that stop the world not so much…
Measure!

24.
Exploring the heap
for fun and profit

25.
How would you...
…build a managed type system, store in memory, CPU/memory friendly
Probably:
Store type info (what’s in there, what’s the offset of fieldN, …)
Store field data (just data)
Store method pointers
Inheritance information

26.
Stuff on the Stack

27.
Stuff on the Managed Heap
(scroll down for more...)

28.
Theory is nice...
Microsoft.Diagnostics.Runtime (ClrMD)
“ClrMD is a set of advanced APIs for programmatically inspecting a crash dump of
a .NET program much in the same way that the SOS Debugging Extensions (SOS)
do. This allows you to write automated crash analysis for your applications as well
as automate many common debugger tasks. In addition to reading crash dumps
ClrMD also allows supports attaching to live processes.”
“LINQ-to-heap”
Maarten’s definition

29.
ClrMD
DEMO
https://github.com/maartenba/memory-demos

30.
But... Why?
Programmatic insight into memory space of a running project
Unit test critical paths and assert behavior (did we clean up what we expected?)
Capture memory issues in running applications
Other (easier) options in this space
dotMemory Unit (JetBrains)
Benchmark.NET

31.
dotMemory Unit
DEMO
https://github.com/maartenba/memory-demos

32.
Conclusion

33.
Conclusion
Garbage Collector (GC) optimized for high memory traffic + short-lived objects
Don’t fear allocations! But beware of gen2 “stop the world”
Don’t optimize what should not be optimized…
Measure!
Using a profiler/memory analysis tool
ClrMD to automate inspections
dotMemory Unit, Benchmark.NET, … to profile unit tests
Blog series: https://blog.maartenballiauw.be

34.
Thank you!
Maarten Balliauw
@maartenballiauw
—