Performance Data

Performance Benchmarks

Independent benchmarks demonstrating AADC's performance advantages over traditional AAD approaches, GPU implementations, and ML frameworks.

2871x
vs Python
28x
Greeks vs NumPy
1.9x
vs Hand-optimized C++
6-100×
vs Tape AAD
<1
Adjoint Factor
Interactive

Interactive Benchmark Explorer

Configure trades and scenarios to see real performance data across implementations

AAD Tools

AADC is 10-700× faster than open-source AAD alternatives.

Explore

ML/AD Libraries

AADC Python is 4-24× faster than JAX, PyTorch, and Autograd.

Explore

Python

AADC delivers 420× faster than Basic Python.

Explore

Languages

AADC Python is 2.1× faster than Optimised C++.

Explore

Additional Benchmarks

More detailed benchmarks and comparisons

AADC vs JAX, PyTorch, TensorFlow: 40× Faster

CRITICAL: Total eval time (compilation + execution) is the true metric. JAX shows fast eval_time but 12.5s compilation repeats on every cold start. AADC: 40-64× faster with near-instant 48ms compilation for true production performance.

  • CRITICAL: Total eval time = compilation + execution (the true metric)
  • AADC 260× faster first-run than JAX (48ms vs 12.5s compilation)
  • 40× faster than PyTorch, JAX, TensorFlow for quant workloads
  • JAX's fast eval_time hides slow compilation that repeats on every cold start
  • AADC total time dominates because compilation is negligible
View Benchmark

Intel XVA Benchmark: 1770× AADC Acceleration

Intel whitepaper demonstrating up to 1770x speedup for xVA pricing and 832x for xVA + Greeks on Intel Xeon Scalable Processors with MatLogica AADC.

  • 1770x faster xVA pricing (56 cores)
  • 832x faster xVA + Greeks (56 cores)
  • 35x single-core speedup
  • Enable real-time XVA for trading
  • Meet regulatory requirements efficiently
View Benchmark

2-Asset Autocallable: 100×+ AADC Speedup

Reproducible benchmark for pricing and AAD on a 2-asset autocallable product with interactive results visualization.

  • 100×+ speedup on exotic pricing
  • Full AAD Greeks at minimal overhead
  • Open-source reproducible benchmark
  • Reproducible exotic benchmark methodology
  • Detailed speedup charts and analysis
View Benchmark

AADC C++: 28x Thread Scaling with Linear Predictability

AADC C++ achieves near-linear scaling across threads (28.5x at 32 threads), trades (100x for 10-1000), and scenarios (50x for 10K-500K). Memory scales only with scenarios (~1.9 MB per 1K). Predictable performance enables accurate capacity planning.

  • 28.5x speedup with 32 threads (89% efficiency)
  • Linear scaling with trades: 10 → 1000 = 100x time
  • Linear scaling with scenarios: 10K → 500K = 50x time
  • Memory scales with scenarios only: 19 MB (10K) → 961 MB (500K)
  • 15.7s for 1000 trades × 100K scenarios × 3 Greeks at 8 threads
View Benchmark

150× Faster JIT Compilation: Runtime Benchmark

CRITICAL: Total eval time (JIT compilation + execution) is the true production metric. JAX's fast eval_time (6.5s) hides 12.5s JIT compilation that repeats on every cold start. AADC total time: 6.5s vs JAX total: 19s = 2.9× faster in production.

  • CRITICAL: Total eval time = JIT compilation + execution (the true metric)
  • AADC total: 6.5s (82ms JIT compile + 6.4s exec) vs JAX total: 19s (12.5s JIT compile + 6.5s exec)
  • JAX 'fast after warm-up' is misleading - JIT compilation repeats on every cold start
  • Small benchmarks hide JIT compilation overhead - at scale it dominates
  • AADC JIT graph compilation takes 82ms vs 12.5s for JAX (150× faster)
View Benchmark

QuantLib and ORE: 100×+ AADC Speedup

Accelerate QuantLib and Open Source Risk Engine (ORE) by 100×+ with AADC. Automatic AAD for all models, production-grade performance, zero vendor licensing fees.

  • 100×+ speedup for QuantLib/ORE calculations
  • Automatic AAD for all models
  • No source code modifications required
  • Production-proven at major banks
  • How AADC integrates with QuantLib and ORE
View Benchmark

AADC vs Adept: 832× Faster xVA Greeks

Open-source C++ benchmark comparing AADC against Adept (tape-based AAD) for CVA/DVA Monte Carlo valuation. Demonstrates 832× speedup for pricing plus Greeks using AVX-512 vectorization on Intel Xeon CPUs.

  • 832× faster than Adept for pricing + Greeks
  • 1770× speedup for xVA valuation vs single-thread
  • Code-generation AAD vs tape-based AAD comparison
  • Integration of AADC into plain C++ code
  • Vectorized parallel execution without manual changes
View Benchmark

Learn More

Understand the technology behind these results

How AADC Works

AADC extracts a computational graph (DAG) from existing analytics at runtime and compiles it to optimized machine code, achieving 100-1000× for Python and 6-100× for C++ with automatic derivatives.

Learn More

Accelerate Python Models with AADC

Prototype in Python, achieve C++ performance. Use AADC to accelerate your existing Python pricing models with minimal code changes — no rewrites required.

Learn More
Client Results Research Papers

Want to Run Your Own Benchmarks?

We can benchmark AADC against your specific use cases and workloads

Schedule Benchmark Session Contact Us