Applying Architectural Templates for Design-Time Scalability and Elasticity Analyses of SaaS Applications Download file

Software architects plan, model, and analyze architectures of large software like Software-as-a-Service (SaaS) applications. The scalability and elasticity of these applications is crucially impacted by architects' early decision for an architectural style. However, whether this decision fostered scalability and elasticity can currently only be tested with the final application deployed in the target cloud computing environment. This process leads to the high risk of unsatisfying scalability/elasticity and expensive re-implementations.
To tackle this problem, we propose an early design-time scalability/elasticity analysis using architectural templates (ATs). ATs are a language to formalize architectural styles on component models for the purpose of model-driven quality analyses. This work-in-progress paper provides a first formalization of ATs and investigates their applicability to analyze the scalability and elasticity of SaaS applications at design-time by using a 3-tier example scenario. Our results indicate that ATs are applicable to such 3-tier scenarios.

Author: Sebastian Lehrig

We presented this paper at the International Workshop on Hot Topics in Cloud service Scalability (HotTopiCS 2014).

Architectural Templates: Engineering Scalable SaaS Applications Based on Architectural Styles Download file

Software architects plan, model, and analyze the high-level design of software systems. Today, these systems are often deployed in cloud computing environments as Software-as-a-Service (SaaS) applications. The scalability of these applications is crucially impacted by architects' early design decisions. Architects decide based on their experience and known architectural styles like a 3-tier architecture. In new application domains, however, architects lack the experience to determine whether their designs will result in scalable implementations. This lack leads to the high risk of unsatisfying scalability and expensive re-implementations.

Authors: Sebastian Lehrig

We presented this paper at the International Conference on Model Driven Engineering Languages and Systems in Miami, USA, September 29 – October 4.

Automatic Detection of Performance Anti-patterns in Inter-component Communications Download file

Performance problems such as high response times in soft- ware applications have a significant effect on the customer’s satisfaction. In enterprise applications, performance problems are frequently manifested in inefficient or unnecessary communication patterns between software components originating from poor architectural design or implementation. Due to high manual effort, thorough performance analysis is often neglected, in practice. In order to overcome this problem, automated engineering approaches are required for the detection of performance problems. In this paper, we introduce several heuristics for measurement-based detection of well-known performance anti-patterns in inter-component communications. The detection heuristics comprise load and instrumentation descriptions for performance tests as well as corresponding detection rules. We integrate these heuristics with Dynamic Spotter, a framework for detection of performance problems, which automatically executes the detection heuristics by systematically conducting experiments. We evaluate our heuristics on four evaluation scenarios based on an e-commerce benchmark (TPC-W) where the heuristics detect the expected communication performance anti- patterns and pinpoint their root causes.

Authors: Alexander Wert, Marius Oehler, Christoph Heger, Roozbeh Farahbod

CloudScale - Skalierbarkeit für die Cloud (German) Download file

Das EU-Projekt CloudScale möchte Unternehmen dabei helfen, Cloud Computing anstelle eigener Rechenanlagen für den Betrieb ihrer Software zu nutzen. Für Unternehmen stellt sich natürlich die Frage, ob sie Cloud Computing überhaupt benötigen. Der ausschlaggebende Faktor zur Beantwortung dieser Frage sind die mit Cloud Computing verbundenen Kosten und die Qualität der Software. Kann hochqualitative Software durch Cloud Computing kostengünstiger als mit der eigenen Rechenanlage betrieben werden, so wird Cloud Computing interessant für Unternehmen. CloudScale ermöglicht es Unternehmen nun, entstehende Kosten zu analysieren und ihre Software für Cloud Computing zu optimieren – noch bevor der Schritt in die Cloud gewagt wird.

(English abstract)
The EU project CloudScale is intended to support companies in using cloud computing instead of their own computers for operating their software. Companies will naturally ask themselves whether they need cloud computing at all. The decisive factor for answering this question depends on the costs arising for cloud computing and the quality of the software used. Companies will be interested in cloud computing if it enables the application of high-quality software at a lower cost than that using the company’s own IT system. CloudScale now makes it possible for companies to analyse any arising costs and to optimise their software for cloud computing – even before venturing into the cloud.

