Towards Domain Model Optimized Deployment

and Execution of Scientiﬁc Applications

in Cloud Environments

Fabian Glaser

Institute of Computer Science, University of G¨ottingen,

Goldschmidtstraße 7, 37077 G¨ottingen, Germany

Existing solutions for automatic scaling of applica-

tions in the cloud focus on the requirements of web

services. A number of application servers is de-

ployed, a load balancer is utilized to distribute the

requests to these application servers, and new ap-

plication servers are launched and conﬁgured when

the requests exceed a certain capacity. However, the

requirements for scaling scientiﬁc applications in a

cloud are different. Often, these applications are used

by a single scientist and the computational load is de-

ﬁned by the complexity of the model to be computed

rather than by the number of users. In this paper, we

present an alternative approach to scale scientiﬁc ap-

plications in the cloud. Hereby, the deployment scal-

ing is driven by a domain model deﬁned by the scien-

tist.

1 RESEARCH PROBLEM

Todays scientiﬁc research and simulations largely

depend on computing resources. While grid com-

puting offered the possibility to share and combine

large computing resources already in the past, cloud

computing offers more ﬂexibility and automatic scal-

ing features when deploying distributed applications.

Large-scale internationalprojects, e.g., Helix Nebula

and the EGI Federated Cloud

exist, that leverage the

usage of inter-connected clouds for the scientiﬁc com-

munity. While cloud computing has penetrated many

business domains, the adoption in the scientiﬁc com-

munity has not been that enthusiastic. Bunch at al.

(Bunch et al., 2012) identify three major reasons for

this observation:

1. Cloud systems are diverse and code written for

one cloud platform can not easily be ported to an-

other platform (“vendor lock-in”).

Helix Nebula: http://www.helix-nebula.eu

EGI Federated Cloud: https://www.egi.eu/

infrastructure/cloud/

2. Current cloud systems are designed for the execu-

tion of applications from the web service domain.

3. Using cloud computing requires user expertise,

rendering it inaccessible for non-computer scien-

tists.

The ﬁrst issue has been addressed recently, by

introducing techniques known from Model-Driven

Development (MDD) to the design of cloud appli-

cations (see e.g. MODAClouds (Ardagna et al.,

2012)) and also by the proliferation of standards

like the Topology Orchestration and Speciﬁcation

for Cloud Applications (TOSCA) (OASIS, 2013) for

Cloud Orchestration and the Open Cloud Computing

Interface (OCCI) (Nyren et al., 2011). The two later

points remain as open issues. To address these issues,

we introduce a framework that uses information from

the domain of the scientist to appropriately scale

scientiﬁc applications in cloud environments. By

leveraging the information encoded in the problem

deﬁnition to scale the infrastructure, we enable

scientists to focus on their domain rather than being

distracted by complicated cloud internals.

The remainder of this paper is structured as fol-

lows. Section 2 summarizes the research objectives

of this project. Section 3 introduces three applications

from different scientiﬁc domains that motivate our

research, while Section 4 summarizes the current

state of the art in modeling and deploying (scientiﬁc)

applications in cloud environments. In Section 5,

we discuss the requirements and restrictions that

are deﬁned by our motivating applications on cloud

deployments and in Section 6, we introduce a frame-

work that aims to provide a foundation to solve the

research questions deﬁned in Section 2. We comment

on drawbacks of the suggested solution in Section 7.

Section 8 deﬁnes the expected outcome and ﬁnally

in Section 9, we summarize the current state of our

research.

Glaser F..

Towards Domain Model Optimized Deployment and Execution of Scientiﬁc Applications in Cloud Environments.

 2015 SCITEPRESS (Science and Technology Publications, Lda.)

2 OUTLINE OF OBJECTIVES

To be able to fully leverage the beneﬁts of cloud com-

puting in science, we identify the following research

questions:

RQ1: How can we shield the individual scientist

who is willing to deploy his application in a cloud

from complicated cloud internals?

RQ2: Which parameters from the domain model

of the scientist have an inﬂuence on the required

scale of the cloud infrastructure?

RQ3: How can these parameters be utilized to scale

the cloud infrastructure conveniently?

To answer these questions, we propose a framework

