Parallelizing buy/sell decisions in a multiple symbol strategy

Author: leszek

Creation Date: 5/6/2014 4:04 PM

Wealth Lab » WealthScript (.NET) » Parallelizing buy/sell decisions in a multiple symbol strategy

leszek

5/6/2014 4:04 PM

When your strategy includes multiple symbols and the buy/sell decisions per symbol are independent then you can easily parallelize those decisions per bar in your Execute function. Performance increase will depend on how many symbols you have and how computationally intensive are the buy/sell decisions - the more symbols you have and the more intensive the decisions are the more you'll gain in performance in backtesting etc. Here's a strategy example that uses the DJIA stocks with random buy/sell decisions that take at least 1 millisecond each:

CODE:
Please log in to see this code.

Size:

Color:

When your strategy includes multiple symbols and the buy/sell decisions per symbol are independent then you can easily parallelize those decisions per bar in your Execute function.  Performance increase will depend on how many symbols you have and how computationally intensive are the buy/sell decisions - the more symbols you have and the more intensive the decisions are the more you'll gain in performance in backtesting etc.  Here's a strategy example that uses the DJIA stocks with random buy/sell decisions that take at least 1 millisecond each:
[code]
// use parallel buy/sell decisions
#define PARALLEL

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Threading;
using WealthLab;
using WealthLab.Indicators;
using WealthLab.PosSizers;

namespace WealthLab.Strategies
{
	public class ParallelStrategy : WealthScript
	{
		#region config
		/////////////////////////////////
		// config
		/////////////////////////////////

// print debug output
		static bool debugOut = true;
		
		// use DJIA symbols
		static string[] symbols = { "MMM", "AXP", "T", "BA", "CAT", "CVX", "CSCO", "DD", "XOM",
			"GE", "GS", "HD", "INTC", "IBM", "JNJ", "JPM", "MCD", "MRK", "MSFT", "NKE",
			"PFE", "PG", "KO", "TRV", "UTX", "UNH", "VZ", "V", "WMT", "DIS" };
		
		/////////////////////////////////
		// end config
		/////////////////////////////////
		#endregion
		
		// struct for keeping track of individual position
		struct PosInfo
		{
			public string symbol { get; set; }
			public Position pos {get; set; }
			public Bars bars {get; set; }
			public bool signal { get; set; }
		};
		// array for keeping track of buys/sells
		PosInfo[] posInfos;
		// array for signaling completion of buy/sell signal computations
		AutoResetEvent[] doneSignals;
		Random rand;

public ParallelStrategy()
		{
			// add 1 for the selected symbol
			int arrayLengths = symbols.Length + 1;
			posInfos = new PosInfo[arrayLengths];
			// posInfos[0] will be assigned at execution
			// timme since it's reserved for the selected symbol
			doneSignals = new AutoResetEvent[arrayLengths];
			doneSignals[0] = new AutoResetEvent(false);
			for(int i = 1; i < arrayLengths; i++)
			{
				posInfos[i] = new PosInfo();
				posInfos[i].symbol = symbols[i-1];
				posInfos[i].pos = null;
				posInfos[i].bars = null;
				posInfos[i].signal = false;
				doneSignals[i] = new AutoResetEvent(false);
			}
			rand = new Random();
		}
		
		// random 1 in 100 buy signal with sleep to simulate long calculation
		private bool BuySignal(Bars bars, int bar)
		{
			Thread.Sleep(1);
			if(bar <= bars.FirstActualBar)
				return false;
			lock(rand)
			{
				if(rand.Next(0,100) == 9)
					return true;
			}
			return false;
		}
		
		// random 1 in 100 sell signal with sleep to simulate long calculation
		private bool SellSignal(Bars bars, int bar)
		{
			Thread.Sleep(1);
			if(bar <= bars.FirstActualBar)
				return false;
			lock(rand)
			{
				if(rand.Next(0,100) == 9)
					return true;
			}
			return false;
		}
		
		// main
		protected override void Execute()
		{
			if (debugOut)
				ClearDebug();
			
			// setup selected symbol
			posInfos[0] = new PosInfo();
			posInfos[0].symbol = Bars.Symbol;
			posInfos[0].pos = null;
			posInfos[0].bars = Bars;
			posInfos[0].signal = false;
			// setup the rest
			for(int i = 1; i < posInfos.Length; i++)
			{
				posInfos[i].bars = GetExternalSymbol(posInfos[i].symbol, true);
			}

for (int bar = 0; bar < Bars.Count; bar++)
			{
				// parallel decisions
				for(int i = 0; i < posInfos.Length; i++)
				{
#if PARALLEL
					ThreadPool.QueueUserWorkItem((e) =>
					{
#else
						object e = i;
#endif
						if(posInfos[(int)e].pos == null)
						{
							if(BuySignal(posInfos[(int)e].bars, bar))
							{
								posInfos[(int)e].signal = true;
							}
						}
						else
						{
							if(SellSignal(posInfos[(int)e].bars, bar))
							{
								posInfos[(int)e].signal = true;
							}
						}
						doneSignals[(int)e].Set();
#if PARALLEL
					}, i);
#endif
				}
				WaitHandle.WaitAll(doneSignals);
				
				// do the actual buying selling
				for(int i = 0; i < posInfos.Length; i++)
				{
					if(posInfos[i].signal)
					{
						if(posInfos[i].pos == null)
						{
							SetContext(posInfos[i].symbol,true);
							posInfos[i].pos = BuyAtMarket(bar + 1, posInfos[i].symbol + " buy");
							if (debugOut && bar + 1 < Bars.Date.Count)
								PrintDebug(posInfos[i].symbol + " Bought on " + Bars.Date[bar + 1]);
						}
						else
						{
							SellAtMarket(bar + 1, posInfos[i].pos, posInfos[i].symbol + " buy");
							if (debugOut && bar + 1 < Bars.Date.Count)
								PrintDebug(posInfos[i].symbol + " Sold on " + Bars.Date[bar + 1] + ", profit = " + posInfos[i].pos.NetProfitAsOfBarPercent(bar + 1));
							posInfos[i].pos = null;
						}
						posInfos[i].signal = false;
					}
				}
			}
		}
	}
}[/code]

Eugene

5/6/2014 4:38 PM

That's a great way to speed up a Strategy, so thank you for sharing this design pattern with the community. Personally, I prefer to use Parallel.For/ForEach for they're more intuitive and convenient than the ThreadPool (no WaitHandle, no AutoResetEvent, terser code - you know).