⚠️ The Branch Coverage Problem

If you record your function with a single execution path, AADC may only capture one branch of an if-statement. When the kernel later encounters the other branch, it may produce incorrect results or fail to compute derivatives properly. This is especially critical for barrier options, path-dependent payoffs, and early exercise features.

The Challenge

Consider a barrier option function that checks if the spot price exceeds a barrier level. If the barrier is breached, the option knocks out and returns zero. Otherwise, it calculates the normal payoff.

Problem: If you record with a spot price below the barrier (e.g., spot = 95, barrier = 100), only the "option still alive" branch is recorded. Later executions with spot prices above the barrier (e.g., spot = 105) will use an incorrect computation graph because the knock-out branch was never recorded!

Step 1: Enable Branch Analysis

Configure the AADC context to track which branches are executed during recording. You can set the analysis mode to comprehensive, which provides detailed information about every conditional statement encountered.

Step 2: Record Multiple Scenarios

To ensure complete branch coverage, record your function multiple times with different input values that trigger different conditional paths. For the barrier option example, you would record once with the spot price below the barrier and again with the spot price above the barrier. AADC can merge these multiple recordings into a single kernel that handles all branches correctly.

Step 3: Review Branch Coverage Report

After recording, retrieve the branch coverage report to verify completeness. The report identifies any branches that were not covered during recording, showing the filename, line number, branch description, and suggestions for additional test scenarios needed to achieve complete coverage.

✓ Best Practices for Branch Coverage

• Record with diverse inputs: Use representative scenarios covering all conditional paths
• Test boundary conditions: Record with values that trigger all if-statement branches
• Use multi-scenario recording: AADC can merge multiple executions into a single kernel
• Review coverage reports: Always check the diagnostics output before production use
• Document branch scenarios: Keep records of which scenarios were used for recording

Automatic Branch Exploration: AADC provides an advanced feature that can automatically explore different branches during recording. When enabled, the system intelligently tests multiple code paths without requiring you to manually specify different scenarios. This ensures complete branch coverage and generates a kernel capable of correctly handling all conditional paths encountered in your pricing function, including complex path-dependent options with multiple barriers, strikes, dates, and stochastic conditions.

🔧 Toolkit Components

Step 1: Initialize Diagnostics Context

Create an AADC context with full diagnostics enabled. Configure where diagnostic reports should be written and set the desired level of detail in the output (from basic summaries to detailed line-by-line analysis).

Step 2: Configure Validation Rules

Define the acceptance criteria for your integration by setting numerical tolerance levels (both absolute and relative), enabling branch coverage analysis with requirements for completeness, and activating gradient validation with appropriate finite difference parameters for derivative checking.

Step 3: Record with Diagnostics

Begin the recording process with diagnostic tracking enabled. Mark each input variable with descriptive names for easier identification in reports. Execute your pricing function as normal, then mark output variables. The system captures comprehensive diagnostic information throughout the recording process.

Step 4: Run Comprehensive Validation

Execute the recorded kernel with multiple test scenarios covering diverse market conditions: below strike with low volatility, at-the-money with medium volatility, above strike with high volatility, and edge cases with extreme parameter values. The diagnostics system tracks all executions and generates a comprehensive report showing validation results across all scenarios. Reports can be printed to console or exported as HTML for detailed review.

AADC can automatically validate AAD-computed gradients against numerically computed finite differences. This provides confidence that the automatic differentiation is working correctly.

Configuration: Enable gradient validation in the context and configure the finite difference method (central, forward, or backward differences) along with the step size for numerical differentiation.

Execution: After recording, execute the kernel with your input values. The system computes both the AAD gradients and corresponding finite difference approximations.

Validation: The validation report compares AAD gradients with finite differences for all inputs. If all gradients match within tolerance, validation succeeds. Otherwise, the report details which gradients have mismatches, their expected vs. actual values, and the magnitude of discrepancies.

Profile kernel execution to identify performance bottlenecks and verify expected speedups.

Capabilities: The performance profiler measures total execution time, kernel compilation time, average execution time per call, and identifies computational hotspots within your pricing function.

Analysis: Reports show where computational time is spent, highlighting which operations or function calls consume the most resources. This information helps identify optimization opportunities and verify that vectorization and other optimizations are working as expected.

Use Cases: Validate that kernels achieve expected speedups (6-100x), identify unexpected performance regressions, optimize critical paths in complex pricing models, and ensure efficient resource utilization across large portfolios.

Inspect the properties and characteristics of generated kernels to understand their structure and verify correct generation.

Kernel Statistics: View the total number of operations in the kernel, count of input and output variables, memory footprint required for execution, and vectorization factor (how many values are processed simultaneously with SIMD instructions).

Branch Coverage Information: See the total number of conditional branches in your code, how many branches were covered during recording, and calculate the coverage percentage to ensure all code paths are properly handled.

Applications: Verify that kernels are generated correctly, ensure complete branch coverage before production deployment, understand resource requirements for deployment planning, and validate that expected optimizations (like vectorization) are applied.

📋 Recommended Test Suite

1. Unit Tests: Test individual functions in isolation with diagnostics enabled
2. Integration Tests: Test complete pricing workflows with representative scenarios
3. Regression Tests: Compare AADC results with existing validated results
4. Edge Case Tests: Test extreme market conditions and boundary values
5. Stress Tests: Verify performance under high load and large portfolios
6. Gradient Tests: Validate all derivatives against finite differences

Integrating AADC Diagnostics into CI/CD Pipelines

AADC's diagnostics can be seamlessly integrated into your continuous integration and deployment workflows. This ensures that every code change is automatically validated before deployment.

Test Automation: Configure your CI/CD pipeline to run comprehensive AADC tests with full diagnostics enabled, validate numerical accuracy against baseline results, check branch coverage completeness, and verify gradient correctness through automated validation.

Artifact Generation: The pipeline can generate and preserve diagnostic reports (JUnit XML format for test integration, detailed logs for debugging, HTML reports for human review) as build artifacts that can be reviewed by the team.

Quality Gates: Set the validation stage to fail the build if any critical issues are detected, ensuring that problems are caught early in the development cycle before reaching production.