that uses models to deploy applications in cloud en-

vironments and utilizes information from the domain

of the scientist to appropriately scale the deployed in-

frastructure.

3 MOTIVATING EXAMPLE

APPLICATIONS

In the scope of our project, we target three different

scientiﬁc application that are candidates for being ex-

ecuted in a cloud environment. These applications

utilize different software stacks, which will be intro-

duced in the following.

3.1 Monte-Carlo Simulation and Data

Analysis in High Energy Physics

Experimental particle collision data collected by the

experiments at the Large Hadron Collider (LHC)

CERN is produced at a data rate of ∼15 PB/year. To

establish a ground truth, particle collisions data in

the same order of magnitude is generated with help

of Monte-Carlo methods according to the standard

model and its variations. Currently, this data is stored

and analyzed with the help of a multi-tiered grid

which spawns the whole globe. However, due to the

update of the LHC in 2013, the data rate will increase

dramatically. Hence, the high energy physics commu-

nity is searching for new computing models and ex-

tending the resources with cloud resources is a viable

option. Production of Monte-Carlo data by simulation

and also analysis of data can be easily parallelized

The Large Hadron Collider: http://home.web.cern.ch/

topics/large-hadron-collider

The Wordwide LHC Computing Grid: http://wlcg.web.

cern.ch/

since each simulated event (a particle beam cross-

ing) can be simulated and analyzed independently.

Cloud computing is a valuable solution for scientist

conducting analysis on smaller ﬁltered datasets (up

to a few TB in size). The parallel ROOT facility

(PROOF) (Ganis et al., 2008) is a commonly used

tool for conducting the analysis on computing clus-

ters built from commodity hardware. It is both par-

allelized (using multiple threads on multiple kernels)

and distributed (master/worker architecture).

3.2 Modeling and Optimization of

Public Transport Networks

LinTim

is a software framework, developed by

the optimization working group at the University of

G¨ottingen. It aims to support the different planning

stages in public transport networks. Hereby, planning

and optimization of the networks is broken up into

ﬁve stages which are network design, line planning,

timetabling, vehicle scheduling, and delay manage-

ment. Each stage involves modeling the problem as

an optimization problem which is then either solved

by a heuristic or by third-party solvers. LinTim sup-

ports the solvers Xpress

, Gurobi

, and Cplex

. It is

used to steer the execution of the solving steps and

feeding the output data from one step into the other.

LinTim itself is implemented to run on a single-core

machine. The external mathematical solvers are op-

timized for multi-core machines. The runtime of a

solving step is largely inﬂuenced by the complexity

of the optimization problem.

3.3 Material Science

OpenFOAM

is a software toolbox, which was pri-

marily created for numerically solving systems of par-

tial differential equations (PDEs) of continuum me-

chanics problems on a predeﬁned geometry and do-

main. Its inter-process communication is based on

Open MPI

. Thereby, solving the system of PDEs,

typically involves the following steps: deﬁnition of

the PDEs, deﬁnition of the geometry of the domain,

deﬁnition of a mesh that covers that domain and de-

composition of the domain for parallel computation.

Different solvers can be utilized to then numerically

LinTim: http://lintim.math.uni-goettingen.de

FICO Express Optimization: http://www.ﬁco.com/en/

products/ﬁco-xpress-optimization-suite

Gurobi: http://www.gurobi.com/

Cplex: http://www-01.ibm.com/software/commerce/

optimization/cplex-optimizer/

OpenFOAM: http://www.openfoam.org/

OpenMPI: http://www.open-mpi.org/

TowardsDomainModelOptimizedDeploymentandExecutionofScientificApplicationsinCloudEnvironments

solve the PDEs, including ﬁnite volume methods and

ﬁnite elements methods.

4 STATE OF THE ART

In the following, we shortly sketch the state of the art

in modeling, deployment, conﬁguration management,

and automatic scaling of cloud applications.

4.1 Cloud Application Modeling

MODAClouds (Ardagna et al., 2012) targets cloud-

provider independent development of cloud applica-

tions. Thereby, it supports the design, implemen-

tation and deployment of software with a cloud-

provider independent modeling approach. The ap-

plication model undergoes different modeling reﬁne-

