Good evening everyone!

2013 hasn’t started very well for me as I’ve been sick for the past week and completely unable to work on anything even on a bit of CFA. Thankfully, I’m now starting to get better and I can again put a few words – or pieces of code – together.

I decided to write this quick post because my fiancee’s sister Elsa forwarded me a few questions she had about the material of an exam she had this morning in Embedded Systems. As you might guess, some of the material was dedicated to handling concurrency issues which made me realize that I never discussed parallel programming in C#.

Besides, I just bought a brand new laptop as my previous one was really looking like it was going to die any minute and, without a computer to play around with, I would really be like a professional hockey player without a stick (I hope you like the metaphor). As a matter of fact, this new computer (an Asus G55V) is quite powerful: it has an Intel i7 2.4 Ghz processor with 12 GB of RAM. With this kind of setup, I should be able to run 7 computations at a time (using each of the 7 cores of the Intel i7). Cool huh?

Therefore, I decided to create a little, very simple example of parallel processing in C# applied to quantitative finance. The classic case of parallel processing in this field is usually referring to so-called Monte-Carlo simulations, where you simulate a very large amount of different paths for the price of a stock price according to a given model.

I will split this post in two distinct parts: the model and the simulation. For those of you who are not interested about the financial aspects of this post, feel free to just jump to Part II.

## Part I : the model

### Definition

I chose the model to be the Geometric Brownian Motion, which is used for the well-known Black-Scholes famework. The model states the dynamics of a price process $S_t$ as follows:

$$ dS_t = \mu S_t dt + \sigma S_t dW_t $$

Note that the return are intrinsically modeled like this:

$$\frac{dS_t}{S_t} = \mu dt + \sigma dW_t \sim \mathcal{N}(\mu ~ dt, \sigma^2 dt)$$

To simulate this price process using a programming language, I need to discretize the equation:

$$ \Delta S_t = S_{t + \Delta t} – S_t = \mu S_t \Delta t + \sigma S_t W_{\Delta t} $$

For simplicity’s sake, I’ll assume my model to be looking at daily prices and I will simulate prices every day so $\Delta t = 1$:

$$ \Delta S_t = S_{t + 1} – S_t = \mu S_t + \sigma S_t Z_t \quad \text{with} \quad Z_t \sim \mathcal{N}(0,1) $$

### The implementation

The implementation is very simple: I created a very simple StockPath class which is supposed to simulate a the path of the prices of an arbitrary stock. I gave it the following private methods:

/// <summary> /// Computes the change in price (delta S) between two points in the paths. /// </summary> /// <param name="currentStockPrice">The price of the stack at the first (known) point.</param> /// <param name="randomNoise">The random noise used to estimate the change.</param> /// <returns>The absolute change in price between two points according to the model.</returns> /// <remarks>The underlying model assumes a geometric brownian motion.</remarks> private double _computeStockPriceChange(double currentStockPrice, double randomNoise) { return currentStockPrice * _mean * _timeInterval + _standardDeviation * currentStockPrice * randomNoise; } /// <summary> /// Computes the next stock price given a <paramref name="currentStockPrice"/>. /// </summary> /// <param name="currentStockPrice">The price of the stack at the first (known) point.</param> /// <param name="randomNoise">The random noise used to estimate the change.</param> /// <returns>The next stock price according to the model. This value will never be less than 0.0.</returns> /// <remarks> /// The model makes sure that a price cannot actually go below 0.0. /// The underlying model assumes a geometric brownian motion. private double _computeNextStockPrice(double currentStockPrice, double randomNoise) { return Math.Max(currentStockPrice + _computeStockPriceChange(currentStockPrice, randomNoise), 0.0); }

Note that I also made sure that the stock price $S_t$ would never go below 0.0 (this is not the case in the mathematical model I stated above).

The computation of the path is performed using Math.Net library to generate the normal variables, and is done in the constructor:

/// <summary> /// Initializes a stock path. /// </summary> /// <param name="nbrSteps">The number of steps in the path.</param> /// <param name="mean">The mean of the returns.</param> /// <param name="std">The standard deviation of the returns.</param> /// <param name="timeInterval">The time between two evaluation points.</param> /// <param name="initialPoint">The starting point of a path.</param> public StockPath(int nbrSteps, double mean, double std, double timeInterval, double initialPoint) { //Assigns internal setup variables _timeInterval = timeInterval; _mean = mean; _standardDeviation = std; //Using Math.Net library to compute the required random noise. Normal normal = Normal.WithMeanStdDev(0, 1); IEnumerable<double> returns = normal.Samples().Take(nbrSteps); //Explicit implementation of aggregation mechanism. _lastPrice = returns.Aggregate(initialPoint, _computeNextStockPrice); }

Note that for simplicity and to diminish the computation time, I do not save each step of the price computation: I save only the last price.

## Part II: simulation

For those of you who weren’t interested in the model specifics, this is where the main topic of this posts starts. We previously defined how we compute each path. The main problem with path computation is that you cannot parallelize it because you need to know $S_t$ to compute $S_{t+1}$. However, you can compute different paths in parallel, as they are completely independent from each other. To demonstrate the advantage of using parallel computations, I will want to simulate a very large amount of paths (100’000 of them) each of which will have 10 years of daily data (2520 points).

#### Why is it useful to compute the paths in parallel?

