Gathering Information Information Collection: Garbage In – Garbage Out.
Garbage Collection .Net
-
Upload
wekoslav-stefanovski -
Category
Software
-
view
244 -
download
2
description
Transcript of Garbage Collection .Net
Ready
Ready
Wekoslav Stefanovski
Senior Developer / Seavus
Комунална Хигиена.net
Ready
Please Muteyour mobile devices
Ready
General Sponsors
Platinum Sponsors
Silver Sponsors
Gold Sponsors
Bronze Sponsors
Promoters
Ready
Agenda
• How is memory organized in .net , how is it managed
and by whom?
• What are garbage generations?
• What are finalizers, and why should I care?
• What are weak references (and why should I care)?
• Things that you should never do
Ready
Memory Organization
Ready
Stack & Managed Heap
• Stack – typically a per-thread 1MB structure.
– (Mainly) used for value types
– Local variables (and parameters) usually live here
– Keeps track of execution chain
– Uses stack frames
– Ultra fast, very light
– No garbage collection, because none is needed
Ready
Stack & Managed Heap
• Heap
– Used for everything not elsewhere
– Not a monolith structure, actually 4 heaps
• Small object heap, generation 0
• Small object heap, generation 1
• Small object heap, generation 2
• Large object heap
– Very fast
– The domain of The Collector
Ready
Stack & Managed Heap
Ready
Garbage collector goals
• To enable you to develop your application without
having to free memory.
• To reclaim objects that are no longer being used, clears
their memory, and keeps the memory available for
future allocations.
• To provide memory safety by making sure that an object
cannot use the content of another object.
• To allocate objects on the managed heap efficiently.
Ready
Garbage collector information
• Runs on top of the Windows (or other) memory
management.
• Does so in 3 generations (Gen0, Gen1, Gen2)
• Works on a separate thread(s)
• Can run concurrently (in the background) or separately
• Optimized for latency or throughput
• Essentially a non-real-time component of .net
Ready
Details of a garbage run
• Three phases:
– Mark
– Sweep
– Compact
Ready
Details of a garbage run - mark
• The assumption is: Everything is dead until proven alive
• The Collector makes a list of root objects (from globals,
things on the stack and processor registers)
• Marks referenced objects as alive
• Mark everything referenced by referenced object as
alive
Ready
Details of a garbage run - sweep
• Move everything that is marked alive to the next
generation
• Fix the references, so they are working
• Nuke the current generation (from orbit)
Ready
Details of a garbage run - compact
• On Gen0 and Gen1 runs, zeroes out everything
• On Gen2 zeroes everything that is not marked as live
• Moves the objects next to one another
• We can easily allocate new objects – includes only
reserving the required memory size
• Constructing new objects is very cheap and fast in .net
• It’s actually faster than C++
Ready
Large Object Heap
• Special handling for large objects
• Too heavy to move – so nobody moves them
• Limit is 85KB
• Not collected on Gen0 or Gen1 collections
• Collected on Gen2 collections
• It is never compacted, so it can get heavily fragmented
ReadyReady
Demo:
Collecting Garbage
Ready
Finalizers and disposables
Ready
Finalizers
• .net does not have destructors
• They are called finalizers
• Finalizers are executed non-deterministically
• Special root collection, called freachable queue
• Causes generational promotion
• It takes at least two runs of different generations to get
rid of a finalizable object
• Exception thrown in finalizers are uncatchable
• Don’t use them if you do not need them
Ready
Disposing
• Managed way to free acquired resources
• Integrated in C# with the using keyword
• It can, but should not throw exception
• The object should be disposed of after use
• No further use is expected after disposal is done
• It can be implemented in a special pattern so that it
plays nicely with finalizers
ReadyReady
Demo:
Implementing Disposable
Ready
Weak References
Ready
Weak references
• Standard references are considered strong
• Weak reference is a non-binding reference
• It might be there, but then again, it mightn’t
• Commonly used by reference counting memory
managers (not required in .net)
Ready
Weak references
• The garbage collector will collect objects that only have
weak references
• Common scenario: objects that are somewhat
expensive to keep, but not very complicated to get (i.e.
MRU document list)
• Never trust IsAlive when it returns true
ReadyReady
Demo:
Weak references
Ready
Some bad advices
Ready
GC.Collect
• Rule 1: Don’t
• Rule 2: Only call it if you can prove you know more that
the GC
• If you have lots of recently deceased objects in
Generation 2
• Rule 1 supersedes rule 2
Ready
Performance Measuring
• Never optimize what does need optimization
• It’s very very rare that a nicely written program has
intense memory pressure
• Always monitor performance
• Use performance counters – the GC has some nice
ones
• Don’t always trust them
• Always profile performance (speed and memory wise)
• Lots of profilers available, included with Visual Studio
• Measure, measure, measure
Ready
Finalizers
• Rule 1: Don’t use finalizers
• Rule 2: Don’t leak resources
• Rule 3: If you have to use finalizers, use the Dispose
pattern
Ready
Bottom line
• Forget this presentation (unless you need to remember it)
ReadyReady
Complete the evaluation and earn the chance to win valuable prizes from our sponsors
Questions
ReadyReady
Thank you