ment steps, starting with a Cloud-Enabled Computa-

tion Independent Model (CIM), which identiﬁes the

basic components of a system, to a Cloud-Provider

Independent Model (CPIM), which incorporates gen-

eral cloud concepts like elements from Software-as-

a-Service (SaaS), Platform-as-a-Service (PaaS), and

Infrastructure-as-a-Service (IaaS) and ﬁnalizing with

the Cloud-Provider Speciﬁc Model (CPSM), which

includes the information on how to deploy the appli-

cation on a speciﬁc cloud.

4.2 Automated Scaling in the Cloud

In general, there is a differentiation between vertical

scaling, i.e., the resizing of virtual machines or con-

tainers and horizontal scaling, i.e., the multiplication

of virtual machines or containers (compare, e.g., (Ra-

jan et al., 2013)). Horizontal scaling of web-services

is commonly implemented with the help of a load bal-

ancer, which distributes the load on the existing appli-

cation servers. If an application needs to be scaled, is

triggered by so called user-deﬁned rules, which de-

ﬁne actions, e.g., the launch of an additional applica-

tion server in case a certain condition is met, e.g., the

number of user requests exceeds a certain threshold.

4.3 Cloud Deployments and Cloud

Orchestration

Cloud orchestration frameworks, such as Ama-

zon CloudFormation

, OpenStack Heat

, and

Amazon CloudFormation http://aws.amazon.com/

cloudformation/

OpenStack Heat: https://wiki.openstack.org/wiki/

Cloudify

utilize reusable templates that model the

infrastructure and the component structure required

by a cloud application and enable their orchestrated

and reproducible launch. TOSCA (OASIS, 2013)

aims to provide a standardized template format for

orchestration. Cloudify is set to fully adopt the

standard in future versions and there are ongoing

implementation efforts to build a translator to convert

TOSCA to the Heat Orchestration Template (HOT)

format. Scalability is supported by deﬁning policies

that trigger a user-deﬁned action, when a certain

condition is met. Cloudinit.d (Bresnahan et al.,

2011) is a tool to support the orchestrated launch,

conﬁguration and monitoring of services in an IaaS

cloud. Thereby, it differentiates between different

run-levels of the required services, where the levels

deﬁne the dependencies of services to each other:

services on the same run-level have no dependencies,

while there might be dependencies between services

running in different run-levels. The deployment

and conﬁguration of the Virtual Machines (VMs)

is steered by three user deﬁned scripts, which is

submitted to the VMs at launch time: The startup

script, which is run at start-up to install the necessary

software packages and the required conﬁguration,

the test script, which is used to test the system after

conﬁguration and the termination script, which runs,

when a service is shut down. In the startup script

the user is free to also use Conﬁguration Manage-

ment tools like Puppet

, Chef

or Ansible

(see

Section 4.4). To offer scientiﬁc software frameworks

in the cloud, Bunch et al. (Bunch et al., 2012)

introduce a domain-speciﬁc language called Neptune.

In contrast to Cloudinit.d, Neptune is specialized

to steer the deployment of speciﬁc software frame-

works on top of the PaaS framework AppScale

Thereby, it supports the utilization of different

High Performance Computing (HPC) software

packets for distributed computation that are often

used in science, including MPI, X10 and MapReduce.

4.4 Conﬁguration Management

While conﬁguration management tools like Puppet,

Chef, and Ansible are not cloud deployment speciﬁc,

they are often used to manage large scale deploy-

ments on cloud platforms. For this purpose, they

use declarative text-based languages to deﬁne the de-

Cloudify: http://getcloudify.org/

Puppet: http://puppetlabs.com/

Chef: https://www.chef.io/chef/

Ansible: http://www.ansible.com/home

AppScale: http://www.appscale.com

CLOSER2015-DoctoralConsortium

sired conﬁguration of a (distributed) set of physical

or virtual hosts. This includes, but is not limited to

installed software, permissions, and network conﬁg-

urations. These descriptions are then used to auto-

matically enforce and keep the hosts in the desired

state. Hereby operating-system speciﬁc details, like

the utilized packet manager are transparent to the user.

Wettinger et al. (Wettinger et al., 2013) deﬁne dif-

