Option Engine: a grid  enabled software package to evaluate financial options * §

Francesca Mariani, Maria Cristina Recchioni, Francesco Zirilli

 

 

1.     Introduction

2.     The Option Engine project

3.     Some difficulties encountered in the Option Engine  project

4.     The Option Engine performance on a grid: some numerical experiments

5.     Download the software package Option Engine

6.     Appendix: Instructions to use the Option Engine package

1. Introduction

The development of parallel  applications using service oriented grid-oriented infrastructures is of great interest in several  fields of practical relevance.   Platform Computing   is interested in  investigating the applicability of Service Oriented Middleware (SOAM) to high performance numerical computing.  Products such as the Platform LSF environment for Grids/Clusters, Platform Enterprise Grid Orchestrator (EGO) grid resource management platform and Platform Symphony Enterprise Grid package for financial services are an evidence of the work made in this direction by Platform. The work presented in this website consists in a software package named Option Engine that implements 27 modules of the QuantLib software library in a grid environment consisting in the Platform Symphony Enterprise Grid package. These modules evaluate the prices of several kinds of traded financial options. The main novelty of the Option Engine software package is that it makes available in the Symphony environment a relevant subset of QuantLib modules. Symphony allows to optimize the computing resources once assigned a work load (i.e.: the computation of the prices of several options through the use of the QuantLib modules contained in Option Engine). As shown in Section 4 with an example, computing n modules on a computing grid in the Symphony environment is computationally more efficient than computing the same modules in the LSF environment (for example using a job-array).

The Option Engine package consists of the following modules:

 01. Black-Scholes

         02. Barone-Adesi/Whaley

         03. Bierksund/Stensland

         04. Integral

         05. Finite Differences

         06. Binomial Jarrow-Rudd

         07. Binomial Cox-Ross-Rubistein

         08. Binomial equiprobabilities

         09. Binomial Trigeorgis

         10. Binomial Tian

         11. Binomial Leisen-Reimer

         12. Binomial Joshi

         13. MC (crude)

         14. QMC (Sobol)

         15. MC (Longstaff Schwartz)

         16. Digital payoff

         17. Discrete dividends

         18. Bates

         19. Ju

         20. FD for dividend options

         21. Heston

         22. Black-Scholes with Hull-White

         23. Heston with Hull-White

         24. MC (crude) Heston

         25. QMC (Sobol) Heston

         26. Heston Variance Option                

         27. Perturbative Barrier Option

 

The titles of the 27 modules are self explanatory for an user familiar with mathematical finance.

A reference for the first 25 modules can be found in http://quantlib.org/reference/group__vanillaengines.html,  a reference for the 26th module can be found  in

