Detect and analyze run-time problems

 

  1. Overview
  2. Monitor code coverage to detect untested lines and methods
  3. Code coverage monitoring user interface reference
  4. Analyzing memory leaks
  5. Memory leak analysis user interface reference
  6. Getting started with run-time problem determination
  7. Getting started: Probekit for customized profiling
  8. Run-time problem determination user interface reference
  9. Common causes of slow performance
  10. Detecting performance bottlenecks
  11. Performance bottleneck detection user interface reference
  12. Detecting thread bottlenecks
  13. Thread bottleneck detection user interface reference
  14. Log and Trace Analyzer
  15. Getting started: Performance
  16. Getting started: Code
  17. Getting started: Profiling
  18. Getting started: Memory
  19. Getting started: Thread
  20. The Annotated Source view, source data display
  21. The Annotated Source view, source code with annotations display
  22. Method and Line Code Coverage page, Edit Profiling Set dialog
  23. Method Event and Pattern Editor dialog box
  24. The Coverage Navigator view
  25. The coverage data Preferences pages
  26. The Coverage Statistics view for line and method coverage
  27. Automatic Leak Detection page, Edit Profiling Set dialog
  28. The Leak Candidates view
  29. The Object Details view
  30. Object Reference Graph view Preferences pages
  31. The Object Reference Graph view
  32. Object Reference Graph data commands
  33. The Performance Call Graph view
  34. Performance Call Graph data commands
  35. Execution Time Analysis page, Edit Profiling Set dialog box
  36. The Method Details view
  37. Performance Call Graph preferences
  38. Thread Analysis page, Edit Profiling Set dialog box
  39. The Thread View preferences page
  40. The Thread View
  41. Collecting coverage data for lines and methods
  42. Changing fonts, colors, and font attributes in the Annotated
  43. Opening source code for editing
  44. Flushing coverage data for display in the Coverage Details
  45. Limiting coverage data collection
  46. Controlling the Coverage Navigator display
  47. Managing data in the Coverage Statistics view
  48. Switching between source data and source code in the Annotated
  49. Viewing and analyzing coverage data for lines and methods
  50. Generating a list of leak candidates
  51. Obtaining heap dumps for memory leak analysis
  52. Collecting leak detection data with manual heap dumps
  53. Collecting leak detection data with timed heap dumps
  54. Importing heap dumps for memory leak analysis
  55. Saving leak analysis data
  56. Identifying memory leaks
  57. Getting started: Creating a profiling configuration for run-time
  58. Customizing the Performance Call Graph view
  59. Getting information from the Performance Call Graph view
  60. Collecting performance data
  61. Limiting performance data collection
  62. Getting information from the Method Details view
  63. Opening source code from the Performance Call Graph or Method
  64. Viewing and analyzing performance data
  65. Changing colors and patterns in the Thread View
  66. Collecting thread data
  67. Opening the source code to correct thread bottlenecks
  68. Identifying the methods behind thread bottlenecks
  69. Changing the thread name display format in the Thread View
  70. Changing the timescale in the Thread View
  71. Hiding and showing the legend in the Thread View
  72. Using the Thread View, UML2 Object Interactions view, and
  73. Identifying thread bottlenecks
  74. Zooming and scrolling the time display in the Thread View