High-Performance Computing

To valuate 500 moderately complex financial instruments, with an average of 10 sec / instrument valuation, across 1000 historical change scenarios took 60 days on a single-core CPU. To make this in a coffee-break requires a speed-up of 10.000.

To achieve this you need to optimize your data structures and algorithms and you might be ably to get significant speed-up by outsourcing special algorithms on GPU co-processors, but you need to distribute your load.

With imperative programming languages (C++, Java, ..), concurrency can only be exploited by writing programs with multiple threads of execution. High-performance multithreading is hard in those languages.

In functional programming languages it is easy.

Mathematica 7's built-in parallel computing represented in its parallel declarative (functional) programming langage is perfect for symbolic, coarser-grain parallelisation. Its extension gridMathematica makes use of pools of network-managed multi-core-multi-compute-node of any scale. It optimizes for the latest hw platforms and you can create minimalist HPC infrastructures.

The valuation of a portfolio:

1. Valuate each portfolio member, an instrument instantiation

2. Accumulate individual instrument prices to obtain the portfolio value

Using a pseudo Mathematica Notation, it looked like this

portfolioValue = Apply[Map[portfolio, Valuate]Accumulate]

where Valuate in real Mathematica Code represents the generic interface to the valuation of ALL deal and instrument types in UnRisk.

To parallelise we changed to

portfolioValue = Apply[ParallelMap[portfolio, Valuate]Accumulate]

That's it? Yes, that is it about. A few lines of code with enormous impact.