http://quantlib.org/reference/class_quant_lib_1_1_integral_heston_variance_ option_engine.html and finally a reference for  the 27th module can be found in http://quantlib.org/reference/class_quant_lib_1_1_perturbative_barrier_option_engine.html

 

 

 The modules 26 and 27 are derived from the research work of the authors of this website and of their co-workers. More specifically  module 26 considers the problem of pricing variance options (for further details see http://www.econ.univpm.it/recchioni/finance/w4) and   module 27 considers the problem of pricing  barrier options in the Black Scholes framework with time dependent coefficients (for further details see http://www.econ.univpm.it/recchioni/finance/w3). 

The realization of the Option Engine package has been made possible thank to the effort of CERI Università di Roma “La Sapienza” with the assistance of  Platform Computing and QuantLib. Option Engine is an example that shows how  the Symphony package can be profitably used to perform scientific computations, that is profitably used to run QuantLib library routines. The project substantially consists in  grid-enabling a subset of the routines contained in  QuantLib with behind-the-scene data decomposition and deployment.

For the convenience of the reader  we give below some information about Symphony and QuantLib.

Symphony is a grid computing middleware that enables to build and deploy rapidly distributed services through a single, high-level paradigm for multi-core and multi-node environments. Platform Symphony is widely deployed by financial institutions to process computer and time-sensitive applications, such as trading, pricing, risk analysis, profit and loss reporting and trade settlement, in real time across an Enterprise Grid computing infrastructure. Recently available as a free trial download, Platform Symphony Developer Edition (DE) provides developers with powerful HPC tools to build and deploy service-oriented applications. With comprehensive and easy to follow coding examples, developers can create and test out high-performance application services in the language of their choice in record time. The demo of Symphony DE can be downloaded from: http://www.platform.com/Products/platform-symphony

QuantLib is a C++ Open Source library for financial quantitative analysis that contains source codes of several kinds: codes that perform mathematical operations, such as constrained and unconstrained optimization and/or interpolation, codes that generate random numbers sampled from a given probability distribution, and codes that compute the price of derivative contracts with assigned parameters. The  library boost must be installed to be able to use QuantLib.

 

2 The Option Engine project

In the past years we have carried out two projects that can be considered as preliminary steps to the project presented here, that is:

1.      The use of Symphony to grid enable a Fortran routine for the pricing of variance options (see http://www.econ.univpm.it/recchioni/finance/w4). The grid-enabled version of the Fortran routine has been realized providing a Fortran dll and inglobing it in a suitable C++ program that calls the Fortran dll. The Symphony enabled version of the Fortran routine used to price variance options is available at the website http://www.econ.univpm.it/recchioni/finance/w4.

2.      A preliminary work that shows the feasibility of taking a specific algorithm in the QuantLib library (http://quantlib.org/) and enable it on the grid through Symphony (see http://www.ceri.uniroma1.it/ceri/zirilli/w2). In particular in http://hpccommunity.org/f13/simple-option-applications-using-symphony-quantlib-15/   two packages have been provided: bs_symphony and mc_symphony.  These packages contains Symphony applications that make available in the Symphony environment two QuantLib codes that implement the evaluation of the price of a European call/put option with prescribed value of the underlying, of the volatility, of the discount factor and of the strike price  using the Black Scholes formula (bs_symphony) and  using the Monte Carlo method (mc_symphony). These packages have been made available in Symphony environment  transforming the applications originally written as  C++ codes contained in QuantLib in  dll libraries that usually have  extensions “a” (for example math.a). These  dll libraries are  put in a bigger dll library that contains also the Symphony libraries needed for the input/output operations and for the environment management. Note that the input/output instructions must be adapted to the input/output needs of the application. In the website http://www.ceri.uniroma1.it/ceri/zirilli/w2 the steps that must be performed to make available in the Symphony environment the QuantLib pricing engines Black Scholes and Monte Carlo are described. This work has been done  on a Linux machine with kernel 2.4 where there are installed LSF, Symphony, QuantLib-0.8.1, and boost-1_33_1.

The new project that we are presenting here can be summarized as follows:

3.      The main idea of the project  is the extension of the work described in 2 to develop a more complete software package.  The workflow of the project has been the following:

a)      QuantLib developers have provided a generic infrastructure to grid-enable QuantLib algorithms and have integrated in the latest version of QuantLib (version 0.9.7) two routines developed by the authors and their co-workers. The first routine is a C++ version of the Fortran routines  described in 1 for pricing variance options (module 26) and the second routine is a routine to price barrier options with time dependent parameters (module 27). These two routines integrated in QuantLib are  Heston Variance Option (see http://quantlib.org/reference/class_quant_lib_1_1_integral_heston_variance_ option_engine.html, for further details see read_me_variance_options), and Perturbative Barrier Option (see http://quantlib.org/reference/class_quant_lib_1_1_perturbative_barrier_option_engine.html, for further details see read_me_perturbative_barrier_options),

b)      Symphony developers have provided a modified version of the bs_symphony mentioned in  2 that runs under Symphony DE 4.0 and is able to read data from a file and to provide its output on video and on file,

c)      CERI - Università di Roma “La Sapienza” after contributing to the integration of the two routines described in a) in QuantiLib  has made Symphony enabled these two routines plus twenty five routines of QuantLib (i.e. the basic engines of the option pricing, see http://quantlib.org/reference/group__vanillaengines.html). This work has been done  on a Linux machine with kernel 2.4 where there are installed LSF, Symphony DE 4.0, QuantLib-0.9.7, and boost-1_33_1. In this step a C++ code (EquityOption1.cpp) provided by QuantLib developers has been slightly modified in order to generate a code that can be invoked by the file service.cpp in order to make Symphony enabled the twenty seven routines. This code is substantially a C++ template that can be used to invoke any QuantLib routine and to generate C++ codes to invoke routines of other libraries. In particular as described in Section 3 EquityOption1.cpp and service.cpp are the files that the user must modify to be able to invoke new routines.   

3 Some difficulties encountered in the Option Engine project

In this Section we describe some of the difficulties encountered in the realization of the Option Engine project.

 

The items a) and b) of the project have been realized making Symphony enabled some C++ functions.  This enabling can be obtained easily using a C++ code that calls the functions that must be Symphony enabled and using the files client.cpp and  service.cpp to assign the input parameters. In the realizations made in items a) and b)  the input data are read by video and the file client.cpp and service.cpp had to be modified when some new input parameters had to be introduced. This structure is heavy and has been improved in the final realization of item c).

