Debugging Production SharePoint Applications

1. Debugging Production SharePoint Applications Wouter van Vugt

2. Agenda • How .NET and the CLR work • Optimizing code and the effect on debuggers • Debugging third party code

3. How .NET and the CLR work

4. .NET Applications • Written in any language • Executed in a runtime called CLR • Shield code from hardware specifics • Java: One language, multi OS • .NET: Many languages, one OS (and Mono) • Allows various types of preprocessing of code

5. Common Language Runtime

6. Type Safety • Type Safety • A pointer of a specific type can never point to an object which is not of that type! • Checked at compile AND runtime! • Knowing the actual type enables • Reading its data  Quite useful in debugging  • Calling its functions Car c = new Person() ‘Pointer type’ Pointer Object type

7. Demo Try and Circumvent type safety

8. Creating .NET Applications C#, C++, VB.NET, F#.... (40+) Module Assembly Compile Link PDB PDB

9. Executing code • Assemblies contain mostly IL code • IL is the ‘Machine code’ for .NET • Compiled to native instructions at runtime through the JIT Compiler • Enough information remains to decompile back to source! Language richness compared Machine Code C# IL

10. Executing code with JIT Compilation Console.WriteLine("Hi"); Console.WriteLine("There"); Console metadata static void WriteLine() JIT Compiler Address static void WriteLine(string) JIT Compiler Address Native Address Native CPU Instructions • JIT Compiler • Lookup IL for method • Compile IL to native • Modify metadata to point to compiled code • Jump to compiled code

11. Executing code with JIT Compilation Console.WriteLine("Hi"); Console.WriteLine("There"); Console metadata static void WriteLine() JIT Compiler Address static void WriteLine(string) Native Address Native CPU Instructions • JIT Compiler • Lookup IL for method • Compile IL to native • Modify metadata to point to compiled code • Jump to compiled code

12. Code optimization • Compile-time • Constant value folding • Remove Branch to next instruction and NOP instructions used to break on control flow, {, }, EndIf etc • Overflow checking • … • During JIT • Eliminate local variables • Range check elimination • Method inlining • Tail call optimization • Common subexpression elimination • Dead code elimination • Loop unrolling • …

13. Running non optimized code • Breakpoints • Edit and continue

14. C# Compiler – Variable Generation

15. C# Compiler – Variable Generation Debug Release

16. C# Compiler – Inserting NOP

17. C# Compiler – Inserting NOP Debug Release

18. C# Compiler – Branching

19. C# Compiler – Branching Debug Release

20. Demo Compile time optimizations

21. Just In Time Compilation • Transformation of MSIL to native x86 / x64 / ARM etc • Can optimize code • Mathematically ensured correctness • Takes a small performance hit during startup

22. NGEN.exe • JIT Compilation incurs a runtime cost • NGEN pre-compiles MSIL assemblies to machine code • Runs as a service in the background • Also used by the “.NET Runtime Optimization Service”

23. JIT - Local variable elimination Before User user = GetUser(3); PrintUser(user); PrintUser(GetUser(3)); After

24. JIT – Range check elimination Before static int[] _array = new int[10]; static volatile int _i; static void Main(string[] args) { for (int i = 0; i < _array.Length; ++i) _i += _array[i]; } static int[] _array = new int[10]; static volatile int _i; static void Main(string[] args) { int[] localRef = _array; for (int i = 0; i < localRef.Length; ++i) _i += localRef[i]; } After

25. JIT – Method Inlining Before public class Program { public static int And(int first, int second) { return first & second; } static voidMain(string[] args) { int i = And(5, 4); } } public class Program { static void Main(string[] args) { int i = 5 & 4; } } After

26. JIT – Tail Call Optimization • staticvoid Main(string[] args) • { • TestTailCallOptimization(); • } • publicstaticvoidTestTailCallOptimization() • { • string s = "Test"; • TailCall1(s); • } • staticvoid TailCall1(string s) • { • Console.WriteLine(s); • TailCall2(s); • } • staticvoid TailCall2(string s) • { • Console.WriteLine(s + s); • }

27. Loading non-precompiled assemblies • Native NGEN images are hard to debug • Remove the NGEN image • Or, prevent NGEN image from loading C:\> NGEN uninstall MyAssembly C:\> SET COMPLUS_ZAPDISABLE=1

28. Preventing JIT optimization • Creating debug builds • JIT prevented through compile time attributes • INI file MyAssembly.ini • In Visual Studio, on module load after attach [assembly: Debuggable(DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.EnableEditAndContinue | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.Default)] [.NET FrameworkDebuggingControl]GenerateTrackingInfo=1AllowOptimize=0

29. Demo Debugging optimized code

30. Debugging code • PDB files are as essential as code! • Breakpoints can do way more than break • Tracing is cheaper than debugging • IntelliTrace can run in production

31. PDB Files • Contain vital debugging information • No PDB? Severely limited debugging experience! • Minimal investment: Symbol server • Managed PDB files contain • Source file names / line numbers • Local variable names • Alternate streams  Used by TFS

32. Symbol Servers • Central repository for storing debug symbols • File system based technology • Integrated into Team Foundation and Visual Studio

33. Locating debug symbols • PDB files are located • Same directory as module • Hardcoded path in module • Symbol server cache • Symbol server MyAssembly.dll MyAssembly.pdb Equal GUID GUID

34. Dumpbin.exe • Use to peek inside PE files

35. Prevent loading all PDBs

36. Visual Studio Source Server support • Allows Visual Studio to download relevant source files automatically from a repository.

37. Configuring Symbol Locations

38. PDB alternate streams • Used by TFS to store server path to sources

39. Demo Symbol servers, Source Servers and source indexing

40. Working with break points

41. Setting breakpoints on automatic properties • Use ‘Break at function’ and enter get_name

42. Setting breakpoints on automatic properties • Inspect callstack / locals window

43. Debugging third party code • Red Gate .NET Reflector PRO • Decompile assemblies into source code • Generate PDB file from assembly + source • Enables debugging third party code

44. Enabling remote debugging • Run Remote Debugging x86 or x64 • Give permissions • Connect

45. Demo Debugging SharEPoint