ferent approaches to integrate Conﬁguration Manage-

ment with Cloud Orchestration.

5 DISCUSSION

While the applications represent heterogeneous ap-

proaches from different scientiﬁc domains, they share

common key characteristics, which are given below:

C1. A ﬁxed set of existing frameworks is used to

evaluate or execute input models from the distinct

scientiﬁc domain.

C2. These frameworks are highly specialized and en-

code a high amount of domain knowledge.

C3. The frameworks are not built for being executed

on a scalable computing infrastructure.

C4. The utilized frameworks are responsible for dis-

tributing the computational load.

C5. The computationalload to be handled largely de-

pends on the input model provided to the frame-

work.

When moving scientiﬁc applications to cloud envi-

ronments, these characteristics have to be taken into

account. While cloud computing offers great ﬂexibil-

ity, when creating computing infrastructures, it poses

the question on how these infrastructures need to be

scaled to ﬁt the computational demand. The charac-

teristics of the frameworks described above restrict

the solution space for this problem: C1 deﬁnes the

software conﬁguration of the cloud infrastructure, C2

renders it often impossible to switch to a framework

which is optimized for being executed in a cloud en-

vironment, C3 does not allow the cloud environment

to scale driven by the framework, and C4 restricts

the infrastructure deployment to a certain architec-

ture. While C1-C4 enforce a certain structure on the

deployed compute infrastructure, C5 deﬁnes the com-

putational load on this infrastructure and so it should

present a main source for deﬁning its scale. In addi-

tion to the requirements introduced by the character-

istics deﬁned above, another set of requirements is de-

ﬁned by the scientist. This might include limitations

on the overall runtime in case a certain deadline needs

to be met or a certain number of backups of the out-

put data needed to be kept for reliability. Given the

Scientist (S3)

IaaS Cloud

Concrete Deployment Model

Scientific Computation Framework (S2)

Monitor

Domain Model (S1)

executed on

modeled by

deployed on

Evaluator

Abstract Deployment Model

Instantiation

evaluated by

develops

defines parameters for

monitored by

defines parameters for

monitored by

existing new contributions

Figure 1: A framework for adapting scientiﬁc application

deployments according to domain model demands.

characteristics above, we hence identify three main

sources that deﬁne the requirements on an optimal de-

ployment selection:

S1. the domain model to be computed,

S2. the scientiﬁc computation framework, which is

utilized,

S3. the scientist.

A framework for automatic scalability of scientiﬁc

cloud applications needs to be able to leverage re-

quirements from all three sources. In the next section,

we will introduce a framework that allows to deploy

and scale the application according to these observa-

tions.

6 METHODOLOGY

Figure 1 depicts the overall framework which is used

to address the research questions deﬁned in Section 2.

To leverage the full ﬂexibility of cloud computing, the

framework builds on IaaS. The components shaded

in grey are already existing and the research in this

project is focused on the white components.

In the following, we discuss the different components

and their interaction. Thereby, we exemplify the steps

with help of the example application from material

science deﬁned in Section 3.3.

6.1 Domain Models

Domain models appear in very different formats. Of-

ten only a limited set of parameters deﬁned in the do-

main model have an impact on the computational de-

TowardsDomainModelOptimizedDeploymentandExecutionofScientificApplicationsinCloudEnvironments

mand e.g., the selection of a certain solving strategy

might require a certain amount of RAM in the infras-

tructure.

In OpenFOAM the domain model is deﬁned with the

help of a dictionary ﬁle that deﬁnes the geometry, a

ﬁle that deﬁnes the boundary and initial conditions of

the system of PDEs, and a properties ﬁle that deﬁnes

the physical properties such as the system of PDEs to

be solved. An additional ﬁle is used to decompose

the domain into subdomains for parallel execution.

The number of subdomains thereby should match the

number of processors available in the infrastructure.

While in traditional compute infrastructures, this is

determined by the number of available cores, in cloud

environmentsit should be deﬁned according to the do-

main model.

6.2 Scientiﬁc Computation Frameworks

In our example, OpenFOAM represents the scientiﬁc

computation framework (SCF). The SCF is the most

restrictive component for the cloud deployment. It

encodes how the computational load is distributed on