A preliminary realization of item c)  is the package equi_symphony2.zip. This package has been realized without improving the input output operations. In fact it was necessary first of all to overcome the difficulty coming from the need of invoking a C++ class in a Symphony environment.  The package equi_symphony2.zip  realized the call to  C++ classes in a Symphony environment  and made Symphony enabled fifteen QuantLib routines (see http://quantlib.org/reference/examples.html) to evaluate several kinds of vanilla options  in financial applications (such as, for example, call and put European, American and Bermudan options in the Black Scholes world).

The package equi_symphony2.zip runs under Symphony version 2.6. This version of Symphony does not allow to enable more than one application at a time. This justify the use Symphony DE 4.0 instead than Symphony version 2.6 to overcome this limitation and to complete  the project producing a software package able to  read data from files. The Symphony developers had produced a sample of how to proceed to go from Symphony version 2.6 to Symphony DE 4.0 that is available in the HPC forum http://hpccommunity.org/f13/simple-option-applications-using-symphony-quantlib-15/ . We have analyzed this software in order to realize the item c) of the project.

Some other  difficulties encountered in pursuing the realization of the Option Engine package are listed below.

(i-1) The Fortran codes that price  the variance options in the Heston model framework available in the web-site http://www.econ.univpm.it/recchioni/finance/w4  and  the Fortran code that prices barrier options in the time dependent Black Scholes framework available in the web-site   http://www.econ.univpm.it/recchioni/finance/w3  have been translated in C++ language  to be integrated in QuantLib.

The main difficulty of the translation work  has been the correct implementation of the input operations. In fact the input parameters in QuantLib must be introduced using suitable QuantLib functions. Furthermore  the C++ codes implemented (variance options and barrier options) require user supplied functions and these input functions must be introduced as input data. This difficulty has been overcome introducing example codes to run these routines. These example codes are  available in the test-suite of QuantLib in the web-site: https://quantlib.svn.sourceforge.net/svnroot/quantlib/trunk/QuantLib/test-suite.

Thank to the work of QuantLib developers  the  C++  codes resulting from the translation have been integrated in the repository of  QuantLib and are available  in the website: https://quantlib.svn.sourceforge.net/svnroot/quantlib/trunk/QuantLib/ql/experimental.

These codes have been tested before the  integration in the new release of the QuantLib library .

 

(i-2) The test of  the C++ routines for pricing variance options and barrier options as members of the repository of QuantLib has not been   an easy task since we had to run the routines with a QuantLib library subversion. This last fact implied that  some modifications of the varianceoption.cpp and of the barrieroption.cpp files were necessary because of some troubles with the boost and with some auxiliary QuantLib routines (i.e. FlatRate). 

(i-3)  We made Symphony enabled the 25 routines of the Vanilla Option Engine in Symphony DE 4.0 environment. This application reads the input parameters from a file and produces an output file. The reading from a file makes the structure of the file client.cpp  independent of the particular  module considered simplifying the Symphony enabling procedure of  scientific modules. In this phase  the main difficulty  was the comprehension of  the Symphony DE approach  to the input/output operations and the realization of the new client.cpp and service.cpp files.

 

(i-4) Once available the latest version of QuantLib (version 0.9.7), we added to the 25 routines mentioned (i-3) the two new  QuantLib routines (i.e.: modules 26 and 27)   to realize the  Symphony enabled Option Engine package. The main difficulty in the realization of the C++ code that calls the 27 routines has been the use of the QuantLib “DayCounter” subprogram  since the  Barrier Option module (module 27)  uses a DayCounter different from the others QuantLib modules.

 The service.cpp application has been modified in order to introduce the output of these 27 routines both on a file, named “result.txt” and on video.

 

 4 The Option Engine performance on a grid: some numerical experiments

In this section we compare the performance of Symphony with the performance of the LSF job array. The LSF job array is a LSF instruction able to submit simultaneously up to 1000 copies of   the same code with different input data. This instruction  allocates the jobs on the free processors  following a sequential order, that is when one of the processors of the grid is free a job is allocated on it.  Using the job array instruction no considerations are made about the computing load of the grid at the time when the jobs are submitted. An example of the job array instruction is:

bsub –m hostname –J”name_we_want”[1-100] $PWD/nome_executable_file

 

The previous instruction submits 100 copies of  the executable file named “nome_executable_file”.

 

Symphony is able to perform a smart allocation of the jobs that must be executed by a preliminary study of the free resources of the grid and of the computing load present on the grid at the time when the jobs  are submitted.    

 

The following results have been obtained using  a Linux machine with 4 processors and  kernel 2.4 with  LSF system software.

We have considered as computing load the computation of six or twelve barrier options using module 27. The following tables show the results of a comparison between the use of Symphony  and the use of LSF job array.

Note that the Symphony jobs and the LSF jobs are submitted at the same time.

Table 1

Method used to compute

 the 6 modules

      Execution Time

 (expressed in seconds)

Interactive run with one processor

1080

Symphony run

535

LSF job-array [1-6] run

575

 

 

Table 2

Method used to compute

 the 12 modules

      Execution Time

 (expressed in seconds)

Interactive run with one processor

2124

Symphony run

1064

LSF job-array [1-12] run

1118

 

We note that the use of the Symphony package reduces the computing time of about 40 seconds in Table 1 and of about a minute in Table 2 that  is we have a time reduction of  7.5 per cent and 6 per cent respectively. This effect increases when we use a larger number of processors. In this experiment Symphony was able to use immediately at least 50% of the resources at our disposal and to distribute suitably the computing load among the resources. On the contrary the distribution of the load in the job-array instruction is fixed a priori by the user that chooses the number and the order of the jobs and the job array instruction, in our experience,  does not use at least the 50% of the available resources as done by Symphony. Generally this percentage is smaller than 50% and this fact probably is the reason of the difference between the execution times shown in the tables. The advantage of using Symphony increases when the computation to be executed, the computing grid used and the load present on the grid become more complex.  Note that as shown in Table 1, 2 the advantage of using Symphony  reduces when  the number of tasks that must be executed increases, in fact the margin to improve the allocation of the jobs on the computing resources reduces due to the  heavy load already present on the computing resources.

 

5 Download the software package : Option Engine package

To download the software package Option Engine click here

 

 

 6 Appendix: Instructions to use the Option Engine package

The package has the following structure:

 

OptionEngine/

README                you are reading this file  

OptionEngine.xml        the service description file

client/                            the application client code

service/                          the application service code

mathlib/                         the library of the QuantLib Option Engine

common/                  common classes to client and server

This application has been tested on a Linux machine with kernel 2.4 where there are installed LSF, Symphony, QuantLib-0.9.7, and boost-1_33_1.

The archive OptionEngine.zip contains a Symphony DE 4.0 application named OptionEngine that computes 25 modules of the Vanilla Option Engines of the QuantLib library and 2 extra modules of the  QuantLib library (0.9.7). That is  27 functions are implemented (see Introduction).

The OptionEngine application reads the input data from a file and writes the results on a file named result.txt and on the video.

We provide the file example.txt that contains a test case for each set of input parameters required by the modules. This file is contained in the directory “output” .               

Warning: Remind that in order to generate the executable version of OptionEngine  the user must run the makefile contained in the directories: mathlib, common, service, client (download read_me.txt).

Note that in the makefile contained in the directory mathlib the user must change two paths that refer to the QuantLib-0.9.7.a:

LIBF2C =  insert the path to      /lib/libQuantLib-0.9.7.a

and that refer to the boost:

$(G++) -I insert path to Quantlib -->  /include -I  insert path to boost --> /boost/include/boost-1_33_1 -c EquityOption1.cpp

 

 

 

Note that in the makefile contained in the directory service the user must change a path that refers to the QuantLib-0.9.0.a:

MATT=  insert the path to   /lib/libQuantLib-0.9.7.a

 

We assume that Symphony is installed in the directory /$HOME/symphonyDE/DE40/. 

To install the two libraries boost-1_33_1 and QuantLib-0.9.7 it is necessary to download in /home/boost/ from the website the following compressed files: boost-1_33_1.tar.gz and boost-jam-3.1.13-1-linuxx86.tar and in /$HOME/quantlib/ from the website QuantLib-0.9.7.tar.gz.

To install Boost-1_33_1 the following commands are necessary:

>> cd /$HOME/boost/

>> tar zxvf boost-1_33_1.tar.gz

>> cp boost-jam-3.1.13-1-linuxx86.tar $HOME/boost-1_33_1/.

>> tar zxvf boost-jam-3.1.13-1-linuxx86.tar

>> configure –prefix =  $HOME/boost/

>> make install

To install QuantLib-0.9.7 the following commands are necessary:

>> cd  $HOME/quantlib/

>> tar zxvf QuantLib-0.9.7.tar.gz

>> configure –disable-shared --with-boost-include=/home/boost/include/boost-1_33_1 –with-boost-lib= $HOME/boost/lib –prefix= $HOME/quantlib

 

>> make install

 

Finally we update the library path:

 

>> export LD_LIBRARY_PATH = $HOME/boost/

 

>> export LD_LIBRARY_PATH = $HOME/quantlib/

 

In order to make available in the Symphony environment the Option Engine  we must perform the following steps:

 

 

1)      We connect to a server, where Symphony, Quantlib and boost are installed, with the network   protocol ssh. We entry in the subdirectory  $HOME/symphonyDE/DE40/conf and start Symphony through the commands:

             >>  . profile.soam

      >> soamstartup &

 

