S4199 Effortless GPU Models for Finance

Transcription

1 ADAPTIV Risk management, risk-based pricing and operational solutions S4199 Effortless GPU Models for Finance 26 th March 2014 Ben Young Senior Software Engineer

2 SUNGARD SunGard is one of the world s leading financial software and technology services companies ADAPTIV SunGard's Adaptiv solution is a robust, scalable and future-proofed risk infrastructure ANALYTICS A flexible and extensible engine for fast calculations of a wide variety of pricing and risk measures on a broad range of asset classes and derivatives

3 PERFORMANCE DEMANDS Valuations 30 year semi-annual interest rate swap Market Risk Sensitivities 20 HSVaR 250 Monte Carlo VaR MC VaR Factor Groups Potential Future Exposure PFE Stress Tests CVA Sensitivities 5,000 15, ,000 7,000,000 21,000,000

4 ADAPTIV ANALYTICS PRINCIPLES Extensibility Clients extend system in the same way as SunGard Transparency All models written in C# Accuracy Generate accurate cash flows and dynamic dates Availability Avoid barriers to taking advantage of new hardware Flexibility Don t force a particular hardware configuration

5 PERFORMANCE TIMELINE Valuations/second 100 THOUSAND Single Core 1.1 MILLION Multicore 15 MILLION Initial Vectorisation 22 MILLION Current

6 ARCHITECTURE MODEL CODE ABSTRACT VECTOR LAYER PERFORMANCE PRIMITIVES

7 MODEL CODE /// <summary> /// Black & Scholes formula for European options. /// </summary> public static void BlackScholes(Vector vout, Vector typesign, Vector spot, Vector strike, double tau, Vector r, Vector b, Vector v) { if (tau < 0.0) { vout.clear(); // expired } else if (tau == 0.0) { vout.assign(vectormath.max(typesign * (spot - strike), 0.0)); // option payoff } else { using (var cache = Vector.CacheLike(vout)) { Vector stddev = cache.get(vectormath.max(v * Math.Sqrt(tau), CalcUtils.TINY)); Vector d1 = cache.get(vectormath.max(spot, CalcUtils.TINY) / VectorMath.Max(CalcUtils.TINY, strike)); // spot / strike d1.assign((vectormath.log(d1) + (b * VectorMath.Sqr(v)) * tau) / stddev); vout.assign(typesign * (spot * VectorMath.Exp((b - r) * tau) * VectorMath.CdfNorm(typeSign * d1) - strike * VectorMath.Exp(-r * tau) * VectorMath.CdfNorm(typeSign * (d1 - stddev)))); } } }

8 GPU MODEL CODE? Vector operations Virtual call Virtual call Virtual call // Get payoff FX rate payofffxrate.assign(fpayofffxrate.get(tgi.t)); // Get spot price if (fquantocompo!= null && fpayofftype == PayoffType.Compo) { // fquantocompo == null when pricing basket options spot.assign(fspotprice.get(tgi.t) / payofffxrate); } else spot.assign(fspotprice.get(tgi.t) / ffxrate.get(tgi.t)); // Get Volatility Volatility(v, tgi.t, spot); if (ftimetoforward > tgi.t) { // Calculate discount rate GetDiscountRate(r, fdiscountrate, tgi.t, ftimetoforward); // Calculate forward to spot ratio ForwardFactor(b, tgi.t, ftimetoforward); Conditional execution Configurable objects

9 POSSIBLE APPROACHES TRANSLATE C# TO GPU KERNEL PER OPERATION RE-WRITE IN CUDA/OPENCL SOMETHING ELSE

10 KEY INSIGHT - PRIMITIVES VECTORS SCALARS N-DIMENSIONAL SURFACES MATRICES

11 GPU ARCHITECTURE MODEL CODE ABSTRACT VECTOR LAYER PERFORMANCE PRIMITIVES TRACING ENGINE CUDA OPENCL

12 TRACING vout.assign(a + (b * c)) Trace Trace vector code during execution Identify loop boundaries tmp1 = b * c tmp2 = a + tmp1 vout = tmp2

13 TRACING Trace Trace Library tmp1 = b * c tmp2 = a + tmp1 vout = tmp2 Match to previously seen traces Produce and compile CUDA code if needed NVCC

14 case 3: { double* pv0 = get_ptr(vecs + 0) + idx; double v0; double* pv1 = get_ptr(vecs + 1) + idx; double v1 = *pv1; double* pv3 = get_ptr(vecs + 2) + idx; double v3 = *pv3; double* pv4 = get_ptr(vecs + 3) + idx; double v4 = *pv4; v0 = get_scal(scals + 0); e2 = mix(v0, v1, get_scal(scals + 1)); e2 = hull_white(e2, get_scal(scals + 2), get_scal(scals + 3)); e12 = mix(v4, v3, get_scal(scals + 4)); e12 = hull_white(e12, get_scal(scals + 5), get_scal(scals + 6)); e2 = e2 / e12; e0 = e2; e13 = e0; e0 = log(e13); e0 = e0 * get_scal(scals + 7); e13 = e0; *pv0 = v0; vecs += 4; scals += 8; goto JumpDown; }

15 PROCESS SWAP FX FX FX CAP SWAP SWAPTION FX TRACING

16 PROCESS SWAP FX FX FX CAP SWAP SWAPTION FX TRACE EXECUTION TRACING

17 PROCESS SWAP FX FX FX CAP SWAP SWAPTION FX TRACE EXECUTION TRACING

18 PROCESS SWAP FX FX FX CAP SWAP SWAPTION FX EXECUTION

19

20 PERFORMANCE TIMELINE Valuations/second 120 MILLION GPU 100 THOUSAND Single Core 1.1 MILLION Multicore 15 MILLION Initial Vectorisation 22 MILLION Current

21 GPU PERFORMANCE REAL WORLD

22 SUMMARY Keep C# code for models Minimal code changes See through virtual method calls Produce optimised kernel in CUDA or OpenCL

23 Copyright & Confidentiality Copyright 2013 by SunGard Data Systems Inc. ( SunGard ). This document and the software described within are copyrighted with all rights reserved. No part of this document may be reproduced, transcribed, transmitted, stored in an electronic retrieval system, or translated into any language in any form by any means without the prior written permission of SunGard. SunGard makes no warranties, express or implied, in this document. In no event shall SunGard be liable for damages of any kind arising out of use of this document or the information contained within. CONFIDENTIALITY STATEMENT: This document contains information that is confidential or proprietary to SunGard (or its direct and indirect subsidiaries). By accepting this document, you agree that: (1) if there is any pre-existing contract containing disclosure and use restrictions between your company and SunGard, you and your company will use this information in reliance on and subject to the terms of any such pre-existing contract; or (2) if there is no contractual relationship between you or your company and SunGard, you and your Company agree to protect this information and not reproduce, disclose or use the information in any way, except as may be required by law. Some content in this presentation is covered in US patent application