GPUs and DSLs for Life Insurance Modeling

Originally published at:

The Solvency II EU Directive came into effect at the beginning of the year. It harmonizes insurance regulation in the European Union with an economic and risk based approach, which considers the full balance sheet of insurers and re-insurers. In the case of life insurers and pension funds, this requires the calculation of the economic value…

Very interesting, thank you for this -complete- post. As a math person, it's always good to see a nice description and modeling of the problem.

I'm currently working with a bank that uses GPUs and develop in a C# framework (nvcc & VS C# compiler), but relies on a tool provided by another company to generate multithreaded or GPU code automatically : I wasn't aware of such alternatives, or of F#.

A question, though, on the C# code snippet. This simulation relies on a stochastic model which means we probably cannot just "compute" the result for a given contract by simply integrating the equation.
Is that stochasticity somewhat hidden under the outer loop (under "results"), that accounts for different scenarii / states of the Markov chain, or has this "expectation" been already computed and translated into the "bj_ii" factor ?

As these loops are sequential by nature, I'd then infer that it's the work of a single thread. Then, what is mapped to thread blocks / grid (a contract, a single simulation, a portfolio) ?


The model directly incorporates the stochasticity of unknown remaining lifetime (through a death intensity function) but not the stochasticity of unknown death intensity (eg. longevity shocks) or unknown interest rates, nor of unknown interest rates: it assumes deterministic future interest rates, often mandated by financial regulation. A more complicated model could account for these unknowns too, or more simply, one could run the given model with a range of death intensities and interest rate curves -- which of course would require more computation time.

Your are right that (the reserve of) each contract is computed in a single thread. An entire portfolio of similar contracts is mapped to thread blocks or grids, though we are also experimenting with mapping a single many-state contract to a thread block.