2)      We copy the content of the package Option Engine, that can be downloaded from this website, in a new subdirectory of  $HOME/symphonyDE/DE40/4.0/ named OptionEngine

3)          We write a C++ code: the EquityOption1.cpp that contains the call to the QuantLib class. Click here to see the code EquityOption1.cpp. Go down in the directory of $HOME/symphonyDE/DE40/4.0/EquityOption/mathlib.  The code EquityOption1.cpp can be compiled and a suitable library generated using the command:

 

            >>./make

 

4)      Go down in the directory of $HOME/symphonyDE/DE40/4.0/EquityOption/common. Generate the communication library using the command:

 

            >>./make 

 

 

5)      Go down in the directory of $HOME/symphonyDE/DE40/4.0/EquityOption/service. We modify the file service.cpp to call the routine contained in EquityOption1.cpp. Create the executable file service in the directory:  $HOME/symphonyDE/DE40/4.0/EquityOption/output/ with the command:

             >>./make 

 

6)           Go down in the directory of $HOME/symphonyDE/DE40/4.0/EquityOption/client. Generate the client executable file in the directory: $HOME/symphonyDE/DE40/4.0/EquityOption/output using the command:

            >>./make 

 

7)   In the directory $HOME/symphonyDE/DE40/4.0/OptionEngine/output/, compress the file service and deploy the compressed file with the following commands:

