AADC C++: Predictable
Linear Scaling

AADC C++ achieves near-linear scaling: 4.7x at 4 threads, 9.2x at 8 threads, 17.6x at 16 threads, and 28.5x at 32 threads for Greeks computation on 1K trades x 100K scenarios.

AADC C++ scales linearly with trades. At 8 threads and 100K scenarios: 10 trades = 1.08s, 100 trades = 2.16s, 1000 trades = 15.69s for Greeks computation.

AADC C++ scales linearly with scenarios. At 8 threads and 1000 trades: 10K scenarios = 1.48s, 100K = 15.69s, 500K = 79.91s for Greeks computation.

AADC C++ achieves 89% scaling efficiency at 32 threads (28.5x speedup vs ideal 32x), demonstrating near-linear scaling.

At 8 threads: Price only = 11.18s, Price + Greeks (Delta, Rho, Vega) = 15.69s. At 32 threads: Price only = 3.17s, Greeks = 5.09s.

Thread count (near-linear speedup), number of trades (linear), number of scenarios (linear), and SIMD vector size (AVX2 vs AVX512). Memory bandwidth can limit scaling at very high scenario counts.

Memory scales linearly with scenarios only (~1.9 MB per 1K scenarios). Memory is constant across threads and trades: 10K scenarios = 19 MB, 100K = 192 MB, 500K = 961 MB. Doubling threads or trades does not increase memory.

Memory depends only on scenario count: 10K scenarios uses 19 MB, 100K scenarios uses 192 MB, 500K scenarios uses 961 MB. Memory is independent of thread count and number of trades.

NAG dco/c++ is a tape-based AAD library similar to Adept. Based on our benchmarks with similar tape-based tools, NAG dco/c++ performance should be approximately 6-100× slower than AADC. NAG uses operator overloading with tape recording, while AADC uses Code Generation AAD with JIT compilation to binary kernels.

Yes, AADC C++ is production-proven at Tier-1 banks. With 8 threads, 1000 trades × 100K scenarios completes Greeks in 15.7 seconds. With 32 threads, the same workload completes in 5.1 seconds.

Greeks overhead (Delta + Rho + Vega vs price-only) is approximately 40% at 8 threads and 60% at 32 threads. This is much lower than the typical 2-5× overhead of tape-based AAD libraries.

Yes, AADC C++ uses OpenMP-style parallelization with lock-free batch processing. Thread scaling is near-linear up to 32 threads with 89% efficiency.

AADC C++ benefits from multi-core CPUs with AVX2 or AVX512 support. Intel Xeon or AMD EPYC processors are recommended. More cores = near-linear speedup.

AADC C++ on modern multi-core CPUs often matches or exceeds GPU performance for financial derivatives pricing, without GPU memory limitations, data transfer overhead, or specialized CUDA programming.