Authors: Sebastian Lehrig, Steffen Becker

We presented this paper at the ForschungsForum in Paderborn (2014)

CloudScale: Scalability Management for Cloud Systems View article

This work-in-progress paper introduces the EU FP7 STREP CloudScale. The contribution of this paper is an overall description of CloudScale’s engineering approach for the design and evolution of scalable cloud applications and services. An Electronic Health Record (EHR) system serves as a motivation scenario. The overall CloudScale method describes how CloudScale will identify and gradually solve scalability problems in this existing applications. CloudScale will also enable the modelling of design alternatives and the analysis of their effect on scalability and cost. Best practices for scalability will further guide the design process. The CloudScale method is supported by three integrated tools and a scalability description modelling language. CloudScale will be validated by two case studies.

Authors : Gunnar Brataas, Erlend Stav, Sebastian Lehrig, Steffen Becker, Goran Kopčak, Darko Huljenič

We presented this paper at International Conference on Performance Engineering in Prague, April 21-24.

Comparison of Request Admission Based Performance Isolation Approaches in Multi-Tenant SaaS Applications View article

In the Software-as-a-Service model one single application instance is usually shared between different tenants to decrease operational costs. However, sharing at this level may lead to undesired influence from one tenant onto the performance observed by the others. Intentionally, the application does not manage hardware resources and the responsible OS is not aware of application level entities like tenants. Consequently, it is difficult to control the performance of individual tenants to make sure they are isolated. In this paper we present an overview and classification of methods to ensure performance isolation based on request admission control. Further, informational requirements of these methods are discussed.

Authors: Rouven Krebs, Manuel Loesch

In Proceedings of 4th International Conference On Cloud Computing And Services Science (CLOSER 2014), Barcelona, Spain, April 3, 2014.

Does Your App Scale? Download file

Cloud computing offers us theoretically unlimited resources, but is your application able to use it? Many startups run into large problems as their applications are not able to scale with the increasing demand (see [1] on SeatWave for example). In the book "Founders at Work" [2], the founders of companies like PayPal and Hotmail report on the large efforts they had to undertake in order to make their application scalable with the growing user base. Building internet-scalable applications is hard and unfortunately just moving to the cloud doesn't change that.

Author : Roozbeh Farahbod

Heinz Nixdorf annual report 2012 (German) Download file

Cloud computing offers companies a promising approach for saving costs when running their software: they only have to pay for the amount of hardware that is required for operation. However, software needs to be optimised to run in the cloud in such a way that a minimum of hardware is needed. The aim of the EU FP7 STREP project CloudScale is, the refore, to aid software developers to engineer software that performs well in the cloud.

CloudScale on page 112-113.

Optimization Method for Request Admission Control to Guarantee Performance Isolation Download file

Software-as-a-Service (SaaS) often shares one single application instance among different tenants to reduce costs. However, sharing potentially leads to undesired influence from one tenant onto the performance observed by the others. Furthermore, providing one tenant additional resources to support its increasing demands without increasing the performance of tenants who do not pay for it is a major challenge. The application intentionally does not manage hardware resources, and the OS is not aware of application level entities like tenants. Thus, it is difficult to control the performance of different tenants to keep them isolated. These problems gain importance as performance is one of the major obstacles for cloud customers. Existing work applies request based admission control mechanisms like a weighted round robin with an individual queue for each tenant to control the share guaranteed for a tenant. However, the computation of the concrete weights for such an admission control is still challenging. In this paper, we present a fitness function and optimization approach reflecting various requirements from this field to compute proper weights with the goal to ensure an isolated performance as foundation to scale on a tenants basis.

Authors: Rouven Krebs, Philipp Schneider, Nikolas Herbst

We presented this paper at the International Workshop on Hot Topics in Cloud service Scalability (HotTopiCS 2014).

