GBM Asian Option MC

260× Faster First-Run.
48ms Compilation.

AADC delivers the best combination of fast compilation and fast execution for Monte Carlo Greeks computation.

With 48ms compilation time (vs 12.5s for JAX XLA), AADC is ideal for real-time pricing where trade structures change frequently.

All benchmarks are transparent, reproducible, and verifiable.

260×
Faster first-run than JAX
48ms
AADC compilation time
2.7×
Faster Greeks than PyTorch
+31%
Greeks overhead (AAD)
Request Demo See Comparison
Model: GBM Asian Option Monte Carlo
Trades: 100
Scenarios: 50,000
Timesteps: 252
Threads: 8
The Key Finding

Compilation + Execution: The Full Picture

First-run performance matters. JAX is fast after warm-up, but 12.5s compilation makes it unsuitable for dynamic trade structures.

The Problem Heavy Compilation

JAX XLA takes 12.5 seconds to compile. TensorFlow takes 18 seconds. This happens every time trade parameters change.

For real-time pricing: Unacceptable
vs
AADC Solution 48ms Compilation

AADC compiles in 48 milliseconds. Combined with fast execution, total time is 4.2 seconds vs 16.2 seconds for JAX.

Result: 260× faster compilation
3.8× faster total first-run
Total Time: Compilation + Execution

First-Run Performance for Greeks

Lower is better. Compilation time shown in lighter shade.

Compilation
Execution
AADC C++
855ms
AADC Python
4,248ms
C++ (FD)
4,950ms
PyTorch
12,050ms
NumPy (FD)
15,200ms
JAX (XLA)
16,200ms
TensorFlow
23,600ms
Autograd
58,500ms
FD = Finite Difference (4× pricing for Delta, Rho, Vega)

Compilation Time Only

Time to JIT compile / trace the computational graph

AADC C++
35ms
AADC Python
48ms
PyTorch
850ms
JAX (XLA)
12,500ms
TensorFlow
18,000ms
AADC Advantage
260× faster compilation than JAX. Critical for real-time pricing where trade structures change.

Execution Time (Steady State)

Greeks computation after compilation warm-up

AADC C++
820ms
JAX (XLA)
3,700ms
AADC Python
4,200ms
TensorFlow
5,600ms
PyTorch
11,200ms
NumPy (FD)
15,200ms
Autograd
58,500ms
Note
JAX is fast after warm-up, but 12.5s compilation penalty makes it unsuitable for dynamic trade structures.
Greeks Overhead

AAD vs Finite Difference

Additional cost to compute Delta, Rho, Vega beyond price-only

AAD Methods ~31% overhead

Single adjoint pass computes all sensitivities simultaneously.

AADC
+31%
PyTorch
+32%
JAX
+32%
TensorFlow
+33%
vs
Finite Difference ~300% overhead

Requires 4× full pricing (base + bump for each Greek).

NumPy
+300%
C++ Optimised
+482%
* C++ overhead higher due to optimised price-only baseline
Recommendations

When to Use Each Tool

Recommended ✓

AADC

Fast AND simple

  • Real-time pricing & risk
  • Dynamic trade parameters
  • Low-latency requirements
  • Production quant systems
ML Training

JAX / TensorFlow

Fast after warm-up

  • ML model training
  • Batch inference (same structure)
  • GPU acceleration needed
  • Not for dynamic structures
Research

PyTorch / Autograd

Simple but slow

  • Research & prototyping
  • Educational purposes
  • Small-scale experiments
  • Not for production scale

Why JAX/TensorFlow compilation is problematic for quant finance

Valuation graphs in derivatives pricing are significantly larger and more complex than typical ML models. A single exotic trade may generate millions of operations in the computational graph. JAX XLA and TensorFlow's compilation passes scale poorly with graph size, resulting in 12-18 second compilation times that repeat whenever trade parameters change.

In production environments where traders need real-time pricing for RFQs, intraday risk recalculation, or dynamic hedging, this compilation overhead makes JAX/TensorFlow impractical for production deployment. AADC's 48ms compilation enables responsive pricing even with changing trade structures.

Full Data

Detailed Benchmark Data

Tool Compile (ms) Price Only (ms) Greeks (ms) Overhead Total (ms) Memory (MB) LOC
AADC C++ 35 620 820 +32% 855 8 950
AADC Python 48 3,200 4,200 +31% 4,248 12 822
C++ (FD) 0 850 4,950 +482% 4,950 180 1219
PyTorch 850 8,500 11,200 +32% 12,050 2400 890
NumPy (FD) 0 3,800 15,200 +300% 15,200 420 745
JAX (XLA) 12,500 2,800 3,700 +32% 16,200 1800 920
TensorFlow 18,000 4,200 5,600 +33% 23,600 3200 1150
Autograd 0 45,000 58,500 +30% 58,500 850 780
FD = Finite Difference | LOC = Lines of Code | Memory = Peak during Greeks computation

Ready to Accelerate Your Greeks?

AADC delivers the best combination of fast compilation and fast execution. Perfect for real-time pricing where trade structures change frequently.

Schedule Demo View Examples