Let’s take a simple real-life example: cooking. Assume you invited a group of friends for dinner. You decided to have smoked salmon and toasts for appetizers and a pizza for the main. Now, what you would most probably do is prepare the pizza, put it in the oven, and while it is cooking, you would make the toasts, and while the toasts are in the toaster, you would put the salmon in a plate and so on. Once everything is done, you put everything in the table. In classic programming, you just cannot do that.

### Haven’t we already been doing exactly that forever?

No, but everything was made to make you believe so. To keep it simple, a processor (CPU) can only do a single thing at a time: that is, if you were a processor, you would be stuck in front of the oven while the pizza is cooking. Some of you might argue that old computers (who had only a single CPU) managed to do several things at a time: you could still move the mouse or open a text editor while running an installation. That’s not really true! Actually, what the computer was doing was to *alternate* between different tasks. To come back to the kitchen example, if you were a computer, you could stop the oven, put the first glass on the table, switch back the oven, wait a little, stop the oven again, put the second glass on the table, restart the oven, wait again a little, and so on… This could look like you’re doing several things at the same time, but in fact, you’re splitting your time between several tasks. In short, a CPU performs computations **sequentially**. The problem with this “fake” parallelization is that although it looks like everything happens at the same time, you actually waste a lot of time because you can’t do many things at the same time.

### What about today?

Modern computers are equipped with multiple cores. For example, my computer has an Intel i7 processor: it has 7 different cores that can process computations on their own. This means that you can compute 7 different things **in parallel**. They work as a team; for the kitchen example the team in the kitchen. This does not mean that I can compute anything in parallel, I need the tasks to be independent (at least to some extent). Now, this doesn’t mean that I can really compute things 7 times quicker. The reason for that is because the computer needs to perform some operations to make synchronize the results together once they are done. In the kitchen example, the team need to make sure that they do not do things recklessly; they need the plates to be ready at a given time; they need to organize themselves. Overall, there is an organisational overhead, but it is offset by the ability of being able to perform several things at the same time.

### Is it difficult to perform parallel computations in C#?

There are several ways to perform parallel computing in C#. Today, I would like to discuss the simplest one: PLINQ. In my functional programming post, I already showed how to use the classical LINQ framework to handle collections functionally. What is incredible about PLINQ is that it automatically handles the parallel aspect of collection operations after the function AsParallel() is called. So, first, I define a creator function which creates a new stock path for a given index (the index is actually useless in our case, but enables us to treat the computations functionally):

Func<int,StockPath> creator = x => new StockPath(nbrPoints, mean, stdDev);

What I want to do is to make sure that this creator is called in parallel several times. Here is now the function I implemented to run a simulation of several paths of a given amounts of points:

/// <summary> /// Runs a simulation and prints results on the console. /// </summary> /// <param name="nbrPoints">The number of points for each path to be generated.</param> /// <param name="nbrPaths">The number of paths to be generated.</param> /// <param name="simulationName">The name of the simulation</param> /// <param name="creator">The function used to create the <seealso cref="StockPath"/> from a given index.</param> /// <param name="mode">The <see cref="Program.ExecutionMode"/></param> public static void RunSimulation(int nbrPoints, int nbrPaths, string simulationName, Func<int,StockPath> creator, ExecutionMode mode) { Stopwatch stopWatch = new Stopwatch(); StockPath[] paths = new StockPath[nbrPaths]; IEnumerable<int> indices = Enumerable.Range(0, nbrPaths - 1); Console.WriteLine("Starting " + simulationName + " simulation."); stopWatch.Start(); switch (mode) { case ExecutionMode.CLASSIC: paths = indices.Select(creator).ToArray(); break; case ExecutionMode.PARALLEL: paths = indices.AsParallel().Select(creator).ToArray(); break; default: throw new ArgumentException("Unknown execution mode", "mode"); } stopWatch.Stop(); Console.WriteLine("End of " + simulationName + " simulation."); var lastPrices = paths.Select(x => x.LastPrice); Console.WriteLine("Min price: " + lastPrices.Min().ToString("N2")); Console.WriteLine("Max price: " + lastPrices.Max().ToString("N2")); Console.WriteLine("Computation time: " + stopWatch.Elapsed.TotalSeconds.ToString("N2") + " sec"); }

The two most important lines are the number #20 and #23. The rest of the function basically computes the executions time and prints the results on the console. Running the simulation in both modes (sequential and parallel) gives me the following results:

Execution mode | Computation time |
---|---|

Sequential | 32.33 sec |

Parallel | 06.29 sec |

As you can see, running the paths in parallel improved greatly the computation time of the simulation; it’s about 5 times quicker. As expected, we did not perform 7 times better (the number of available cores) because we had to do the extra background work of synchronizing the results at the end of the computation.

## Summary

Given the extreme simplicity (only adding the AsParallel() call) of the code to get into parallel mode, using PLINQ seems to be a very good and very accessible solution for simple cases such as this one.

Of course the performance will vary with the processor being used but in general, I would recommend using this PLINQ solution. There are a few important things to think about when using parallelism: think about whether it is really useful:

- Are the computations really independent?
- Are there enough computations to compensate for the extra work required to synchronize the results?

The whole project is available on my GitHub account here: https://github.com/SRKX/ParallelStockPaths.

I hope you enjoyed the demo,

See you next time,

Jeremie

An Intel i7 processor has 4 physical cores. With hyperthreading enabled, each physical core looks like two virtual cores to the operating system, so 8 in total.

Jeremie,

You are actually creating one less than 100,000 StockPath instances in your code. That’s because the line should be “indices = Enumerable.Range(start:0, count:nbrPaths);”.

PS: But thanks for the interesting post!