Platform-as-a-Service Architecture for Performance Isolated Multi-tenant Applications View article

Software-as-a-Service (SaaS) often shares one single application instance among different tenants to reduce costs. However, sharing potentially leads to undesired influence from one tenant onto the performance observed by the others. This is a significant problem as performance is one of the major obstacles for cloud customers. The application does intentionally not manage hardware resources, and the operating system is not aware of application level entities like tenants which makes the performance control a challenge. In case the SaaS is hosted on a Platform-as-a-Service (PaaS), the SaaS developer usually wants to control performance-related issues according to individual needs, and available information is even more limited. Thus, it is difficult to control the performance of different tenants to keep them isolated. Existing work focuses on concrete methods to provide performance isolation in systems where the whole stack is under control. In this paper we present a concrete PaaS enhancement which enables application developers to realize isolation methods for their hosted SaaS application. In a case study we evaluated the applicability and effectiveness of the enhancement in different environments.

Authors: Rouven Krebs, Manuel Loesch, Samuel Kounev

In Proceedings of the 7th IEEE International Conference on Cloud Computing (IEEE Cloud 2014), Anchorage, USA, July 2, 2014

Reengineering of Component-Based Software Systems in the Presence of Design Deficiencies – An Overview Download file

In reengineering, up-to-date architecture models are important artifacts to get an overview of a system and to plan and execute the necessary reengineering activities. If such models do not exist, software architecture reconstruction (SAR) techniques can be used to recover them from the system's source code. However, design deficiencies like Interface Violations can influence the architecture reconstruction and thereby adulterate the recovered architecture. This is currently not addressed by SAR approaches. Archimetrix is an iterative reengineering process that was developed in a PhD thesis at the University of Paderborn [5]. It aims at detecting and removing design deficiencies which influence the architecture reconstruction and thereby enable the recovery of more accurate architecture models.

Authors : Markus von Detten, Sebastian Lehrig

We presented this paper at the 15th Workshop Software-Reengineering in Bad Honnef, Germany, May 6-8, 2013.

Resource Usage Control In Multi-Tenant Applications View article

Multi-tenancy is an approach to share one application instance among multiple customers by providing each of them a dedicated view. This approach is commonly used by SaaS providers to reduce the costs for service provisioning. Tenants also expect to be isolated in terms of the performance they observe and the providers inability to offer performance guarantees is a major obstacle for potential cloud customers. To guarantee an isolated performance it is essential to control the resources used by a tenant. This is a challenge, because the layers of the execution environment, responsible for controlling resource usage (e.g., operating system), normally do not have knowledge about entities defined at the application level and thus they cannot distinguish between different tenants. Furthermore, it is hard to predict how tenant requests propagate through the multiple layers of the execution environment down to the physical resource layer. The intended abstraction of the application from the resource controlling layers does not allow to solely solving this problem in the application. In this paper, we propose an approach which applies resource demand estimation techniques in combination with a request based admission control. The resource demand estimation is used to determine resource consumption information for individual requests. The admission control mechanism uses this knowledge to delay requests originating from tenants that exceed their allocated resource share. The proposed method is validated by a widely accepted benchmark showing its applicability in a setup motivated by today’s platform environments.

Authors: Rouven Krebs, Simon Spinner, Nadia Ahmed, and Samuel Kounev

In Proceedings of the 14th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGrid 2014), Chicago, IL, USA, May 26, 2014. IEEE/ACM.

Systematically Deriving Quality Metrics for Cloud Computing Systems Download file

In cloud computing, software architects develop systems for virtually unlimited resources that cloud providers account on a pay-per-use basis. Elasticity management systems provision these resource autonomously to deal with changing workload. Such changing workloads call for new objective metrics allowing architects to quantify quality properties like scalability, elasticity, and eciency, e.g., for requirements/SLO engineering and software design analysis. In literature, initial metrics for these properties have been proposed. However, current metrics lack a systematic derivation and assume knowledge of implementation details like resource handling. Therefore, these metrics are inapplicable where such knowledge is unavailable.
To cope with these lacks, this short paper derives metrics for scalability, elasticity, and eciency properties of cloud computing systems using the goal question metric (GQM) method. Our derivation uses a running example that outlines characteristics of cloud computing systems. Eventually, this example allows us to set up a systematic GQM plan and to derive an initial set of six new metrics. We particularly show that our GQM plan allows to classify existing metrics.