the underlying infrastructure. As described in Sec-

tion 3, OpenFOAM is parallelized using Open MPI,

hence it requires an MPI cluster to run and distribute

the computational load.

6.3 Abstract/Concrete Deployment

Model

The deployment of the SCF is modeled with help

of standardized modeling languages. Using models

for describing a cloud application has the advantage

that the description of the application deployment be-

comes cloud-provider agnostic and hence avoids ven-

dor lock-in. It enhances comprehensibility by in-

creased abstraction, and it fosters re-usability, since

a cloud-provider agnostic model can be (semi-) au-

tomatically transformed to suit the requirements of

a certain cloud-provider. By using models, we ad-

dress RQ1.

The aforementioned TOSCA standard allows to de-

ﬁne input parameters for application models. These

parameters can include the virtual machine type to use

or the number of instances of a certain type to launch.

We call a model with unset parameters abstract and

a model with instantiated parameters concrete. The

transformation from an abstract model into a concrete

model is called instantiation. For each domain model

it must be evaluated which domain model parameters

have an inﬂuence on the performance in the cloud,

and these parameters then need to be mapped to and

reﬂected by the input parameters of the abstract de-

ployment model.

The optimal setting for the parameters needed for the

instantiation is determined by three sources: the sci-

entist, an evaluator and a monitor.

6.4 Evaluator/Monitor

To ﬁnd suitable parameters settings for the require-

ments of a speciﬁc domain model, different strategies

are possible. Hereby, we distinguish between static

evaluation, whereby the applications is not executed

in the cloud, and dynamic evaluation, whereby the ap-

plications are executed and monitored. Static evalua-

tions are implemented with help of a domain speciﬁc

model evaluator. This evaluator transforms values of

parameters of interest of the domain model into suit-

able settings of parameters for the concrete deploy-

ment model. The evaluator is domain speciﬁc and the

parameters of interest in the domain model need to be

carefully selected (RQ2). Static evaluations are done

before the application is deployed on the cloud infras-

tructure. The concept of the evaluator addresses RQ3.

Dynamic evaluations can be done by manual obser-

vation of the application execution in the cloud, or

automatically with help of a monitor. According to

the outcome of the deployment evaluation, the pa-

rameters that have been used for the initial deploy-

ment are readjusted and a new instantiation of the

abstract deployment model is initiated. Hereby, ei-

ther a new concrete deployment model is created and

deployed or the existing concrete deployment model

is readjusted. The second approach is similar to the

Models@Runtime approach, suggested by Ferry et al.

(Ferry et al., 2014).

6.5 Deployment

The deployments of the applications are fully auto-

mated to avoid manual interaction with the cloud and

enable transparent application deployment for the sci-

entist. A cloud orchestration framework is used for

the orchestrated launch of the infrastructure and a

conﬁguration management tool is utilized to automat-

ically conﬁgure the launched infrastructure.

7 LIMITATIONS OF OUR

APPROACH

While the proposed framework offers the methodol-

ogy to adapt application deployments to the needs of a

speciﬁc domain model, it has one limitation: Domain

models have very heterogeneous formats and the re-

lation between a domain model and the deployment

CLOSER2015-DoctoralConsortium

model has to be deﬁned manually for each scientiﬁc

computation framework to enable automatic scaling.

Hence a domain speciﬁc evaluator needs to be imple-

mented for each domain. Once this mapping is done,

our frameworkenables the scientist to focus on the de-

velopment of the domain model for his problem def-

inition and is freed from deploying the applications

accordingly.

8 EXPECTED OUTCOME

We expect the following outcome of this research

project:

• Contributions to the state of the art in modeling of

scientiﬁc applications for the cloud,

• a novel method to leverage domain model infor-

mation of the scientist to scale scientiﬁc applica-

tions in the cloud,

• a prototypical implementation of the proposed

framework to demonstrate its feasibility.

9 STATE OF THE RESEARCH

In this paper, we proposed a framework for automat-

ically scaling scientiﬁc applications in a cloud. We

argue, that the traditional way of scaling applications

in cloud environments does not suit the frameworks

for scientiﬁc computation, since it does not take the

scientiﬁc domain into account. By evaluating the do-

