Speed Up Your .NET Apps: AQtime Tips and Best Practices

Advanced AQtime Workflows: Profiling, Coverage, and Optimization

1) Goals and setup

• Goal: Find runtime bottlenecks, detect memory/resource leaks, and maximize test coverage.
• Setup: Install AQtime (integrates with Visual Studio/RAD Studio) and enable debug symbols for line-level data. Use 64-bit build if targeting 64-bit runtime.

2) Recommended profilers to combine

• Performance Profiler (Time): call counts, inclusive/exclusive time, call tree.
• Allocation Profiler: track heap allocations, allocation sites, and object lifetimes.
• Coverage Profiler (or Light Coverage): per-routine and per-line coverage % for tests.
• Leak/Resource Profiler: detect unreleased handles and memory leaks.
• Timeline (if available) / Event Tracing: correlate UI freezes, I/O, and GC pauses.

3) Typical workflow (ordered, repeatable)

1. Baseline run: full app scenario; collect Performance + Allocation + Coverage.
2. Identify hotspots: sort by inclusive time and heavy call paths; inspect source-level call stacks.
3. Inspect memory: switch to Allocation + Leak profilers; find high-allocation call sites and unreleased objects.
4. Narrow scope with filters: profile specific modules/routines or threads to reduce noise and overhead.
5. Use triggers/actions: enable profiling only during target operations (e.g., user action, test case) to get focused data.
6. Run targeted tests: instrument unit/integration tests or automated TestComplete suites to exercise problematic paths and collect coverage.
7. Merge & compare results: auto-merge multiple runs and compare to track regressions or coverage changes.
8. Iterate: apply code fixes, rebuild with symbols, re-run same scenarios and compare before/after results.

4) Analysis techniques

• Call-tree drilling: follow heavy parent routines to root cause; inspect child calls and system calls included/excluded.
• Per-line timing: use line-level profiling for micro-optimizations after addressing higher-level hotspots.
• Allocation stacks: inspect allocation call stacks and lifetime graphs to find retention points preventing GC.
• Coverage gaps: list unexecuted routines/lines (red) to prioritize tests; merge runs from CI to get cumulative coverage.
• Cross-reference: map coverage gaps to hotspots—uncovered slow code may be dead or low-priority.

5) Performance trade-offs & best practices

• Profile at routine level first (low overhead); use line-level only when needed.
• Disable unrelated modules (All Project Modules) to reduce noise.
• Use triggers/actions to limit profiling window and lower runtime impact.
• Prefer repeated, short focused runs over one long noisy run.
• Keep builds with debug symbols for meaningful source mapping; strip symbols for production builds.

6) Automation and CI

• Integrate AQtime with automated tests (TestComplete or CI tasks) to collect repeatable profiles.
• Auto-merge result sets and fail builds when key metrics regress (e.g., execution time, memory allocations, coverage drops).
• Store baseline results and use comparison reports to detect regressions.

7) Quick checklist before fixing code

• Reproduce hotspot reliably in a short run.
• Confirm allocations/leaks with Allocation/Leak profilers.
• Ensure coverage confirms code path exercised.
• Make minimal change, re-run same profilers, and compare merged results.

8) Useful AQtime features to leverage

• Triggers & Actions — focused profiling windows.
• Auto-merge & Compare — track changes across runs.
• IDE integration — jump directly from profiler results to source in Visual Studio/RAD Studio.
• Filtering by thread/module — reduce noise.

If you want, I can convert this into a one-page actionable checklist or a CI-ready profiling script for AQtime.