Option Pricing with the SABR Model on the GPU

Transcription

1 Option Pricing with the SABR Model on the GPU Yu Tian, Zili Zhu, Fima C. Klebaner and Kais Hamza School of Mathematical Sciences, Monash University, Clayton, VIC3800, Australia {yu.tian, fima.klebaner, CSIRO Mathematics, Informatics and Statistics, Clayton, VIC3168, Australia Abstract In this paper, we will present our research on the acceleration for option pricing using Monte Carlo techniques on the GPU. We first introduce some basic ideas of GPU programming and then the stochastic volatility SABR model. Under the SABR model, we discuss option pricing with Monte Carlo techniques. In particular, we focus on European option pricing using quasi-monte Carlo with the Brownian bridge method and American option pricing using the least squares Monte Carlo method. Next, we will study a GPUbased program for pricing European options and a hybrid CPU-GPU program for pricing American options. Finally, we implement our GPU programs, and compare their performance with their CPU counterparts. From our numerical results, around 100 speedup in European option pricing and 10 speedup in American option pricing can be achieved by GPU computing while maintaining satisfactory pricing accuracy. Keywords-GPU; CUDA; option pricing; SABR model; quasi- Monte Carlo I. INTRODUCTION In the world of financial engineering, there are two main streams for research: developing new financial models and proposing novel computation methodologies to solve the models efficiently. The aim of our research is to study and combine state-of-the-art techniques in financial option pricing, Monte Carlo simulation and other methods for specific research problems. Although Monte Carlo can be fast for some simple and one-dimensional option pricing problems implemented on the Central Processing Unit (CPU), it will definitely be slow for multi-dimensional problems, e.g. for pricing path-dependent options and single- and multi-asset options based on multi-dimensional stochastic processes. The advent of fast GPUs shows a promising way to fast parallel computing. One such implementation is through CUDA [1], an extension of C/C++ developed by NVIDIA. The motivation of using the Graphics Processing Unit (GPU) for computation is that the research applications can be parallelized, or at least partially parallelized. Since Monte Carlo simulation for pricing European options can be highly parallelized, the GPU is an excellent candidate for accelerating computation. In addition, in order to price American options with the least squares Monte Carlo method, GPUbased matrix solver can play an important role. In this paper, we first introduce some basic ideas of NVIDIA CUDA programming in Section II. We then discuss a two-dimensional stochastic volatility model, the SABR model, and option pricing techniques for European and American options under the SABR model in Section III. Next, we study programming techniques for pricing European and American options on the GPU in Section IV. In Section V, we implement numerical experiments and demonstrate the performance of GPU programs for option pricing. II. A SIMPLE DESCRIPTION OF THE CUDA PROGRAMMING SYSTEM The CUDA programming system consists of two parts, a host (CPU) and a device (GPU). The main routine of CUDA programming can be summarized as: 1) set up initial data on the host; 2) allocate device memory for computation; 3) copy initial data from the host to the device; 4) implement computation on the device; 5) copy results from the device to the host; 6) release device and host memory. There are up to 512 threads per block and up to blocks in the CUDA programming architecture. Each thread can be simply seen as a computation unit, while the number of computation units on the CPU is usually 2-4, which is equivalent to the number of CPU cores. Furthermore, threads within the same block on the GPU can cooperate by synchronizing their execution. Regarding the memory used, we mainly use four types for programming: host memory, which is the computer memory used by CPU to store data; global memory, which is the main part of off-chip memory on a graphics card used by GPU to read and write data and used by CPU to transfer data, and which should be coalesced for accesses; local memory, which is a part of off-chip memory used by the thread to read and write data; shared memory, which is on-chip memory with a small size and can be used by threads within the same block. The access to the off-chip global and local memory is slow, and a large part of time in GPU computation is used for Copyright /10/$26.00 c 2010 IEEE

