Performance Data

Performance Benchmarks

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

420x
vs Python
73x
Greeks vs NumPy
5.4x
vs Hand-optimized C++
6-100×
vs Tape AAD
<1
Adjoint Factor

Benchmark Results

Independent benchmarks demonstrating AADC's performance across different use cases

AADC vs JAX, PyTorch, TensorFlow: 40× Faster

Independent benchmark comparing MatLogica AADC against JAX, PyTorch, and TensorFlow for quantitative finance workloads. Results show 40-64x performance advantage for Monte Carlo pricing with 50K paths and 500 time-steps.

  • 40× faster than PyTorch, JAX, TensorFlow for quant workloads
  • 43x faster with graph compilation (0.166s vs 6.82s)
  • 64x faster when reusing compiled kernels
  • Optimized for scalar operations vs tensor operations
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 vs Python, NumPy, C++: 5.4× Faster Greeks

Benchmark comparing Basic Python, NumPy, hand-optimised C++ (AVX2), and AADC Python for Asian option Monte Carlo pricing. AADC delivers 420× faster than Basic Python, 73× faster Greeks than NumPy, and 5.4× faster Greeks than hand-optimised C++ — with only 32% Greeks overhead vs 306% for NumPy and 582% for C++.

  • 5.4× faster Greeks than hand-optimised C++
  • 136s vs 731s for C++ (1000 trades × 500K scenarios)
  • Only +32% Greeks overhead vs +582% for C++
  • 73× faster Greeks than NumPy
  • How AADC accelerates Monte Carlo simulations
View Benchmark

260× Faster First-Run: Runtime JIT Compilation

Benchmark comparing runtime JIT compilation speed of AADC against PyTorch, JAX, TensorFlow and other AD tools. AADC compiles kernels in 48ms at runtime vs 12.5s for JAX XLA—critical for real-time pricing where code must compile on-the-fly for each new trade structure.

  • 260× faster first-run than JAX (4.2s vs 16.2s total)
  • 48ms compilation time vs 12.5s for JAX XLA
  • 2.7× faster Greeks than PyTorch
  • +31% Greeks overhead with AAD vs +300% for finite difference
  • Why compilation time matters for real-time pricing
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

xVA Benchmark: 1770x AADC Speedup

Open-source C++ benchmark demonstrating massive speedups for CVA/DVA Monte Carlo valuation and AD sensitivities using MatLogica AADC on Intel Xeon CPUs with AVX-512 vectorization.

  • 1770x speedup for xVA valuation with AVX-512
  • 832x speedup for xVA pricing plus AAD Greeks
  • Safe parallelization of single-threaded code
  • Integration of AADC into plain C++ code
  • Vectorized parallel execution without manual changes
View Benchmark

AADC vs JAX, PyTorch, Autograd: 127-566× Faster Greeks

Comprehensive benchmark comparing MatLogica AADC against JAX, PyTorch, Autograd, XAD, and Enzyme-AD for Python Monte Carlo Greeks. AADC achieves 127x speedup with 1 thread (348ms total), scaling to 566x with 16 threads (78ms total), with minimal code changes and 3-5x less memory than JIT-based alternatives.

  • AADC 1-thread: 348ms (45ms compile + 172ms execute) - 127x faster
  • AADC 16-thread: 78ms (45ms compile + 22ms execute) - 566x faster
  • JAX: 1.07s total (230ms compile + 710ms execute) - 41x faster
  • Enzyme-AD: 1.05s total (220ms compile + 701ms execute) - 42x faster
  • AADC uses 52-78 MB vs 187-259 MB for JIT-based
View Benchmark

AADC vs CppAD, Adept, CoDiPack: C++ AAD Comparison

Comprehensive benchmark comparing MatLogica AADC against CoDiPack, Adept, CppAD, and autodiff for C++ Monte Carlo Greeks. Multi-threaded bump-and-revalue (75ms) outperforms all open-source AAD libraries, with CoDiPack being the best open-source option at 581ms.

  • Multi-threaded bump: 75ms (fastest)
  • CoDiPack AAD: 581ms (best open-source)
  • autodiff: 132s (134x slower - avoid)
  • AADC provides SIMD + threading + AAD
  • How AADC compares to CoDiPack, Adept, CppAD, autodiff
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