main models deﬁned by the scientist and mapping cer-

tain key characteristics of this model to the deploy-

ment model, we are able to shield the scientist from

complex cloud internals.

In the ﬁrst phase of this project, we were setting up an

infrastructure, to supportthe differentsteps deﬁned by

our framework. We deployed the example application

deﬁned in Section 3 in a prototypical IaaS cloud based

on OpenStack

. A modiﬁed version of Cloudify was

used for the orchestrated deployment of the applica-

tions, whereby the application models are based on

Cloudify’s current support for TOSCA. The conﬁgu-

ration of the cloud applications was automated with

help of the conﬁguration management tool Ansible.

Unfortunately, it became clear that current implemen-

tations of the TOSCA language are very limited when

it comes to deﬁning and launching scalable compo-

nents. If TOSCA is able to properly support the scala-

bility demands, deﬁned in our framework is currently

under evaluation.

OpenStack: https://www.openstack.org/

ACKNOWLEDGEMENTS

I would like to thank my supervisor Jens Grabowski

for his support and fruitful comments. This work

is partially funded by the Joint Centre of Simulation

Technology (SWZ) of the Universityof G¨ottingen and

the Technical University of Clausthal (project 11.4.1).

REFERENCES

Ardagna, D., Di Nitto, E., Mohagheghi, P., Mosser, S.,

Ballagny, C., D’Andria, F., Casale, G., Matthews, P.,

Nechifor, C.-S., Petcu, D., et al. (2012). Modaclouds:

A model-driven approach for the design and execution

of applications on multiple clouds. In Modeling in

Software Engineering (MISE), 2012 ICSE Workshop

on, pages 50–56. IEEE.

Bresnahan, J., Freeman, T., LaBissoniere, D., and Keahey,

K. (2011). Managing appliance launches in infrastruc-

ture clouds. In Proceedings of the 2011 TeraGrid Con-

ference: Extreme Digital Discovery, page 12. ACM.

Bunch, C., Drawert, B., Chohan, N., Krintz, C., Petzold, L.,

and Shams, K. (2012). Language and runtime support

for automatic conﬁguration and deployment of scien-

tiﬁc computing software over cloud fabrics. Journal

of Grid Computing, 10(1):23–46.

Ferry, N., Brataas, G., Rossini, A., Chauvel, F., and Solberg,

A. (2014). Towards Bridging the Gap Between Scala-

bility and Elasticity. In Proceedings of the 4th Interna-

tional Conference on Cloud Computing and Services

Science, pages 746–751.

Ganis, G., Iwaszkiewicz, J., and Rademakers, F. (2008).

Data Analysis with PROOF. In Proceedings of XII

International Workshop on Advanced Computing and

Analysis Techniques in Physics Research, number

PoS(ACAT08)007 in Proceedings of Science (PoS).

Nyren, R., Edmonds, A., Papaspyrou, A., and Metsch,

T. (2011). Open Cloud Computing Interface -

Core. [Available online: http://ogf.org/documents/

GDF.183.pdf].

OASIS (2013). Topology and Orchestration Speciﬁcation

for Cloud Applications (TOSCA) 1.0. [Available

online; http://docs.oasis-open.org/tosca/TOSCA/v1.0/

os/TOSCA-v1.0-os.html fetched on 03/12/2015].

Rajan, D., Thrasher, A., Abdul-Wahid, B., Izaguirre, J. A.,

Emrich, S. J., and Thain, D. (2013). Case Studies

in Designing Elastic Applications. In Cluster, Cloud

and Grid Computing (CCGrid), 2013 13th IEEE/ACM

International Symposium on, pages 466–473. IEEE

Computer Society.

Wettinger, J., Behrendt, M., Binz, T., Breitenb¨ucher, U.,

Breiter, G., Leymann, F., Moser, S., Schwertle, I.,

Spatzier, T., et al. (2013). Integrating Conﬁguration

Management with Model-driven Cloud Management

based on TOSCA. In Proceedings of the 3rd Interna-

tional Conference on Cloud Computing and Services

Science, pages 437–446.

TowardsDomainModelOptimizedDeploymentandExecutionofScientificApplicationsinCloudEnvironments