2 transferring data between host and device. However, since the access to shared memory is very fast, the low-latency shared memory provides an efficient means for threads to share data within the same block. To build a good GPU program, we should make the best of shared memory and the cooperation of threads within the same block to reduce the work on the CPU and to accelerate the computation speed. In our GPU implementations, we will use columnmajor ordering to store all vectors and matrices hereafter. We refer to [1] for detailed descriptions of CUDA programming. III. FINANCIAL MODELS A. The SABR model A class of stochastic volatility models has been used to explain why the Black-Scholes implied volatilities are different for options with different strikes and maturities. These models involve a stochastic process for the volatility parameter. One popular socialistic volatility model is the SABR model proposed by Hagan et al. [2]. In the SABR model, the stochastic processes for a forward price F t and its volatility α t are assumed to be df t = α t F β t dwt 1,F 0 = f, dα t = να t dwt 2,α 0 = α, (1) cov[dwt 1, dwt 2 ]=ρdt, where 0 β 1 and ν 0. If the short rate r(t) is assumed to be a deterministic function of the time, the discount rate D(t, T ) is ( T ) D(t, T )=exp r(s)ds. (2) So the spot price S t equals S t = F t D(t, T ). From Ito s lemma, we can express the processes for the spot price S t as ds t = r(t)s t dt + α t S β t D(t, T ) 1 β dwt 1,S 0 = f D(0,T), dα t = να t dwt 2,α 0 = α, cov[dwt 1, dwt 2 ]=ρdt. (3) If β =1,theD(t, T ) term in the process of the spot price disappears. In other cases, it will affect the change of the spot price. When β =1, the spot price model represents a stochastic log-normal process; and when β =0,itisa stochastic normal process. The volatility parameter in the SABR model follows a stochastic log-normal process. An important feature of the SABR model is that it has asymptotic analytical solutions for European options, which are given by Black s formula [2] as V call = D(0,T) {fφ(d 1 ) KΦ(d 2 ), V put = D(0,T) {KΦ( d 2 ) fφ( d 1 ), d 1 = log (f/k)+ 1 2 σ2 B T (4),d 2 = d 1 σ B T, σ B T t where Φ(x) denotes a cumulative distribution function of the standard normal distribution and the implied volatility σ B (K, f) is given by σ B (K, f) = α (fk) (1 β)/2 {1+ (1 β)2 24 log 2 (f/k)+ (1 β) (f/k) ( ) log4 z x(z) { [ (1 β) (fk) 1 β + 1 ρβνα 2 3ρ2 + 4 (fk)(1 β)/2 24 with z = ν α (fk)(1 β)/2 log (f/k), { 1 2ρz + z2 + z ρ and x(z) = log 1 ρ For the case when K = f, the limit lim z 0 then the implied volatility is simplified as σ B (f,f) = α { [ (1 β) 2 α 2 f 1 β f + 2(1 β) α ρβνα 2 3ρ2 + f 1 β 24 ν ]T 2,. (5) z x(z) =1and ν 2 ]T. (6) After calibration of the model parameters from market prices (see, e.g., [2], [3]), the model can be used to capture the volatility surface and to price exotic options. B. Pricing European options with quasi-monte Carlo and Brownian bridging Given a constant risk-free interest rate r and a initial spot price S 0, the European option price at the initial time 0 is given by V (S 0, 0) = e rt E[V (S T,T) S 0 ] (7) where V (S T,T) is the payoff of the European option at maturity T. When using Monte Carlo methods by simulating N paths of the spot price with M time steps, one can approximate the option price V (S 0, 0) by N V (S 0, 0) = e rt k=1 V (Sk t M,t M ) (8) N where the payoff function V (St k M,t M ) is max(st k M K, 0) for European call and max(k St k M, 0) for European put at the maturity T = t M. The SABR model (3) with a constant interest rate r can be discretized with M time steps as S ti+1 = S ti + rs ti Δt + α ti S β t i exp {(T iδt)(β 1)ΔWt 1 i, α ti+1 = α ti + να ti [ρδwt 1 i + 1 ρ 2 ΔWt 2 i ], with S t0 = f exp ( rt ), α t0 = α, i =0,...,M 1, and Δt = T M, ΔW j t i = W j t i+1 W j t i,j=1, 2. (9)

3 A simple way to simulate the increment of a Brownian motion ΔW j t i is to use the property ΔW j t i = (Δt) N (0, 1), wheren (0, 1) is the standard normal distribution. Numerically, the standard normal random number can be generated as a pseudo-random number artificially. The convergence rate of the Monte Carlo simulation is O(N 1/2 ), where N is the number of simulations. For accelerating the convergence of pricing, there are various variance reduction techniques. We refer to [4], [5] for more information. Another good alternative method to Monte Carlo simulation is known as the quasi-monte Carlo method. The idea of quasi-monte Carlo is to use a d- dimensional low discrepancy sequence from [0, 1) d, with d the dimension of the quasi-monte Carlo problem, to generate d-dimensional uniformly distributed vectors. For a problem of k-dimensional single-asset option pricing, the dimension of quasi-monte Carlo d equals k times the number of time steps M. In particular, the dimension of quasi-monte Carlo for single-asset option pricing under the SABR model is 2M as there are two stochastic processes in the model. For multi-asset option pricing, the problem dimension increases accordingly. A good candidate of the uniformly distributed low discrepancy sequences is the Sobol sequence (see [6], [7]). We can convert the uniformly distributed Sobol sequence to standard normals. Since the generation of the Sobol sequence can be parallelized on the GPU (see the NVIDIA GPU Computing SDK), we need a GPU-based algorithm, e.g., the ICNDfloat2 algorithm [8], to obtain the standard normals. The performance of the quasi-monte Carlo is excellent for low dimensional problems but not so good for high dimensions. This is because the theoretical convergence rate O(N 1 log d N) of the quasi-monte Carlo becomes slower than O(N 1/2 ) of the crude Monte Carlo for high dimensional problems, unless N is very large. In addition, the uniformity of the Sobol sequence in higher dimensions is inferior to that in lower dimensions. Hence, the speed of convergence in European option pricing using the Sobol sequence will decrease for a large number of time steps. Nevertheless, note that, from principal component analysis (see [5]), the first few steps of Brownian motion largely determine the movement of a stochastic process. Moreover, since many option contracts depend on the terminal point of Brownian motion, we can use the Sobol sequence from a low dimension with good statistical properties to construct Brownian motion at the terminal point. Hence, we will use Brownian bridging techniques to construct Brownian motion in order to improve the performance of quasi-monte Carlo methods. To be specific, if the time step M is a power of 2, we use the following techniques to generate the Brownian motion: ( see [5]) W t0 =0,W tm = T Z 1, W tm/2 = 1 2 (W t 0 + W tm )+ T/4 Z 2, W tm/4 = 1 2 (W t 0 + W tm/2 )+ T/8 Z 3,. W tm 1 = 1 2 (W t M 2 + W tm )+ T/2M Z M,j=1, 2. (10) where Z i is an independent standard normal generated from the Sobol sequence 1. In such a way, the first standard normal generated from the first coordinate of a Sobol sequence, which should have superior statistical properties, is used to determine the terminal value of the Brownian path. The second standard normal is used to construct the mid-point of the Brownian path and so forth. In such a way, the first few coordinates of the Sobol sequence determine a general shape of Brownian motion. After bridging, we use successive differences of the Brownian motion to simulate paths for the spot price and the volatility parameter. We refer to [5], [9], [10] for detailed discussions on the construction and implementation of Brownian bridges. C. Pricing American options with least squares method An American option can be exercised at any time during its life. The value of an American option is thereby obtained by exercising optimally. Here we assume that the underlying asset does not pay dividend. We will focus on American put options hereafter. When using Monte Carlo methods to price American put options, we need to specify a number of discrete exercise time points within the maturity. Since quasi-monte Carlo with Brownian bridging performs a good approximation in European option pricing, we will continue to use the techniques presented in Section III-B, and combine them with the least squares methods proposed by Longstaff and Schwartz [11] to price American put options. Given M exercise time points t 1,...,t M, the cash flow of an American put at the maturity time t M is set to be the payoff of the put as F M (S tm )=max(k S tm, 0). Atan exercise time t i (i =1,...,M 1) prior to the maturity, the cash flow of an American put option is given by { ψi (S F i (S ti )= ti ), if ψ i (S ti ) C i (S ti ), (11) 0, if ψ i (S ti ) <C i (S ti ), where the immediate exercise value is ψ i (S ti )=max(k S ti ) for put option and the expected continuation value is C i (S ti )=E[ M m=i+1 e r(m i)δt F m (S tm ) S ti ]. To model 1 Note that when applying Brownian bridging techniques to pseudorandom numbers, it will generally not improve the performance of Monte Carlo. One may use conventional variance reduction techniques to improve the performance of conventional Monte Carlo.

4 the expected continuation value with regression-based methods, we will assume a regression function for C i (S ti ). Under the SABR model, we assume the following regression function for estimating the expected continuation value as Ĉ i (S ti )=b 0 + b 1 α ti + b 2 (α ti ) b 3 S ti + b 4 (S ti ) 2 + b 5 α ti S ti. (12) It can be generalized as Ĉ i (S ti )= 5 b j X j (S ti,α ti ). (13) j=0 where b j is the regression coefficient and X j (S ti,α ti ) is called the basis function. To estimate the value of the coefficients, given N simulated values of the spot price with its volatility parameter, we need to identify the set I i of in-the-money paths. At exercise time t i, we collect St k i, α k t i and realized continuation values C i (St k i )= M m=i+1 e r(m i)δt F m (St k m ) in the set of inthe-money paths (k I i ) for regression. Then the following merit function L is to be minimized: L = 5 2 (C i (St k i ) b j X j (St k i,α k t i )). (14) k I i j=0 To find the minimum of L, we can simply solve a system of equations of the first derivative of L with respect to each b j being zero. However, a nearly zero element is likely to occur when using numerical methods to solve the equations, which will give rise to the equations being very close to singular. In such cases we cannot obtain desirable solutions. In addition, we may obtain different sets of regression coefficients which fit the data in the above least squares problem equally well so that it can be difficult to determine which set of coefficients gives better approximations to expected continuation values. An alternative method which gives better estimations is the singular value decomposition (SVD) method. The idea of the SVD method is to find a solution of estimated coefficients in the sense of least squares, i.e, to find a set of b j which minimizes L in equation (14). That is exactly what we need. Furthermore, SVD method is valid for nearly singular equations. For these advantages, we will rely on the SVD method to solve the least squares problem in pricing American options. Let b be the regression coefficient vector, c be the realized continuation value vector from the in-the-money paths and X be the P Q basis function matrix with P the number of in-the-money paths at time t i and Q the number of basis functions, which is 6 in the case of the SABR model from equation (13). In our case of regression, the number of inthe-money paths P is usually much larger than the number of basis functions Q, which implies that the number of equations is much more than that of unknown regression coefficients. For the SVD method, matrix X can be written as X = U W V T, (15) where U is a P Q column-orthogonal matrix, W is a Q Q diagonal matrix containing non-negative singular values of X in the diagonal in descending order, and V is a Q Q orthogonal matrix. Since the diagonal matrix W can be stored as a vector w =(w 0,...,w Q 1 ), we can derive the regression coefficient vector b from b = V [diag(1/w j )] U T c, (16) We refer to [12] for detailed discussions on the SVD method. After all cash flows at each exercise time point are determined, backward regression and payoff comparison are performed. The value of the American put at the initial time t 0 is approximated by V 0 (S t0 )= 1 N N k=1 m=1 M e rmδt F m (St k m ). (17) The general procedure for pricing American put with the least squares Monte Carlo method is summarized in Algorithm 1. Algorithm 1 Least squares Monte Carlo method for pricing American put 1. Simulation: simulaten paths for spot price St k i and its volatility parameter α k t i with M exercise time points t i,fork =1,...,N and i =1,...,M. 2. Approximation: at terminal time t M, set cash flow F M (St k M )=max(k St k M, 0) for k =1,...,N. for i = M 1,...,1 do 2.1. find the set I i of in-the-money paths; 2.2. generate realized continuation value C i (St k i ) and basis function X j (St k i,α k t i ) for j =0,...,5 and k I i ; 2.3. derive regression coefficient b j by the SVD method from C i (St k i ) and X j (St k i,α k t i ) for j =0,...,5 and k I i ; 2.4. estimate expected continuation value Ĉi(St k i ) = 5 j=0 b jx j (St k i,α k t i ) for k I i ; 2.5. for k I i,setψ i (St k i )=max(k St k i ): if ψ i (St k i ) Ĉi(St k i ) then F i (St k i )=ψ i (St k i ) for m = i +1,...,M do F m (St k m )=0 end for else F i (St k i )=0 end if 2.6. for k {1,...,N/I i :setf i (St k i )=0; end for 3. Output: V 0 (S t0 )= 1 N M N k=1 m=1 e rmδt F m (St k m ).

5 IV. PROGRAMMING TECHNIQUES FOR OPTION PRICING A. GPU-based program for pricing European options We first develop a GPU-based implementation for pricing European options under the SABR model with quasi-monte Carlo and Brownian bridging. Here we focus on pricing a European option based on a single asset. We use one thread for one simulation, which contains one path for the spot price and one for the volatility parameter. So the total number of threads used in all blocks equals the number of simulations. Then we can output the payoff in each thread from GPU to CPU and calculate the discounted average of all the payoffs on CPU. In addition, since the construction of Brownian bridges on CPU is very time-consuming but can be parallelized, we can implement Brownian bridging on GPU. The general computation procedure for pricing European options under the SABR model is summarized as: 1) set up initial data on CPU with N simulations and M time steps; 2) generate 2M-dimensional Sobol sequence of N vectors, and convert all vectors into standard normals on GPU; 3) construct all Brownian motions from Brownian bridgingongpu; 4) generate simulation paths, compute the payoff in each thread, and output all the payoffs to CPU; 5) calculate the discounted average of all payoffs on CPU. Since all threads within the same block have the access to the same shared memory and thereby can cooperate, we use shared memory to store the partial sum of the payoffs within one block in order to reduce data transfer from GPU to CPU and the work on CPU. This is done as follows. First, we simulate the underlying process and derive the payoff of the option in each thread. All threads within the same block will not be synchronized until all the payoffs calculated within the block are stored in the shared memory. We implement tree-based summation, see Listing 1. Afterwards, we only need to output all the partial sums to CPU. The number of output results now equals the number of blocks used, instead of the number of simulations. When averaging partial sums, we use Kahan summation algorithm to reduce the numerical error of floating-point code occurred in the summation of a large sequence. See [13] [15] for detailed discussions. To reduce data transfer between GPU and CPU, we find that Step 3 and Step 4 in the above computation procedure can be combined by first constructing two Brownian motions (one for the spot price and the other for the volatility parameter) from Brownian bridging per thread and then by using constructed Brownian motions to generate paths in the same thread. In such a way, we do not need to construct all Brownian motions for the simulation beforehand. Moreover, const int tid=threadidx.x; const int bid=blockidx.x; const int totalid=blockdim.x bid+tid ; // simulate paths for spot price and its volatility parameter in each thread // call option : payoff=s K float thispayoff=thisspot ( dev K); thispayoff=thispayoff >0?thisPayOff :0; extern shared float partialsum []; partialsum [ tid ]=thispayoff ; syncthreads () ; for ( int offset=blockdim.x/2; offset >0;offset >>=1){ if ( tid<offset ){ partialsum [ tid]+=partialsum [ tid+offset ]; syncthreads () ; if ( tid==0){ dev output [bid]=partialsum [ tid ]; Listing 1. Using shared memory to implement partial summation from numerical experiments, we find that time spent on the combined step is almost the same as that spent on Step 4 alone in the above computation procedure and hence the combined step can save us time. In summary, the improved computation procedure is: 1) set up initial data on CPU with N simulations and M time steps; 2) generate 2M-dimensional Sobol sequence of N vectors, and convert all vectors into standard normals on GPU; 3) construct two Brownian motions from Brownian bridging, then generate one simulation per thread, compute the partial sum of the option payoffs per block, and output all partial sums to CPU; 4) calculate the discounted average of all partial sums on CPU. B. Hybrid CPU-GPU program for pricing American options We now discuss our implementation of American option pricing. As a first step, similar to the procedure in Section IV-A, we can implement the simulation part for pricing an American put on GPU and then output paths of the spot price and the volatility parameter to CPU for choosing in-the-money paths. This could save us time while maintaining almost the same precision as that implemented on CPU. When analyzing the CPU program of Algorithm 1, we find that over 80% of the total computation time is used for Step 2. In particular, generating data for regression in Step 2.2 can occupy more than 60% of the total computation time. We note that the generation of realized continuation values in Step 2.2 can be seen as the multiplication of a P R cash flow matrix F and a discount factor vector e with R elements, where P is the number of in-the-money paths at time t i and R is the number of discount period.

6 To accelerate the generation of realized continuation values without much effort, we turn to the parallelization of matrixvector multiplication on GPU with the help of CUBLAS [16], a basic linear algebra library in CUDA. We first allocate GPU memory for multiplication and then copy the cash flow matrix and the discount vector from CPU to GPU. Thereafter we call the single-precision cublassgemv function in CUBLAS to generate a vector of realized continuation values c by c = F e. In addition, the generation of basis functions can also be implemented on GPU, which can save some time. The third step for accelerating American option pricing is to implement the singular value decomposition on GPU with the help of CULA [17], a linear algebra package for CUDA-enabled GPUs. We use the single-precision culadevicesgesvd function in CULA to obtain the matrices U, V and the vector w (see Section III-C), and we obtain the coefficient vector b from matrix-vector multiplication by using cublassgemv on GPU. Consequently, we can also derive the expected continuation value vector in Step 2.4 from multiplying basis function matrix by the coefficient vector on GPU. We now have a hybrid CPU-GPU program for pricing American options. In summary, the following steps in Algorithm 1 will be implemented on GPU: Step 1: simulate paths for spot price and its volatility parameter from quasi-monte Carlo with Brownian bridging on GPU, and then output simulated paths to CPU; Step 2.2: generate realized continuation value vector c = F e by cublassgemv and generate basis function matrix X on GPU; Step 2.3: generate matrices U, V and vector w by culadevicesgesvd and derive coefficient vector b from b = V [diag(1/w j )] U T c by cublassgemv on GPU; Step 2.4: estimate expected continuation value vector ĉ = X b by cublassgemv on GPU, and then output ĉ to CPU for comparison; For other sequential parts of the algorithm, we rely on CPU for computing. V. NUMERICAL RESULTS We now present the numerical results of our GPU implementations of option pricing under the SABR model. All the experiments are implemented on the Monash Sun Grid. The CPU we use is quad-core Intel Xeon L GHz with 48 GB DDR MHz RAM. The GPU is NVIDIA Tesla C GHz with 4 GB GDDR3 800 MHz RAM. The single-precision code is written in Microsoft Visual Studio 2008 SP1 with NVIDIA CUDA 3.1. A. European options In the first numerical experiment, we compare the performances of crude Monte Carlo and quasi-monte Carlo methods on GPU. We set the initial parameters of the SABR model to be: S 0 = 100,K = 100,r =0.05,T =1, (18) α =0.2,β =0.5,ν =0.2,ρ= 0.5. The reference value of the European call is as derived from the asymptotic analytical solution in equation (4). We use 2 15 = simulations but different time steps for comparison, see Table I. In terms of accuracy, we can see that quasi-monte Carlo with Brownian bridges outperforms quasi-monte Carlo without Brownian bridges and the crude Monte Carlo. We also report that if more than 2 20 (around one million) simulations are used, the accuracy of crude Monte Carlo and quasi-monte Carlo without Brownian bridges can match that of quasi-monte Carlo with Brownian bridges. For European options, we find that all the Monte Carlo results obtained from the GPU program are identical to those from the CPU program, which shows that the singleprecision arithmetic of the GPU is comparable to that of the CPU. result relative error time steps=64 GPU-MC % GPU-QMC % GPU-QMC-BB % time steps=128 GPU-MC % GPU-QMC % GPU-QMC-BB % time steps=256 GPU-MC % GPU-QMC % GPU-QMC-BB % Table I COMPARISONS OF MONTE CARLO (MC) AND QUASI-MONTE CARLO (QMC) WITHOUT AND WITH BROWNIAN BRIDGES (BB) ON GPU. THE REFERENCE VALUE IS paths= 2 n CPU (time) GPU (time) speedup s 0.01s s 0.02s s 0.61s 105 Table II COMPARISON OF COMPUTATION TIME (IN SECOND) FOR CPU AND GPU PROGRAMS, TIME STEPS=128 Next, in Table II, we compare the computation time used in GPU and CPU programs for pricing European options when using quasi-monte Carlo with Brownian bridging. We find that a speedup of around 100 times can be achieved as can be seen in Figure 1 while maintaining the same precision. In addition, we find that around half of the GPU computation time is used for transferring data between GPU and CPU. Hence, how to minimize data transfer is a challenge for GPU computing.

7 that, with the help of CULA and CUBLAS, a four-fold speedup can be found in the SVD method implemented on GPU compared to the one on CPU. The parallelization of these operations contributes to a total speedup of around 10 times in pricing American options. speedup paths=2 n CPU (time) GPU (time) speedup total time s 13.63s 10 PS 9.13s 0.48s 19 components DGR s 5.92s 19 SVD 9.30s 2.44s 4 UP 4.80s 4.79s 1 Table IV COMPARISON OF TIME IN CPU AND HYBRID CPU-GPU PROGRAMS FOR PRICING AMERICAN PUTS, PATHS=131072, TIME STEPS=128, PS=PATH SIMULATION, DGR=DATA GENERATION FOR REGRESSION, UP=UNPARALLELIZED PARTS Figure 1. steps=128 Speedup of European option pricing on GPU vs CPU, time B. American options We now implement numerical experiments for pricing American put options. We will compare the performances of our hybrid CPU-GPU version with the CPU version of Algorithm 1. We set the parameters of the SABR model to be: S 0 = 100,K = 100,r =0.05,T =1, (19) α =0.4,β =0.9,ν =0.4,ρ=0.3. change from standard case CPU result GPU result relative difference % K= % K= % β= % ρ= % ν= % Table III COMPARISON OF CPU AND HYBRID CPU-GPU RESULTS FOR PRICING AMERICAN PUTS, PATHS=131072, TIME STEPS=128 We compare the CPU and the hybrid CPU-GPU pricing results with different SABR parameters in Table III. From Table III, we can find very small relative differences between the CPU and GPU results, which shows that our hybrid CPU-GPU program is acceptable. The small numerical difference is due to the rounding error in the implementation of matrix computation on GPU. This can be minimized by updating the CUBLAS and CULA libraries and the GPU hardware. When comparing the computation time in different parts of the CPU and GPU programs in Table IV, we first find that the path simulation part in pricing American option can be accelerated by around 19 times on GPU. Moreover, a speedup of around 19 times can be achieved in data generation for regression on GPU in our example with the help of CUBLAS for matrix multiplication. In addition to We also note that almost half of the GPU computation time is used for data transfer between GPU and CPU, which again demonstrates that efficient data transfer is a key for GPU-based high performance computing. VI. CONCLUSION AND DISCUSSION In this paper, we have presented the implementation of option pricing under the SABR model on GPU. From the numerical results presented for GPU computing, the speed of pricing European and American options can be accelerated significantly while maintaining satisfactory pricing accuracy. A possible and simple extension of the work is to price a European or American option on multi assets. The number of paths simulated on each thread corresponds to the number of assets plus the number of their volatility parameters. However, more advanced GPU-based or hybrid CPU-GPU implementation with efficient data transfer for option pricing need to be investigated in the future. ACKNOWLEDGMENT The authors would like to thank Philip Chan (Monash e- Research Centre) for his kind help with the use of Monash Sun Grid and fruitful discussions on the programming code. REFERENCES [1] NVIDIA, NVIDIA CUDA Programming Guide, 2010, ver [2] P. S. Hagan, D. Kumar, A. Lesniewski, and D. E. Woodward, Managing smile risk, Wilmott Magazine, pp , September [3] G. West, Calibration of the SABR model in illiquid markets, Applied Mathematical Finance, vol. 12, no. 4, pp , [4] P. Jackel, Monte Carlo Methods in Finance. West Sussex: John Wiley & Sons, [5] P. Glasserman, Monte Carlo Methods in Financial Engineering. New York: Springer-Verlag, 2003.

8 [6] P. Bratley and B. Fox, Implementing Sobol s quasirandom sequence generator, ACM Transactions on Mathematical Software, vol. 14, no. 1, pp , [7] S. Joe and F. Kuo, Remark on algorithm 659: implementing Sobol s quasirandom sequence generator, ACM Transactions on Mathematical Software, vol. 29, no. 1, pp , [8] W. T. Shaw and N. Brickman, Differential equations for Monte Carlo recycling and a GPU-optimized normal quantile, 2009, working paper. arxiv: [9] J. Lin and X. Wang, New Brownian bridge construction in quasi-monte Carlo methods for computational finance, Journal of Complexity, vol. 24, no. 2, pp , [10] M. S. Joshi, Graphical Asian options, Wilmott Journal, vol. 2, no. 2, pp , [11] F. A. Longstaff and E. S. Schwartz, Valuing American options by simulation: A simple least-squares approach, Review of Financial Studies, vol. 14, no. 1, p. 113C147, [12] W. H. Press, S. A. Teukolsky, W. T. Vetterling, and B. P. Flannery, Numerical Recipes: The Art of Scientific Computing, 3rd ed. New York: Cambridge University Press, [13] N. J. Higham, The accuracy of floating point summation, SIAM Journal on Scientific Computing, vol. 14, pp , [14] E. Fleegal, Microsoft Visual C++ floating-point optimization, Microsoft Visual Studio Technical Articles, June [15] D. B. Kirk and W. mei W. Hwu, Programming Massively Parallel Processors : A Hands-on Approach, 1st ed. Burlington: Morgan Kaufmann Publishers, [16] NVIDIA, CUDA CUBLAS Library, 2010, ver [17] EMPhotonics, CULA Reference Manual, 2010, ver. 2.1.