>> tar cvf service.tar service
>> gzip service.tar
>> soamdeploy add OptionEngineServicePkg -p service.tar.gz -c /OptionEngine

8) In the directory $HOME/symphonyDE/DE40/4.0/OptionEngine/, create the application profile,  OptionEngine.xml.

>> soamreg $HOME/symphonyDE/DE40/4.0/OptionEngine/OptionEngine.xml

9) Confirm that the registration worked properly by running the following command;

>> soamview app

that verifies if the application, OptionEngine, is enabled.

10) Now you can run the client of new Symphony application, OptionEngine, in the directory $HOME/symphonyDE/DE40/4.0/OptionEngine/output/     with the following command:

>>./client [input file name] [number of tasks]

Note: [input file name] is a text file containing input data (example.txt can be used). Each line in the file  consists of the parameters that must be given as input parameters to call QuantLib routines.

[number of tasks] is a number of splits applied to your tasks input. If the input file contains 10,000 lines and [number of tasks] = 4, then there will be 4 tasks, each containing 2,500 lines of input data.

 

Input file template (download template_data.txt):

 

 

Example of parameters necessary for modules: 01, 04, 13, 14, 22

 

module number, type call/put,  month, day, year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2

 

 

 

Example of parameters necessary for modules: 02,03,15,16,19

 

