Investigating the Cloud Computing Business Framework (CCBF ...

Investigating the Cloud Computing
Business Framework (CCBF) -
Modelling and Benchmarking of
Financial Assets and job
submissions in Clouds
Victor Chang and Gary Wills, University of Southampton, UK.
David De Roure, University of Oxford and University of
Southampton, UK.
Clinton Chee, Commonwealth Bank of Australia, Sydney.
15 September 2010, Cardiff

Overview
• Literature reviews. Finance application
portability for this demo.
• Introduce CCBF - Financial Cloud Framework
(FCF) and Middleware Framework.
• Explain Monte Carlo Methods (MCM) and Black
Scholes Models (BSM).
• Codes and experiments used in different clouds.
• Discussions
• Conclusion with Q & A.

Technical and Business Challenges
Literature reviews, technical and business challenges are identified.
Technical:
• Vendors’ lock-in;
• Interoperability;
• Security;
Business:
• Little linkage between quantitative and qualitative cloud business
frameworks working in the same domain. Most are either quantitative
or qualitative.
• Not many structured frameworks to measure cloud business
performance. Some are in preliminary stage.
• Application portability from desktops to clouds, and later on between
clouds offered by different vendors, is challenging.
Why bother portability
• Need not rewrite API or recode/redesign software. Save $ & time.
• Recessions triggered by finance – they cannot longer just hold data
without sharing. Clouds offer a good platform for joint analysis.

Some issues related to Finance
• Global recessions triggered by Finance is an interdisciplinary
research challenge.
• Not many/few Universities are dealing with Financial cloud.
• Many financial modelling calculations are on desktops.
• Grid/HPC approaches: tend to deal with large scale calculations, &
are less flexible to deal with fast-paced finance challenges/issues.
• Finance applications use VBA, VB and Visual C++ etc, and need not
use HPC benchmark or HPC languages (other than C++), at least
not all the times.
• Some firms/banks just use Excel or desktop software. Despite there
are interests in clouds, they don’t know how to do, or have
impression it costs a lot of money/effort, or just outsource. Portability
for them is a business challenge.

Cloud Computing Business Framework
(CCBF): Our motivation and approaches
• CCBF: contains 4 frameworks. Use strategic/top-down
approaches to identify problems, and use bottom-up
methods to verify (experiments, modelling, simulations,
visualisation etc).
• CCBF includes Middleware Framework (MF) & Financial
Cloud Framework (FCF). MF deals with IaaS and PaaS
portability. FCF deals with SaaS portability issue.
• This paper focuses more on FCF, and presents existing
problems in Finance; and our proposal, analysis,
experimental results, discussions and recommendation.

Monte Carlo Methods (MCM) Part 1
• MCM, Capital Asset Models and Binomial Model etc are studied. Most
commonly used method for finance is MCM, that’s why it’s chosen. We use
MCM for pricing calculation.
• MATLAB is used due to its ease of use with relatively good speed. While the
volatility is known and provided, prices for buy and sale can be calculated.
• The following code demonstrates calculation of prices. Call prices are for buy
and put prices are for sale.
> fareastmc
[LowerLimit MCPrice UpperLimit]
Call Prices: [4.196694 4.248468 4.300242]
Put Prices: [7.610519 7.666090 7.721662]
• MCM application is in the form of a VBA Excel program to calculate the best
call and put prices. For example, Spot Price = 100; Strike Price = 105;
Volatility = 0.1; Risk free rate = 0.05, Option Maturity = 1; Time steps = 10 and
Number of simulations are 10000. The VBA Excel program will calculate the
best call price as 4.009, and best put price as 3.903.

Monte Carlo Methods (MCM) Part 2
Key advantages:
•A large number of simulations can be calculated in one go; eg 100,000.
•MCM have been widely used and proven in many cases. Calculations are close
to reality if key data such as volatility, risk free rate etc are known.
•Speed, accuracy and portability can be demonstrated. See core part of a code.
• MCM are used in Operational Risk and models are used to simulate the
operational risks in Commonwealth Bank, Australia (CBA).
• MCM simulations are written in Fortran and C#. Such simulations may
take several hours or over a day. Results are useful for banks.
• For our work, we use Variance-Gamma (VG) Processes (a specific
technique in MCM) to be used for experiments and benchmark in the clouds.
• VG processes are suitable in reducing errors apart from fast calculations.
Details for VG processes and its experimental results in Public and Private
Clouds are in slide 8-10.

Black Scholes Model (BSM)
• Methods such as Fourier series, stochastic volatility &BSM are used
for volatility. As a main stream option, BSM is selected for risk
analysis.
• BSM has finite difference equations to approximate derivatives. We
write MATLAB code to calculate call price and risk analysis based
on BSM, and contain key values such as
• strike price: the price targeted for sale.
• upper boundary: the highest possible range a price or risk can
reach.
• risk free rate: interest investors would expect from an absolutely
risk-free investment over a period of time.
• maturity: the loan is due to be repaid on a fixed date.
• volatility: used to quantify the risk of assets.
• dividend yield: the return on investment for an asset.
• asset steps: a specific BSM method called explicit time steps. The
more steps, the more accurate the analysis.
• This allows us to calculate and track call prices if variations for
maturity, risk free rate and volatility change. Easy to track volatility
for risk analysis if other variables are changed.

Experiments in Clouds Part 1
• 1 Desktop, 1 Public Cloud (Amazon) and 2 Private Clouds (hardware spec –
refer to our paper) are used for portability – run the same program, run
simulation/calculation and record down time taken. Pictures of private
clouds. We are interested in SaaS (finance application) running on private
clouds.

Experiments in Clouds Part 2
• VG Processes (a technique in MCM) is used.
• MATLAB 2007 and Octave 3.2.4 are used to run 5,000, 10,000 and
15,000 simulations on Clouds. Timing is important to run a large No
of simulations!
• MATLAB – runs nearly 5 times faster than Octave, but more
expensive and difficult to set up. Table below summarises the timing
benchmark result while running the modelling of assets (MoA) code.
Number of simulations and time
taken (sec)
5,000 10,000 15,000
Desktop 11.08 11.92 12.71
Public cloud (large instance) 11.95 12.30 13.15
Private cloud (virtual server)
Private cloud (rack server)
11.31 12.13 12.90
9.63 10.51 11.48

Experiments in Clouds Part 3
time taken (sec)
3.5
3
2.5
2
1.5
1
0.5
0
1 2 3
Desktop
Private Cloud (virtual
server)
Private cloud (rack
server)
• This Figure shows the time taken
for 5,000, 10,000 and 15,000
simulations with MATLAB 2007
on desktop and 2 private
clouds. Public cloud is not
available at the time for testing.
Private cloud (rack server) needs
the least amount of time.
MCM simulations (1 unit = 5,000 simulations)
time taken (sec)
6
5
4
3
2
1
0
1 2 3
No of steps taken (1 unit = 500 steps)
Desktop
Public cloud (large
instance(
Private cloud (virtual
server)
Private cloud (rack
server)
• This Figure shows the time taken
for running 500, 1,000 and 1,500
steps in BSM application on 4
different clouds and 1 desktop.
Time series used in BSM can take
accommodate up to 1,500
simulations. Private cloud (rack
server) has the best hardware
configuration with the fastest
network speed & significantly high
bandwidth, so it runs the fastest.

Middleware Framework – GridSAM 2.3
• GridSAM is widely used in the UK community and is very easy to modify the
Job Submission Description Language (JSDL) for job submission. The
GridSAM 2.3 contains bespoke application that allows multiple submissions for
around 20,000 jobs submitted at each instance.
• A Java program, Primes, is written to list prime numbers, and is able to submit
jobs to Private and Public Clouds. For example: Two JSDL files, primes-
0to10000.jsdl and prime-10001to20000.jsdl are written to send 20,000 jobs,
and a primes_file.pl is modified to lists prime numbers between 0 and 20,000.
7.5
7
6.5
Time taken (sec)
6
5.5
5
Public cloud
Private cloud
(virtual server)
Private cloud
(rack server)
• Job submission and its
status check is used to
record time taken.
4.5
4
1 2 3 4
No of jobs submitted (1 unit =5,000 jobs)

Three implications for Banking
• Three implications: Security; Financial Regulations and
Portability.
• Security: Evolving challenges in location of clouds and data privacy.
Mechanisms such as X509 vs. single sign-on are discussed.
• Regulations: Tighter risk management controls. Cloud computation
and resources help financial institutions in running more analytical
simulations to calculate risks to the client organisations.
• Portability: letting clients to install their own libraries. Users who run
MATLAB only need to install the MATLAB Runtime to run MATLAB
executable on Clouds. For financial simulations written in Fortran or
C++, users may need Math libraries to be installed in the Clouds.
• Clouds must facilitate an easy way to install and configure user
required libraries, without the need to write additional APIs like several
practices do.

Conclusion and Future Work
• MCM, BSM and GridSAM are used to demonstrate how
portability, speed, accuracy and reliability can be achieved
while moving financial applications from desktops to clouds.
This well fits-in an objective in the CCBF to allow portability
on top of, secure, fast, accurate and reliable clouds for IaaS,
PaaS and SaaS.
• Our research is not intended to test pure computing
performance of Cloud Computing. The intention is to port and
test financial applications to run on the Cloud. It is not yet
critical to use Dongarra's netlib functions for benchmark, but
there are plans to use HPC languages such as (Visual) C++
& test on 6-core processing private clouds for next stage.
• We have Health Cloud Storage Framework (HCSF) that can
demonstrate portability in details. We hope to strengthen our
results and extents of collaboration (such as financial services
and non-UK governments).

An example in Private Clod: 6-core & 4 terabytes
• Upgradable to 16 GB DDR3, 8-12 TB per server. Cost effective with high
performance capabilities.
• Better performances in MCM and BSM financial applications.

Collaboration and Questions
Other collaborators: 2 anonymous government department
branches, 2 anonymous investment banks and 3
anonymous small/medium enterprises.
Thank you!

Appendix: An example in Monte Carlo Methods (MCM)
%%%%% Input parameters
%%%%%%%%
S=100; %spot price
K=105; %strike
T=1; %maturity
r=0.05; %interest rate
sigma=0.25; %volatility
NSimulations=100000; %no of
monte carlo simulations
NSteps=100; %no of time steps
%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%
dt=T/(NSteps-1);
vsqrdt=sigma*dt^0.5;
drift=(r-(sigma^2)/2)*dt;
x=randn(NSimulations,NSteps);
Smat=zeros(NSimulations,NStep
s);
Smat(:,1)=S;
for i=2:NSteps,
Smat(:,i)=Smat(:,i-
1).*exp(drift+vsqrdt*x(:,i));
end
%************* calculate call price ***********
callpayoffvec=max(AverageSVec-K,0);
mccallprice=exp(-r*T)*mean(callpayoffvec);
std_dev_call=(var(callpayoffvec))^0.5;
%calculate bounds of expected value assuming 95%
confidence level
mclimit_call=1.96*std_dev_call/NSimulations^0.5;
call_lowerlimit=mccallprice-mclimit_call;
call_upperlimit=mccallprice+mclimit_call;
printf("Call Prices : [%f %f
%f]\n",call_lowerlimit,mccallprice,call_upperlimit);
%************* calculate put price ***********
putpayoffvec=max(K-AverageSVec,0);
mcputprice=exp(-r*T)*mean(putpayoffvec);
std_dev_put=(var(putpayoffvec))^0.5;
%calculate bounds of expected value assuming 95%
confidence level
mclimit_put=1.96*std_dev_put/NSimulations^0.5;
put_lowerlimit=mcputprice-mclimit_put;
put_upperlimit=mcputprice+mclimit_put;
printf("Put Prices : [%f %f
%f]\n",put_lowerlimit,mcputprice,put_upperlimit);

Appendix: An example in Black Scholes Model (BSM)
%----------- Enter input Parameters -----------------------
S=100; %Spot price
K=100; %Strike
UB=115; %upper boundary
r=0.15; %risk free rate
T=.5; %maturity
sigma=0.2; %volatility
D=0.05; %dividend yield
assetsteps=150; %Explicit scheme time steps
%----------------------------------------------------
dt=1/(sigma*assetsteps)^2;
timesteps=ceil(T/dt)+1;
Su=UB;
ds=Su/assetsteps;
dt=T/timesteps;
for k=1:timesteps,
V(2:assetsteps,k+1)=Ai.*V(1:assetsteps-
1,k)+(1+Bi).*V(2:assetsteps,k)+Ci.*V(3:assetsteps
+1,k);
%Apply lower boundary condition
V(1,k+1)=0;
%apply upper boundary condition
V(assetsteps+1,k+1)=0;
end
V2=fliplr(V);
OptionPriceVec=V2(:,1);
option_price=interp1(Svec,OptionPriceVec,S)
V=zeros(assetsteps+1,timesteps+1);
Svec=0:ds:Su;
Svec=Svec';
V(:,1)=max((Svec-K).*(Svec