GPUs have long been positioned as the silver bullet for financial organizations pursuing top computational performance. Chasing proclaimed 100-1000x GPU performance gains versus CPU, many organizations made costly transitions to CUDA—often nearly a decade ago.

This article presents a solution allowing organizations with existing CUDA projects to assess performance for transitioning from GPU to modern CPU systems. Using real-life CUDA examples, we demonstrate how existing GPU-only code can be adopted to run on CPU or GPU simultaneously.

Key Benefits of CPU + AADC Approach:

• Comparable performance to top-tier GPUs
• Automatic Adjoint Differentiation (AAD) - unavailable on GPU
• Larger memory capacity (64-512GB+ vs 8-48GB GPU)
• Easier development - standard C++ vs CUDA
• Lower total cost of ownership
• Escape vendor lock-in

We've made available an open-source equity pricing model benchmark implemented for both CPU and GPU, helping practitioners extract top performance from both platforms for unbiased comparison.

What Was Promised

When GPU initially came to market, Mike Giles, renowned quantitative finance influencer and major GPU promoter, commented: "If there is a big enough market, someone will develop the product".

What Actually Happened

After a decade of technological development, the anticipated revolution for quantitative finance has not transpired. More recently, when Mike Giles was asked "Will GPUs have an impact in finance?" he replied:

"I think IT groups are keen, but quants are concerned about the effort involved... quants have enough to do without having to think about CUDA programming" [MG, pp.22,37]

Technical limitations emerged: Strict memory volume constraints (8-48GB), difficulty with complex control flow, inability to support AAD efficiently, and high development/maintenance costs.

The Real Performance Story

For years, the crucial factor favoring GPU was the ability to generate kernels for safe parallel processing. With proclaimed performance gains of 1000x, CFOs were persuaded to switch despite significant CUDA transition investment and higher software support costs.

Below we provide an approximate comparison of performance and operational costs for modern CPUs vs GPUs, using cloud costs as a proxy for ownership costs.

Figure: Cost-performance comparison NVIDIA V100 GPU vs Intel Xeon Platinum 9282 CPU

Total Cost of Ownership Considerations

The Hidden Cost of Mindset Change

Performance gained in transitioning from CPU to GPU cannot be solely attributed to hardware change. It also involves a costly, and easy-to-dismiss change of mindset, stemming from the transition from object-oriented languages to a matrix-vector multiplication paradigm. This would yield performance improvements despite chip architecture.

Many large banks made long-term commitments to CUDA/GPU years ago. Some have realized this decision created a raft of new liabilities:

There is a way out of the vendor lock-in imposed by CUDA/NVIDIA migration.

Until now, technology similar to CUDA allowing safe multithreading was unavailable on CPU. MatLogica has developed AADC to fill this gap.

AADC vs CUDA Comparison

The Approach

CUDA mainly uses C++ syntax with extensions for parallel programming and GPU management. The AADC approach records scalable CPU kernels by executing original user code for one data sample (e.g., one Monte Carlo path).

Process:

1. Get CUDA analytics to run with AADC for one data sample on CPU
2. AADC records the full valuation graph
3. Compiles scalable CPU kernels supporting safe multithreaded execution
4. Takes advantage of AVX2/AVX512 native CPU vector arithmetic

Complexity: More complex problems (American Monte Carlo pricing, XVA, PDEs) handled with similar approach, modest increases in code complexity.

Implementation: Going Back to Host

To run existing CUDA code with AADC on CPU, we disable CUDA extensions to make code compatible with standard C++ compiler and ready for AADC kernel compilation.

New Compilation Unit for AADC on CPU

 #define double idouble               // Change native types to active AADC types
 #define bool ibool                   // to take advantage of operator overloading  

 // Override CUDA extensions: 

 #define __global__                   // Ignore __global__
 void __syncthreads() {};             // Provide simple stub implementation for CUDA 
                                      // specific API. Other methods can also be 
                                      // implemented such as CUDAMemGetInfo etc.
 struct { int x = 0; } threadIdx;     // Use the zero-th thread to record MC path 0
 struct { int x = 0; } blockIdx;
 struct { int x = 0; } blockDim;

 #include "kernel.cu"                 // Original user CUDA kernel

 // Revert overrides:

 #undef double 		     
 #undef bool
 #undef __global__    
             
 // Normal C++ code follows here

After applying these fixes, kernel.cu compiles as normal C++.

Two-Step Process

1. Start kernel compilation and execute analytics from kernel.cu. Explicitly identify model inputs and outputs.
2. Use compiled CPU kernel instead of original function for subsequent Monte Carlo iterations, running simulation across multiple CPU cores with AVX2/AVX512 parallelization.

We use a model for pricing single-asset Equity Linked Security options developed for CUDA/GPU to examine changes required for CPU execution using MatLogica's AADC.

Original Code: Taken from GitHub and inspired by QuantStart

Code Changes Required

• Vanilla options: No changes to kernel.cu required
• Path-dependent ELS option: Minimal changes needed
• GPU/CPU compatibility: Maintained throughout

Availability: Source code available on request. Builds on Linux and Windows. Located in "CUDA_Example/AADC_Enabled/one-asset ELS/code" with user manual as "Manual.pdf".

Let's compare performance of pricing a one-asset Equity Linked Security option using CUDA/GPU and the AADC-enabled version of CUDA code on CPU.

Test Case Details

• Option Type: Path-dependent Equity Linked Security
• Time Steps: 1,080
• Monte Carlo Simulations: 100,000
• Measurement: Process simulation and pricing logic only (random number generation excluded)

Figure: Execution performance comparison - NVIDIA V100 GPU vs Intel Xeon Platinum 9282 CPU with AADC

*Results are preliminary and being validated by hardware vendors.

Additional CPU Benefits Not Shown in Benchmark

• AAD Support: Automatic Greeks calculation (impossible on GPU)
• Memory: Can handle much larger problems (512GB+ vs 48GB)
• Complex Control Flow: Better support for sophisticated models
• Development: Standard C++ tooling and debugging

Open Source Validation

This example is open source—anyone can run it themselves and recommend improvements for both CPU and GPU. We will update results as we receive feedback from hardware manufacturers and developers.

Beyond Embarrassingly Parallel Problems

In this post, we used an example of an embarrassingly parallel pricing method. MatLogica has solutions for a wide range of more complex models typical in quantitative finance:

• Longstaff-Schwartz pricing of callable products
• XVA calculations (CVA, DVA, FVA)
• PDE solvers for option pricing
• American/Bermudan options with early exercise
• Model calibration with implicit functions

Decision Framework

Migration Path

For organizations with existing CUDA investments:

1. Test AADC adaptation with minimal code changes
2. Benchmark performance on your actual models
3. Support dual builds (CPU and GPU simultaneously)
4. Gradually transition as benefits become clear
5. Leverage AAD benefits impossible on GPU

Related topics: GPU vs CPU quant finance, CUDA on CPU performance, AADC CPU AAD, GPU vendor lock-in escape, Monte Carlo GPU vs CPU benchmark, NVIDIA V100 vs Intel Xeon, CUDA to CPU migration, AAD GPU limitations, quantitative finance hardware comparison, STAC-A2 benchmark, GPU memory constraints quant, CPU vectorization AVX512, escape CUDA lock-in