A data parallel operation is one in which the same function is applied to different inputs. Vectorizing data parallel operations is an important problem with applications in market risk, full portfolio evaluation and numerical schemes. This article compares different approaches for vectorizing the Black Scholes formula for a call option.

Four cases are considered:

1. Using AVX2 instructions
2. Multi Threading
3. Using AVX2 instructions and multi threading
4. Using GPU computing

The four implementations were generated using the SimianQuant library and therefore require equal programmer effort. They are also significantly faster than hand written approaches since the library does not use naive approaches like locks or purely immutable data structures for multi threading. The trends observed are:

1. For the purpose of evaluating the Black Scholes formula, and similar expressions that require computationally intensive atomic operations, a CPU is unambiguously better than a GPU
2. For fewer than 1000 elements, the additional complexity of multi threading degrades runtime performance. Using AVX2 instructions is the only way of improving the performance.
3. Multi threading comes with a significant overhead, and doubling the core count does not halve the runtime

Approach

The multi threaded implementations were benchmarked on two AWS instances to compare the benefits of increasing the core count:

1. A c5.4xlarge instance with 16 cores
2. A c5.18xlarge instance with 72 cores

The GPU implementations were benchmarked on two AWS instances to compare the benefits of using a newer generation GPU, with a higher clock speed and multiprocessor count:

1. A p3.2xlarge instance with an Nvidia V100 GPU
2. A p2.xlarge instance with an Nvidia K80 GPU

The time taken to allocate memory on the CPU and GPU was ignored, because the allocation can be done in parallel with the conversion of the business/persisted representations of the option and market data to ones which can be used for pricing.

In Depth

The SimianQuant library uses Intel’s Thread Building Blocks to implement multi-threading in C++. The benchmarks were run using the default settings. While tuning the parameters could improve the performance, the speedup will at best be incremental.

Runtimes

The simplest way of comparing the different approaches is to compare the median time taken to evaluate the input vector. To simplify the visualization of the result, the log of the median evaluation time (in nanoseconds) with the log of the input vector size.

The corresponding data table is:

Speedup

An alternate way to interpret the results is to compare the speedup of the median evaluation time compared with that in the single threaded scalar case.

The corresponding data table is:

It is observed that for intermediate input vector lengths, i.e. between 2¹⁰ and 2¹⁶, the performance scales superlinearly with input vector size (less than 2x time for 2x input size). This is a consequence of the overheads associated with multi-threading.

Harshad

Goals are not always meant to be achieved, sometimes they simply serve as something to aim for