Presentation is loading. Please wait.

Presentation is loading. Please wait. 5 Misconceptions about.NET Memory Management Wednesday June 1 st 2011 Clive Tong and Andrew Hunter.

Similar presentations

Presentation on theme: " 5 Misconceptions about.NET Memory Management Wednesday June 1 st 2011 Clive Tong and Andrew Hunter."— Presentation transcript:

1 5 Misconceptions about.NET Memory Management Wednesday June 1 st 2011 Clive Tong and Andrew Hunter

2 Developer,.NET Reflector Developer, ANTS Memory Profiler Your presenters

3 The webinar Clive: 5 misconceptions about.NET memory management (30 mins) Andrew: Q&A session for any questions to do with.NET memory $50 Amazon voucher for the best answer to Clives question. Please type questions into your GoToWebinar chat box

4 Some Misconceptions About Memory Management in.NET Clive Tong Red Gate Software

5 Five misconceptions 1 A garbage collector collects garbage 2 Doing lots of gen0 collections is bad 3 Performance counters are great for understanding what is happening 4.NET doesnt leak memory 5 All objects are treated the same

6 1) The Garbage Collectors Collect Garbage The focus is really on the non-garbage Most (young) objects die young Designed to collect dead items without processing them individually Note this is for generation 0

7 A simple mutator var collect = new List (); while(true) { collect.Add(new A()); new A(); new A(); }

8 Allocation in generation 0 Generation 0 After one iteration of the while loop As we go into the fourth iteration

9 No space, so copy Promote gen0 gen1

10 Fix-up gen0 gen1

11 And recycle gen0 gen1

12 Observations Trick is that objects are allowed to move Need to get to a safe point when pointers can be fixed Additionally this allows quick allocation

13 Fast allocation 0:000> u 002c2020 mov eax,dword ptr [ecx+4] mov edx,dword ptr fs:[0E40h] add eax,dword ptr [edx+48h] cmp eax,dword ptr [edx+4Ch] ja 002c203b mov dword ptr [edx+48h],eax sub eax,dword ptr [ecx+4] mov dword ptr [eax],ecx ret 002c203b: jmp clr!JIT_NewFast (5cbded01)

14 Solution Avoid locking too frequently by having thread specific allocation buffers Thread 1 allocation buffer Thread 2 allocation buffer

15 And there is one other trick Use generations to focus attention – 0,1,2 Need to track object references 0:000> u 5cbc2fb0 clr!JIT_WriteBarrierEAX: mov dword ptr [edx],eax cmp eax,271100Ch jb clr!JIT_WriteBarrierEAX+0x17 (5cbc2fc7) shr edx,0Ah nop cmp byte ptr [edx+0BD63E0h],0FFh jne clr!JIT_WriteBarrierEAX+0x1a (5cbc2fca) ret clr!JIT_WriteBarrierEAX+0x18: nop mov byte ptr [edx+0BD63E0h],0FFh ret

16 2) Lots of gen0 collections is bad We have covered this already Time proportional to live data Though with (fixed) overheads Worse case double allocation

17 3) Performance counters are accurate Quick demonstration

18 Periodic measurements Its important to remember that these are updated when a collection happens No collection means the counter is stuck The average value can be misleading

19 class Program { static void Main(string[] args) { var accumulator = new List (); while (true) { DateTime start = DateTime.Now; while ((DateTime.Now - start).TotalSeconds < 15) { accumulator.Add(new Program()); Thread.Sleep(1); } Console.WriteLine(accumulator.Count); } } }







26 4).NET doesnt leak Its a question of definition Old definition -Forgot to de-allocate after use -Lost the final pointer to some memory -Forgot your responsibilities

27 New definition Premature release was often fatal Those days are gone (*) The runtime is ultra-cautious Its difficult to have an effective cost model (*) except when you aggressively dispose

28 What makes things live longer? Runtime User Library Compiler

29 Runtime Type of build Having a debugger attached Heuristics choosing when to collect higher generations Finalizers

30 User Event handlers Assigning temporary values to fields Value only needed on some code paths

31 Library Caches without a lifetime policy Data binding

32 Compiler Closures

33 Closures class Program { private static Func s_LongLived; static void Main(string[] args) { var x = 20; var y = new int[20200]; Func getSum = () => x + y.Length; Func getFirst = () => x; s_LongLived = getFirst; }


35 5) All objects are created equal Copying takes a while Need a better way to handle large objects Resort to standard mark-and-sweep No compact at the moment

36 No copying during collection Before After

37 Some observations No movement, so no fix-ups Potential parallelism But potential fragmentation Only do when gen2 is collected Temporary large objects dont fit model All blocks are touched

38 The problem of fragmentation Before collection After collection Next allocation Allocate block of this size:

39 Conclusion Theres a lot going on inside your process heap The only way to really understand what is going on is to use tools to visualize things

40 Q&A Session Please type your questions into the GoToWebinar box We will read out your questions for Andrew to answer

41 Thank you! A recording of this webinar will be emailed to you tomorrow Do get in touch!

Download ppt " 5 Misconceptions about.NET Memory Management Wednesday June 1 st 2011 Clive Tong and Andrew Hunter."

Similar presentations

Ads by Google