module number, type call/put,  month, day, year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

month (American options),  day (American options), year (American options)

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2, 9, 23, 2009

 

 

 

Example of parameters necessary for modules: 05,06,07,08,09,10,11,12

 

module number, type call/put,  month, day, year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

month (American options),  day (American options), year (American options),

number of exercise dates (max 400) (Bermudan options), list of dates (month, day, year) at

which the option can be exercised.

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2, 0, 0, 0, 3, 6, 20, 2008, 12, 20, 2009, 5, 20, 2010

 

 

Example of parameters necessary for modules: 17, 20

 

module number, type call/put, month, day,  year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

type of dividend months (1=one month, 2=two months,..., only for dividend options), number of dividend months

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2, 2, 5

 

 

Example of parameters necessary for module: 18

 

module number, type call/put,  month, day, year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

initial stochastic variance, speed of mean reversion, long term mean variance, vol of vol, correlation coefficient,

lambda Poisson process intensity,  mean of Poisson logarithm process, volatility of the Poisson logarithm process 

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2, 0.2, 3.2, 0.02, 0.14, -0.6, 0.2, 4, 0.4

 

 

Example of parameters necessary for methods when we want to price options under Heston model: 21,23,24,25

 

module number, type call/put, today month, today, today year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

initial stochastic variance, speed of mean reversion, long term mean, vol of vol, correlation coefficients 

1, 1, 5, 20, 2008, 12, 20, 2012, 1.0, 0.85, 0.0, 0.03, 0.2, 0.2, 3.2, 0.02, 0.14, -0.6

 

 

Example of parameters necessary for module: 26

 

module number, type call/put, today month, today, today year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility,

initial stochastic variance, speed of mean reversion, long term mean, vol of vol, correlation coefficients 

26, 1, 12, 18, 2008, 12, 18, 2009, 1.0, 0.05, 0.0, 0.0, 0.1, 2.0, 2.0, 0.02, 0.1, -0.5

 

 

Example of parameters necessary for module: 27

 

module number, type call/put,  month, day, year, maturity month, maturity day,

maturity year, underlying, strike, dividend, risk free interest rate, volatility (this value is not used,

the volatility is defined in the code EquityOption1), barrier value

27, -1, 12, 18, 2008, 12, 18, 2009, 100.0, 101.0, 0.02, 0.03, 0.1, 101.0

 

 

 

 


References:
1.
http://quantlib.org/index.shtml
2. http://www.ceri.uniroma1.it/ceri/zirilli/w2

3. http://www.econ.univpm.it/recchioni/finance/w3/
4. http://www.econ.univpm.it/recchioni/finance/w4/



*  A donation of Platform Computing (Toronto, Canada) to CERI – Università di Roma “La Sapienza” (Roma, Italy) is gratefully acknowledged.

 

 

 

 

 

 

Entry n.