Authors: Matthias Becker, Sebastian Lehrig, Steffen Becker

We will present this paper at the 6th ACM/SPEC International Conference on Performance Engineering (ICPE 2015) in USA (Austin, TX), Feb 2015.

The Architectural Template Method: Design-Time Engineering of SaaS Applications Download file

Typical requirements of SaaS applications target scalability, elasticity, and cost-efficiency. However, these quality properties lack an engineering method for software architects, allowing them to precisely and efficiently analyze these properties already at early design-time.
To tackle this lack, we propose the architectural template (AT) method, an efficient design-time engineering method for analyzing scalability, elasticity, and efficiency properties of SaaS applications.
Our method quantifies such properties based on reusable analysis templates of cloud computing environments. Architects only have to fill-in the parts specific to their SaaS application.

Author: Sebastian Lehrig

We presented this paper at the PhD Session at the Advanced School on Service Oriented Computing 2014 (Summer SOC 2014).

Towards Bridging the Gap Between Scalability and Elasticity Download file

Scalability and elasticity are key capabilities to tackle the variable workload of an application. Cloud elasicity offers opportunities to manage dynamically the platform and infrastructure resources of an application and improve its scalability. However, managing scalability of complex cloud-based systems might lead to an administrative overhead. Self-adaptive systems are a well-known approach to tame this complexity. In this position paper we propose an approach for the continuous design and management of the scalability concern of cloud-based systems. Our approach is based on a three-layers architecture and relies on two existing frameworks, namely ScaleDL and CloudML.

Authors: Nicolas Ferry, Gunnar Brataas, Alessandro Rossini, Franck Chauvel, Arnor Solberg

We presented this paper at the MultiCloud 2014.

Towards Integrating Java EE into ProtoCom Download file

A key concept of model-driven software development is the transformation of models into other models or source code. ProtoCom is such a transformation that generates a performance prototype from a Palladio Component Model (PCM) instance by means of a model-to-text transformation. The actual supported platform, on which the PCM instance is mapped, is Java SE. Even though related work suggests that multiple platforms should be supported, their concrete integration into ProtoCom is only conceptual. For instance, Java EE~has been investigated as a possible target platform, however, ProtoCom lacks its integration as well as the consideration of the current Java~EE standard. Therefore, we provide a novel conceptual mapping from PCM to Java~EE, thus, allowing to implement a transformation that realizes the mapping. As basis for this implementation, we also provide an initial Java~EE reference implementation of a simple example PCM model.

Authors: Sebastian Lehrig, Daria Giacinto

We presented this paper at the Symposium on Software Performance (Joint Kieker/Palladio Days 2013) in Karlsruhe, Germany, Feb 2014.

Why and How We Should Use Graphiti to Implement PCM Editors Download file

For the Palladio Component Model (PCM), performance engineers use graphical editors for specifying and composing components as well as usage scenarios and deployment environments. These editors are created with the Graphical Modeling Framework (GMF). The fact that GMF editors are widely considered as difficult to maintain and to customize raises the question whether it makes sense to migrate to a more modern framework, namely Graphiti. Currently, related work does not evaluate the applicability of Graphiti for PCM editors. Therefore, we analyze the advantages and disadvantages of Graphiti and GMF in the context of Palladio. Based on our findings, we suggest to use Graphiti for the further development of PCM editors. Furthermore, we suggest how these editors can be implemented based on Graphiti.

Authors: Christian Stritzke, Sebastian Lehrig

We presented this paper at the Symposium on Software Performance (Joint Kieker/Palladio Days 2013) in Karlsruhe, Germany, Feb 2014.