Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1TIedzr. Ben Watson provides a deep-dive introduction to what you need to know to squeeze out the ultimate performance from your .NET code, along with war stories from building the Bing platform query engine. Filmed at qconsf.com. Ben Watson has been a software engineer at Microsoft since 2008. As a core developer of the Bing platform, he has been integral in building one of the world’s leading .NET-based, high-performance server applications, handling high-volume, low-latency requests across tens of thousands of machines for millions of customers.

1. Ben Watson
Principal Software Engineer
Shared Platform Group, Application Services Group, Microsoft
Author, Writing High-Performance .NET Code

2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/bing-net-performance

3. Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
Presented at QCon San Francisco
www.qconsf.com

6. Why Managed Code?

7. Benefits of .NET
Isolation and safety
Easy testing
Debugging
Code is easy to write*

8. GC JIT 3rd Party Code People Factors

9. Garbage Collection
Stops your program DEAD

10. The Threat

11. It’s very easy to build a system that spends an extraordinary
amount of time in GC.
This is not inherent to the CLR!

12. It is impossible to build a low-latency, high-
performance server without taking GC into
account from the beginning.

13. It is a myth that you can’t control the GC – you do so by
controlling allocations.

14. You need to understand the inner workings of the GC, just
like you would any memory allocator.

15. Generational GC in 30 seconds

16. Gen2 Gen1 Gen0
Allocation
point

17. Lessons Learned

18. Objects must die in a gen0 GC
- or –
They must live forever in gen2.

19. You will usually want to optimize for as little memory
allocation as possible.

20. The cost of a GC is proportional to the number of surviving
objects.

21. Consider pooling for objects with a long or unknown lifetime.

22. Pool everything in the large object heap.

23. github.com/Microsoft/Microsoft.IO.RecyclableMemoryStream

24. GC work never stops

25. Just In Time Compilation
Just in time to SLOW YOU DOWN

26. Should you worry about JIT?

27. The Threat

28. Reduce the amount of Code

29. Use the latest .NET

30. Warmup Code

31. Manual JIT
RuntimeHelpers.PrepareMethod

32. NGEN

33. A little of this, a little of that…

34. 3rd Party Code
Trust No One

35. My Code vs. Your Code

38. Joking aside…

39. The Threat

40. The Framework Class Library

41. How would you implement Enum.HasFlag()?

45. Read the Source

46. Default collection sizes

47. Quiz: How many different XML serialization options ship with
.NET?

48. XmlTextReader
XmlValidatingReader
XDocument
XPathNavigator
XPathDocument
LINQ-to-XML
DataContractSerializer
XmlSerializer

49. Methods that throw exceptions in normal conditions.

50. Static analysis

51. FxCop
Stupid String Tricks: ToLower, ToUpper, Format, Join

52. FxCop
Stupid String Tricks: ToLower, ToUpper, Format, Join
Large Static Allocations (>85K go on LOH)

53. FxCop
Stupid String Tricks: ToLower, ToUpper, Format, Join
Large Static Allocations (>85K go on LOH)
Prevent finalizers

54. FxCop
Stupid String Tricks: ToLower, ToUpper, Format, Join
Large Static Allocations (>85K go on LOH)
Force use of pooling APIs for some types
Prevent finalizers

55. FxCop
Stupid String Tricks: ToLower, ToUpper, Format, Join
Large Static Allocations (>85K go on LOH)
Prevent finalizers
Warn against LINQ
Force use of pooling APIs for some types

56. It looks like you’re
writing awful, poorly
performing code.
Would you like to stop
already?
Projects like
RoslynClrHeapAllocationAnalyzer
This is the future…
(note: Clippy not actually included)

57. People Factors
(No, you can’t actually use a
hammer and sword.)

60. You must train people

61. Code does not exist in a vacuum

62. Understand the Tradeoffs

63. Understand the Tradeoffs

64. It is impossible to build a low-latency, high-
performance server without taking GC into
account from the beginning.

65. Performance is a Feature

66. GC JIT 3rd Party Code People Factors

68. Want to know more?
Thursday, 9am, Garden A

69. Resources
• Books
• Writing High-Performance .NET Code
• Book Site – Can get the following for free:
• Intro, Chapter 1 – general measurement guidelines, tools, how to use Windbg
and PerfView (and others)
• Chapter 5 – Performance Considerations of Class Design and General Coding
• Advanced .NET Debugging by Mario Hewardt
• Article: .NET memory allocation details

70. Resources
• Vance Morrison’s CLR Inside Out columns on performance: Measure Early and Often for
Performance, Parts 1 & 2
• http://msdn.microsoft.com/en-us/magazine/cc500596.aspx
• http://msdn.microsoft.com/en-us/magazine/cc507639.aspx
• Interface Dispatch: http://blogs.msdn.com/b/vancem/archive/2006/03/13/550529.aspx
• SOS command reference
• http://msdn.microsoft.com/en-us/library/bb190764.aspx
• Windbg command reference
• http://windbg.info/doc/1-common-cmds.html

71. Tools
• Reflector, ILSpy, ILDASM – tools to convert compiled binaries into readable code. Essential
for understanding how 3rd-party code (including the FCL) works.
• FxCop
• Performance rules are limited, but useful
• Warns about things like multiple casts, Equals() on value types, empty finalizers, etc.
• Lots of other style and correctness rules
• Get in the habit of running these as part of your build
• DON’T get in the habit of issuing exceptions for rule violations -- just fix the issue if
possible

72. Tools
• MeasureIt
• Small, simple tool for running microbenchmarks on the .Net framework
• http://blogs.msdn.com/b/vancem/archive/2009/02/06/measureit-update-tool-for-doing-
microbenchmarks.aspx
• PerfView
• ETW event analyzer with clever views (like a CPU profiler)
• Can analyze both CPU and memory events
• Can tell you who is allocating memory, who owns memory, who is allocating on the LOH
• How often are GCs? How long do they last?
• Exceptions being thrown and handled
• Jitting events
• Anything else that’s an ETW event (which is most things)

73. Tools
• Windbg & SOS
• The best way in many cases to understand what’s really going on
• SOS is the managed debugging extensions
• Comes with CLR, already setup to work with WinDbg in PHX
• See http://msdn.microsoft.com/en-us/library/bb190764.aspx for SOS commands
• Getting started:
• Attach to your process
• .loadby sos clr
• !bpmd program.exe Namespace.Type.Method
• g
• !U @rip
• !ClrStack

74. Watch the video with slide synchronization on
InfoQ.com!
http://www.infoq.com/presentations/bing-net-
performance