Home | Sitemap | Index | Contact | Legals | KIT

Publications of Jens Happe

Books/Book Chapters and edited Proceedings

[1] Ralf H. Reussner, Steffen Becker, Jens Happe, Robert Heinrich, Anne Koziolek, Heiko Koziolek, Max Kramer, and Klaus Krogmann. Modeling and Simulating Software Architectures - The Palladio Approach. MIT Press, Cambridge, MA, October 2016. [ bib | http | Abstract ]
Too often, software designers lack an understanding of the effect of design decisions on such quality attributes as performance and reliability. This necessitates costly trial-and-error testing cycles, delaying or complicating rollout. This book presents a new, quantitative architecture simulation approach to software design, which allows software engineers to model quality of service in early design stages. It presents the first simulator for software architectures, Palladio, and shows students and professionals how to model reusable, parametrized components and configured, deployed systems in order to analyze service attributes. The text details the key concepts of Palladio's domain-specific modeling language for software architecture quality and presents the corresponding development stage. It describes how quality information can be used to calibrate architecture models from which detailed simulation models are automatically derived for quality predictions. Readers will learn how to approach systematically questions about scalability, hardware resources, and efficiency. The text features a running example to illustrate tasks and methods as well as three case studies from industry. Each chapter ends with exercises, suggestions for further reading, and "takeaways" that summarize the key points of the chapter. The simulator can be downloaded from a companion website, which offers additional material. The book can be used in graduate courses on software architecture, quality engineering, or performance engineering. It will also be an essential resource for software architects and software engineers and for practitioners who want to apply Palladio in industrial settings.
[2] Jens Happe. Predicting Software Performance in Symmetric Multi-core and Multiprocessor Environments, volume 3 of The Karlsruhe Series on Software Design and Quality. Universitätsverlag Karlsruhe, 07 2009. [ bib | DOI | Abstract ]
With today's rise of multi-core processors, concurrency becomes a ubiquitous challenge in software development. Performance prediction methods have to reflect the influence of multiprocessing environments on software performance in order to help software architects to find potential performance problems during early development phases. In this thesis, we address the influence of the operating system scheduler on software performance in symmetric multiprocessing environments.
[3] Irene Eusgeld, Jens Happe, Philipp Limbourg, Matthias Rohr, and Felix Salfner. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Performability, pages 245-254. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
Performability combines performance and reliability analysis in order to estimate the quality of service characteristics of a system in the presence of faults. This chapter provides an introduction to performability, discusses its relation to reliability and performance metrics, and presents common models used in performability analysis, such as Markov reward models or Stochastic Petri Nets.
[4] Jens Happe. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Analytical Performance Metrics, pages 207-218. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf ]
[5] Heiko Koziolek and Jens Happe. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Performance Metrics for Specific Domains, pages 233-240. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
Some performance metrics are specific for certain domains or are used differently under different circumstances. In the following, performance metrics for Internet-based systems and embedded systems will be described.

Refereed journal articles

[1] Heiko Koziolek, Steffen Becker, Jens Happe, Petr Tuma, and Thijmen de Gooijer. Towards software performance engineering for multicore and manycore systems. SIGMETRICS Perform. Eval. Rev., 41(3):2-11, 2014, ACM, New York, NY, USA. [ bib | DOI | http ]
[2] Jens Happe, Heiko Koziolek, and Ralf Reussner. Facilitating performance predictions using software components. Software, IEEE, 28(3):27 -33, June 2011. [ bib | DOI ]
[3] Heiko Koziolek, Steffen Becker, Jens Happe, and Paul Pettersson. Quality of service-oriented software systems (QUASOSS 2010). Models in Software Engineering, pages 364-368, 2011, Springer. [ bib ]
[4] Jens Happe, Steffen Becker, Christoph Rathfelder, Holger Friedrich, and Ralf H. Reussner. Parametric Performance Completions for Model-Driven Performance Prediction. Performance Evaluation (PE), 67(8):694-716, August 2010, Elsevier. [ bib | DOI | http | .pdf | Abstract ]
Performance prediction methods can help software architects to identify potential performance problems, such as bottlenecks, in their software systems during the design phase. In such early stages of the software life-cycle, only a little information is available about the system�s implementation and execution environment. However, these details are crucial for accurate performance predictions. Performance completions close the gap between available high-level models and required low-level details. Using model-driven technologies, transformations can include details of the implementation and execution environment into abstract performance models. However, existing approaches do not consider the relation of actual implementations and performance models used for prediction. Furthermore, they neglect the broad variety of possible implementations and middleware platforms, possible configurations, and possible usage scenarios. In this paper, we (i) establish a formal relation between generated performance models and generated code, (ii) introduce a design and application process for parametric performance completions, and (iii) develop a parametric performance completion for Message-oriented Middleware according to our method. Parametric performance completions are independent of a specific platform, reflect performance-relevant software configurations, and capture the influence of different usage scenarios. To evaluate the prediction accuracy of the completion for Message-oriented Middleware, we conducted a real-world case study with the SPECjms2007 Benchmark [http://www.spec.org/jms2007/]. The observed deviation of measurements and predictions was below 10% to 15%
[5] Steffen Becker, Wilhelm Hasselbring, Alexandra Paul, Marko Boskovic, Heiko Koziolek, Jan Ploski, Abhishek Dhama, Henrik Lipskoch, Matthias Rohr, Daniel Winteler, Simon Giesecke, Roland Meyer, Mani Swaminathan, Jens Happe, Margarete Muhle, and Timo Warns. Trustworthy software systems: a discussion of basic concepts and terminology. SIGSOFT Softw. Eng. Notes, 31(6):1-18, 2006, ACM, New York, NY, USA. [ bib | DOI | .pdf | Abstract ]
Basic concepts and terminology for trustworthy software systems are discussed. Our discussion of definitions for terms in the domain of trustworthy software systems is based on former achievements in dependable, trustworthy and survivable systems. We base our discussion on the established literature and on approved standards. These concepts are discussed in the context of our graduate school TrustSoft on trustworthy software systems. In TrustSoft, we consider trustworthiness of software systems as determined by correctness, safety, quality of service (performance, reliability, availability), security, and privacy. Particular means to achieve trustworthiness of component-based software systems � as investigated in TrustSoft � are formal verification, quality prediction and certification; complemented by fault diagnosis and fault tolerance for increased robustness.

Refereed conference/Workshop papers

[1] Christoph Heger, Jens Happe, and Roozbeh Farahbod. Automated root cause isolation of performance regressions during software development. In Proceedings of the 4th ACM/SPEC International Conference on Performance Engineering, Prague, Czech Republic, 2013, ICPE '13, pages 27-38. ACM, New York, NY, USA. 2013, Best Paper Award nominee. [ bib | DOI | http | .pdf ]
[2] Alexander Wert, Jens Happe, and Lucia Happe. Supporting swift reaction: automatically uncovering performance problems by systematic experiments. In Proceedings of the 2013 International Conference on Software Engineering, San Francisco, CA, USA, 2013, ICSE '13, pages 552-561. IEEE Press, Piscataway, NJ, USA. 2013. [ bib | http ]
[3] Dennis Westermann, Jens Happe, and Roozbeh Farahbod. An experiment specification language for goal-driven, automated performance evaluations. In Proc. of the ACM Symposium on Applied Computing, SAC 2013, 2013, page to appear. [ bib ]
[4] Dennis Westermann, Jens Happe, Rouven Krebs, and Roozbeh Farahbod. Automated inference of goal-oriented performance prediction functions. In Proceedings of the 27th IEEE/ACM International Conference On Automated Software Engineering (ASE 2012), Essen, Germany, September 3-7, 2012. [ bib ]
[5] Michael Faber and Jens Happe. Systematic adoption of genetic programming for deriving software performance curves. In Proceedings of 3rd ACM/SPEC Internatioanl Conference on Performance Engineering (ICPE 2012), Boston, USA, April 22-25, 2012, pages 33-44. ACM, New York, NY, USA. April 2012. [ bib | http | .pdf ]
[6] Alexander Wert, Jens Happe, and Dennis Westermann. Integrating software performance curves with the palladio component model. In Proceedings of the third joint WOSP/SIPEW international conference on Performance Engineering, 2012, pages 283-286. ACM. [ bib | http ]
[7] Westermann Dennis, Krebs Rouven, and Happe Jens. Efficient Experiment Selection in Automated Software Performance Evaluations. In Proceedings of the Computer Performance Engineering - 8th European Performance Engineering Workshop (EPEW 2011), Borrowdale, UK, October 12-13, 2011, pages 325-339. Springer. October 2011. [ bib | .pdf ]
[8] Michael Hauck, Jens Happe, and Ralf Reussner. Towards Performance Prediction for Cloud Computing Environments Based on Goal-oriented Measurements. In Proceedings of the 1st International Conference on Cloud Computing and Services Science (CLOSER 2011), 2011, pages 616-622. SciTePress. 2011. [ bib | http | .pdf ]
[9] Dennis Westermann and Jens Happe. Performance Cockpit: Systematic Measurements and Analyses. In ICPE'11: Proceedings of the 2nd ACM/SPEC International Conference on Performance Engineering, Karlsruhe, Germany, 2011. ACM, New York, NY, USA. 2011. [ bib | http ]
[10] Dennis Westermann and Jens Happe. Towards performance prediction of large enterprise applications based on systematic measurements. In Proceedings of the Fifteenth International Workshop on Component-Oriented Programming (WCOP) 2010, Barbora Bühnová, Ralf H. Reussner, Clemens Szyperski, and Wolfgang Weck, editors, June 2010, volume 2010-14 of Interne Berichte, pages 71-78. Karlsruhe Institue of Technology, Faculty of Informatics, Karlsruhe, Germany. June 2010. [ bib | http | Abstract ]
Understanding the performance characteristics of enterprise applications, such as response time, throughput, and resource utilization, is crucial for satisfying customer expectations and minimizing costs of application hosting. Enterprise applications are usually based on a large set of existing software (e.g. middleware, legacy applications, and third party services). Furthermore, they continuously evolve due to changing market requirements and short innovation cycles. Software performance engineering in its essence is not directly applicable to such scenarios. Many approaches focus on early lifecycle phases assuming that a software system is built from scratch and all its details are known. These approaches neglect influences of already existing middleware, legacy applications, and third party services. For performance prediction, detailed information about the internal structure of the systems is necessary. However, such information may not be available or accessible due to the complexity of existing software. In this paper, we propose a combined approach of model based and measurement based performance evaluation techniques to handle the complexity of large enterprise applications. We outline open research questions that have to be answered in order to put performance engineering in industrial practice. For validation, we plan to apply our approach to different real-world scenarios that involve current SAP enterprise solutions such as SAP Business ByDesign and the SAP Business Suite.
[11] Jens Happe, Henning Groenda, Michael Hauck, and Ralf H. Reussner. A Prediction Model for Software Performance in Symmetric Multiprocessing Environments. In Proceedings of the 2010 7th International Conference on the Quantitative Evaluation of Systems, 2010, QEST '10, pages 59-68. IEEE Computer Society, Washington, DC, USA. 2010. [ bib | DOI | http | .pdf | Abstract ]
The broad introduction of multi-core processors made symmetric multiprocessing (SMP) environments mainstream. The additional cores can significantly increase software performance. However, their actual benefit depends on the operating system scheduler's capabilities, the system's workload, and the software's degree of concurrency. The load distribution on the available processors (or cores) strongly influences response times and throughput of software applications. Hence, understanding the operating system scheduler's influence on performance and scalability is essential for the accurate prediction of software performance (response time, throughput, and resource utilisation). Existing prediction approaches tend to approximate the influence of operating system schedulers by abstract policies such as processor sharing and its more sophisticated extensions. However, these abstractions often fail to accurately capture software performance in SMP environments. In this paper, we present a performance Model for general-purpose Operating System Schedulers (MOSS). It allows analyses of software performance taking the influences of schedulers in SMP environments into account. The model is defined in terms of timed Coloured Petri Nets and predicts the effect of different operating system schedulers (e.g., Windows 7, Vista, Server 2003, and Linux 2.6) on software performance. We validated the prediction accuracy of MOSS in a case study using a business information system. In our experiments, the deviation of predictions and measurements was below 10% in most cases and did not exceed 30%.
[12] Jens Happe, Dennis Westermann, Kai Sachs, and Lucia Kapova. Statistical Inference of Software Performance Models for Parametric Performance Completions. In Research into Practice - Reality and Gaps (Proceedings of QoSA 2010), George Heineman, Jan Kofron, and Frantisek Plasil, editors, 2010, volume 6093 of Lecture Notes in Computer Science (LNCS), pages 20-35. Springer. 2010. [ bib | .pdf | Abstract ]
Software performance engineering (SPE) enables software architects to ensure high performance standards for their applications. However, applying SPE in practice is still challenging. Most enterprise applications include a large software basis, such as middleware and legacy systems. In many cases, the software basis is the determining factor of the system's overall timing behavior, throughput, and resource utilization. To capture these influences on the overall system's performance, established performance prediction methods (modelbased and analytical) rely on models that describe the performance-relevant aspects of the system under study. Creating such models requires detailed knowledge on the system's structure and behavior that, in most cases, is not available. In this paper, we abstract from the internal structure of the system under study. We focus our efforts on message-oriented middleware and analyze the dependency between the MOM's usage and its performance. We use statistical inference to conclude these dependencies from observations. For ActiveMQ 5.3, the resulting functions predict the performance with an relative mean square error 0.1.
[13] Michael Hauck, Jens Happe, and Ralf H. Reussner. Automatic Derivation of Performance Prediction Models for Load-balancing Properties Based on Goal-oriented Measurements. In Proceedings of the 18th IEEE International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'10), 2010, pages 361-369. IEEE Computer Society. 2010. [ bib | DOI | http | Abstract ]
In symmetric multiprocessing environments, the performance of a software system heavily depends on the application's parallelism, the scheduling and load-balancing policies of the operating system, and the infrastructure it is running on. The scheduling of tasks can influence the response time of an application by several orders of magnitude. Thus, detailed models of the operating system scheduler are essential for accurate performance predictions. However, building such models for schedulers and including them into performance prediction models involves a lot of effort. For this reason, simplified scheduler models are used for the performance evaluation of business information systems in general. In this work, we present an approach to derive load-balancing properties of general-purpose operating system (GPOS) schedulers automatically. Our approach uses goal-oriented measurements to derive performance models based on observations. Furthermore, the derived performance model is plugged into the Palladio Component Model (PCM), a model-based performance prediction approach. We validated the applicability of the approach and its prediction accuracy in a case study on different operating systems.
[14] Lucia Kapova, Thomas Goldschmidt, Jens Happe, and Ralf H. Reussner. Domain-specific templates for refinement transformations. In MDI '10: Proceedings of the First International Workshop on Model-Drive Interoperability, Oslo, Norway, 2010, pages 69-78. ACM, New York, NY, USA. 2010. [ bib | DOI ]
[15] Lucia Kapova, Barbora Zimmerova, Anne Martens, Jens Happe, and Ralf H. Reussner. State dependence in performance evaluation of component-based software systems. In Proceedings of the 1st Joint WOSP/SIPEW International Conference on Performance Engineering (WOSP/SIPEW '10), San Jose, California, USA, 2010, pages 37-48. ACM, New York, NY, USA. 2010. [ bib | DOI | .pdf | Abstract ]
Performance prediction and measurement approaches for component-based software systems help software architects to evaluate their systems based on component performance specifications created by component developers. Integrating classical performance models such as queueing networks, stochastic Petri nets, or stochastic process algebras, these approaches additionally exploit the benefits of component-based software engineering, such as reuse and division of work. Although researchers have proposed many approaches in this direction during the last decade, none of them has attained widespread industrial use. On this basis, we have conducted a comprehensive state-of-the-art survey of more than 20 of these approaches assessing their applicability. We classified the approaches according to the expressiveness of their component performance modelling languages. Our survey helps practitioners to select an appropriate approach and scientists to identify interesting topics for future research.
[16] Dennis Westermann, Jens Happe, Michael Hauck, and Christian Heupel. The performance cockpit approach: A framework for systematic performance evaluations. In Proceedings of the 36th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA 2010), 2010, pages 31-38. IEEE Computer Society. 2010. [ bib | .pdf | Abstract ]
Evaluating the performance (timing behavior, throughput, and resource utilization) of a software system becomes more and more challenging as today's enterprise applications are built on a large basis of existing software (e.g. middleware, legacy applications, and third party services). As the performance of a system is affected by multiple factors on each layer of the system, performance analysts require detailed knowledge about the system under test and have to deal with a huge number of tools for benchmarking, monitoring, and analyzing. In practice, performance analysts try to handle the complexity by focusing on certain aspects, tools, or technologies. However, these isolated solutions are inefficient due to the small reuse and knowledge sharing. The Performance Cockpit presented in this paper is a framework that encapsulates knowledge about performance engineering, the system under test, and analyses in a single application by providing a flexible, plug-in based architecture. We demonstrate the value of the framework by means of two different case studies.
[17] Jens Happe, Henning Groenda, and Ralf H. Reussner. Performance Evaluation of Scheduling Policies in Symmetric Multiprocessing Environments. In Proceedings of the 17th IEEE International Symposium on Modelling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'09), 2009. [ bib | .pdf | Abstract ]
The shift of hardware architecture towards parallel execution led to a broad usage of multi-core processors in desktop systems and in server systems. The benefit of additional processor cores for software performance depends on the software's parallelism as well as the operating system scheduler's capabilities. Especially, the load on the available processors (or cores) strongly influences response times and throughput of software applications. Hence, a sophisticated understanding of the mutual influence of software behaviour and operating system schedulers is essential for accurate performance evaluations. Multi-core systems pose new challenges for performance analysis and developers of operating systems. For example, an optimal scheduling policy for multi-server systems, such as shortest remaining processing time (SRPT) for single-server systems, is not yet known in queueing theory. In this paper, we present a detailed experimental evaluation of general purpose operating system (GPOS) schedulers in symmetric multiprocessing (SMP) environments. In particular, we are interested in the influence of multiprocessor load balancing on software performance. Additionally, the evaluation includes effects of GPOS schedulers that can also occur in single-processor environments, such as I/Oboundedness of tasks and different prioritisation strategies. The results presented in this paper provide the basis for the future development of more accurate performance models of today's software systems.
[18] Jens Happe, Hui Li, and Wolfgang Theilmann. Black-box Performance Models: Prediction based on Observation. In Proceedings of the 1st International Workshop on the Quality of Service-Oriented Software Systems (QUASOSS), 2009, pages 19-24. ACM, New York, NY, USA. 2009. [ bib | DOI | Abstract ]
Software performance engineering enables software architects to find potential performance problems, such as bottlenecks and long delays, prior to implementation and testing. Such early feedback on the system's performance is essential to develop and maintain efficient and scalable applications. However, the unavailability of data necessary to design performance models often hinders its application in practice. During system maintenance, the existing system has to be included into the performance model. For large, heterogeneous, and complex systems that have grown over time, modelling becomes infeasible due to the sheer size and complexity of the systems. Re-engineering approaches also fail due to the large and heterogeneous technology stack. Especially for such systems, performance prediction is essential. In this position statement, we propose goal-oriented abstractions of large parts of a software system based on systematic measurements. The measurements provide the information necessary to determine Black-box Performance Models that directly capture the influence of a system's usage and workload on performance (response time, throughput, and resource utilisation). We outline the research challenges that need to be addressed in order to apply Black-box Performance Models.
[19] Heiko Koziolek, Steffen Becker, Jens Happe, and Ralf Reussner. Evaluating performance of software architecture models with the palladio component model. In Model-Driven Software Development: Integrating Quality Assurance, Jörg Rech and Christian Bunse, editors, December 2008, pages 95-118. IDEA Group Inc. December 2008. [ bib ]
[20] Heiko Koziolek, Steffen Becker, Jens Happe, and Ralf Reussner. Life-Cycle Aware Modelling of Software Components. In Proceedings of the 11th International Symposium on Component-Based Software Engineering (CBSE), October 2008, Lecture Notes in Computer Science, pages 278-285. Springer-Verlag Berlin Heidelberg, Universität Karlsruhe (TH), Karlsruhe, Germany. October 2008. [ bib | Abstract ]
Current software component models insufficiently reflect the different stages of component life-cycle, which involves design, implementation, deployment, and runtime. Therefore, reasoning techniques for component-based models (e.g., protocol checking, QoS predictions, etc.) are often limited to a particular life-cycle stage. We propose modelling software components in different design stages, after implemenatation, and during deployment. Abstract models for newly designed components can be combined with refined models for already implemented components. As a proof-of-concept, we have implemented the new modelling techniques as part of our Palladio Component Model (PCM).
[21] Steffen Becker, Tobias Dencker, and Jens Happe. Model-Driven Generation of Performance Prototypes. In Performance Evaluation: Metrics, Models and Benchmarks (SIPEW 2008), 2008, volume 5119 of Lecture Notes in Computer Science, pages 79-98. Springer-Verlag Berlin Heidelberg. 2008. [ bib | DOI | .pdf | Abstract ]
Early, model-based performance predictions help to understand the consequences of design decisions on the performance of the resulting system before the system's implementation becomes available. While this helps reducing the costs for redesigning systems not meeting their extra-functional requirements, performance prediction models have to abstract from the full complexity of modern hard- and software environments potentially leading to imprecise predictions. As a solution, the construction and execution of prototypes on the target execution environment gives early insights in the behaviour of the system under realistic conditions. In literature several approaches exist to generate prototypes from models which either generate code skeletons or require detailed models for the prototype. In this paper, we present an approach which aims at automated generation of a performance prototype based solely on a design model with performance annotations. For the concrete realisation, we used the Palladio Component Model (PCM), which is a component-based architecture modelling language supporting early performance analyses. For a typical three-tier business application, the resulting Java EE code shows how the prototype can be used to evaluate the influence of complex parts of the execution environment like memory interactions or the operating system's scheduler.
[22] Jens Happe, Holger Friedrich, Steffen Becker, and Ralf H. Reussner. A Pattern-Based Performance Completion for Message-Oriented Middleware. In Proceedings of the 7th International Workshop on Software and Performance (WOSP '08), Princeton, NJ, USA, 2008, pages 165-176. ACM, New York, NY, USA. 2008. [ bib | Abstract ]
Details about the underlying Message-oriented Middleware (MOM) are essential for accurate performance predictions of software systems using message-based communication. The MOM's configuration and usage strongly influence its throughput, resource utilisation and timing behaviour. Prediction models need to reflect these effects and allow software architects to evaluate the performance influence of MOM configured for their needs. Performance completions [31, 32] provide the general concept to include low-level details of execution environments in abstract performance models. In this paper, we extend the Palladio Component Model (PCM) [4] by a performance completion for Message-oriented Middleware. With our extension to the model, software architects can specify and configure message-based communication using a language based on messaging patterns. For performance evaluation, a model-to-model transformation integrates the low-level details of a MOM into the high-level software architecture model. A case study based on the SPECjms2007 Benchmark [1] predicts the performance of message-based communication with an error less than 20 percent.
[23] Heiko Koziolek, Steffen Becker, and Jens Happe. Predicting the Performance of Component-based Software Architectures with different Usage Profiles. In Proc. 3rd International Conference on the Quality of Software Architectures (QoSA'07), July 2007, volume 4880 of Lecture Notes in Computer Science, pages 145-163. Springer-Verlag Berlin Heidelberg. July 2007. [ bib | .pdf | Abstract ]
Performance predictions aim at increasing the quality of software architectures during design time. To enable such predictions, specifications of the performance properties of individual components within the architecture are required. However, the response times of a component might depend on its configuration in a specific setting and the data send to or retrieved from it. Many existing prediction approaches for component-based systems neglect these influences. This paper introduces extensions to a performance specification language for components, the Palladio Component Model, to model these influences. The model enables to predict response times of different architectural alternatives. A case study on a component-based architecture for a web portal validates the approach and shows that it is capable of supporting a design decision in this scenario.
[24] Jens Happe. Towards a Model of Fair and Unfair Semaphores in MoDeST. In Proceedings of the 6th Workshop on Process Algebra and Stochastically Timed Activities, 2007, pages 51-55. [ bib | .pdf | Abstract ]
Synchronisation and communication of concurrent processes can have a strong influence on their performance, e.g. throughput and response time. The selection policy of waiting processes is usually not described in performance prediction methods such as stochastic process algebras and stochastic Petri nets, but plays a major role for the response time of real software systems. In this paper, we demonstrate how different selection policies of Java semaphores can be modelled using the specification language MoDeST. In a case study, we first compare the performance of Java�s fair and unfair semaphores. Based on the results, we create an initial behavioural model of semaphores in MoDeST. Finally, a comparison of measurements and predictions shows that the operating system�s scheduler strongly influences performance and thus has to be modelled as well.
[25] Steffen Becker, Jens Happe, and Heiko Koziolek. Putting Components into Context: Supporting QoS-Predictions with an explicit Context Model. In Proc. 11th International Workshop on Component Oriented Programming (WCOP'06), Ralf Reussner, Clemens Szyperski, and Wolfgang Weck, editors, July 2006, pages 1-6. [ bib | .pdf | Abstract ]
The evaluation of Quality of Service (QoS) attributes in early development stages of a software product is an active research area. For component-based systems, this yields many challenges, since a component can be deployed and used by third parties in various environments, which influence the functional and extra-functional properties of a component. Current component models do not reflect these environmental dependencies sufficiently. In this position statement, we motivate an explicit context model for software components. A context model exists for each single component and contains its connections, its containment, the allocation on hard- and software resources, the usage profile, and the perceived functional and extra-functional properties in the actual environment.
[26] Heiko Koziolek, Jens Happe, and Steffen Becker. Parameter Dependent Performance Specification of Software Components. In Proc. 2nd Int. Conf. on the Quality of Software Architectures (QoSA'06), Christine Hofmeister, Ivica Crnkovic, Ralf H. Reussner, and Steffen Becker, editors, July 2006, volume 4214 of Lecture Notes in Computer Science, pages 163-179. Springer-Verlag Berlin Heidelberg. July 2006. [ bib | .pdf | Abstract ]
Performance predictions based on design documents aim at improving the quality of software architectures. In component-based architectures, it is difficult to specify the performance of individual components, because it depends on the deployment context of a component, which may be unknown to its developers. The way components are used influences the perceived performance, but most performance prediction approaches neglect this influence. In this paper, we present a specification notation based on annotated UML diagrams to explicitly model the influence of parameters on the performance of a software component. The UML specifications are transformed into a stochastical model that allows the prediction of response times as distribution functions. Furthermore, we report on a case study performed on an online store. The results indicate that more accurate predictions could be obtained with the newly introduced specification and that the method was able to support a design decision on the architectural level in our scenario.
[27] Jens Happe, Heiko Koziolek, and Ralf H. Reussner. Parametric Performance Contracts for Software Components with Concurrent Behaviour. In Proceedings of the 3rd International Workshop on Formal Aspects of Component Software (FACS), Frank S. de Boer and Vladimir Mencl, editors, 2006, volume 182 of Electronic Notes in Theoretical Computer Science, pages 91-106. [ bib | .pdf | Abstract ]
Performance prediction methods for component-based software systems aim at supporting design decisions of software architects during early development stages. With the increased availability of multicore processors, possible performance gains by distributing threads and processes across multiple cores should be predictable by these methods. Many existing prediction approaches model concurrent behaviour insufficiently and yield inaccurate results due to hard underlying assumptions. In this paper, we present a formal performance prediction approach for component-based systems, which is parameterisable for the number of CPUs or CPU cores. It is able to predict the response time of component services for generally distributed execution times. An initial, simple case study shows that this approach can accurately predict response times of multithreaded software components in specific cases. However, it is limited if threads change the CPU during their execution, if the effect of processor cache thrashing is present, and if the memory bus is heavily used.
[28] Heiko Koziolek and Jens Happe. A QoS Driven Development Process Model for Component-Based Software Systems. In Proc. 9th Int. Symposium on Component-Based Software Engineering (CBSE'06), Ian Gorton, George T. Heineman, Ivica Crnkovic, Heinz W. Schmidt, Judith A. Stafford, Clemens A. Szyperski, and Kurt C. Wallnau, editors, 2006, volume 4063 of Lecture Notes in Computer Science, pages 336-343. Springer-Verlag Berlin Heidelberg. 2006. [ bib | .pdf | Abstract ]
Non-functional specifications of software components are considered an important asset in constructing dependable systems, since they enable early Quality of Service (QoS) evaluations. Several approaches for the QoS analysis of component-based software architectures have been introduced. However, most of these approaches do not consider the integration into the development process sufficiently. For example, they envision a pure bottom-up development or neglect that system architects do not have complete information for QoS analyses at their disposal. We extent an existing component-based development process model by Cheesman and Daniels to explicitly include early, model-based QoS analyses. Besides the system architect, we describe further involved roles. Exemplary for the performance domain, we analyse what information these roles can provide to construct a performance model of a software architecture.
[29] Daniel Winteler, Heiko Koziolek, Jens Happe, and Henrik Lipskoch. Die urheberrechtliche Problematik geschlossener Linux Kernelmodule aus Sicht des deutschen Rechts. In Proceedings of the 3rd Workshop Informationsysteme mit Open Source (ISOS2006), Dresden, Germany, Heinrich Jasper and Olaf Zukunft, editors, 2006, Lecture Notes in Informatics. [ bib | .pdf | Abstract ]
Bei den Entwicklern proprietärer Informationssysteme entsteht im Zusammenhang mit GPL-lizenzierter Software eine erhebliche Unsicherheit. Dabei ist der virale Effekt der GPL auf Linux Kernelmodule (LKM) ein heftig diskutiertes Problem. Unbeachtet bleibt bei dieser Diskussion, dass sich die Rechtslage in Deutschland und Europa von der in den Vereinigten Staaten unterscheidet. Dieser Beitrag beleuchtet exemplarisch, welche Konstellationen streng zu trennen sind und wie sich die Rechtslage bei Entwicklung und Vertrieb von LKMs in Deutschland darstellt. Die gewonnenen Erkenntnisse können auf andere Projekte übertragen werden, die GPL-lizenzierte Software einbeziehen.
[30] Viktoria Firus, Steffen Becker, and Jens Happe. Parametric Performance Contracts for QML-specified Software Components. In Formal Foundations of Embedded Software and Component-based Software Architectures (FESCA), 2005, volume 141 of Electronic Notes in Theoretical Computer Science, pages 73-90. [ bib | .pdf | Abstract ]
The performance of a software component heavily depends on the environment of the component. As a software component only justifies its investment when deployed in several environments, one can not specify the performance of a component as a constant (e.g., as a single value or distribution of values in its interface). Hence, classical component contracts allowing to state the component�s performance as a post-condition, if the environment realises a specific performance stated in the precondition, do not help. This fixed pair of preand postcondition do not model that a component can have very different performance figures depending on its context. Instead of that, parametric contracts are needed for specifying the environmental dependency of the component�s provided performance. In this paper we discuss the specification of dependencies of external calls for the performance metric response time. We present an approach using parametric contracts to compute the statistical distribution of response time as a discrete distribution in dependency of the distribution of response times of environmental services. We use the Quality of Service Modeling Language (QML) as a syntax for specifying distributions.
[31] Jens Happe. Prediction Mean Service Execution Times of Software Components Based on Markov Models. In First International Conference on Quality of Software Architectures, volume 3712 of Lecture Notes in Computer Science, pages 53-70. Springer-Verlag Berlin Heidelberg, 2005. [ bib | .pdf | Abstract ]
One of the aims of component-based software engineering is the reuse of existing software components in different deployment contexts. With the redeployment of a component, its performance changes, since it depends on the performance of external services, the underlying hardware and software, and the operational profile. Therefore, performance prediction models are required that are able to handle these dependencies and use the properties of component-based software systems. Parametric contracts model the relationship of provided and required services of a component. In this paper, we analyse the influence of external services on the service execution time applying parametric contracts and a performance prediction algorithm based on Markov chains. We verbalise the assumptions of this approach and evaluate their validity with an experiment. We will see that most of the assumptions hold only under certain constraints.
[32] Jens Happe. Performance Prediction for Embedded Systems. In Trustworthy Software Systems, 2005, volume 2, pages 173-196. [ bib | .pdf | Abstract ]
In this paper, we discuss different approaches to performance prediction of embedded systems. We distinguish two categories of prediction models depending on the system type. First we consider prediction models for hard real-time systems. These are systems whose correctness depends on the ability to meet all deadlines. Therefore, methods to compute the worst case execution time of each process are required. Then the worst case execution times are used in combination with scheduling algorithms to proof the feasibility of the system on a given set of processors. Second we consider prediction models for soft real-time systems whose deadlines can be missed occasionally. Stochastic approaches which determine the probability of meeting a deadline are used in this case. We discuss these approaches with an example based on Stochastic Automaton Networks. Finally, we discuss the applicability of performance prediction models for embedded systems on general software systems.
[33] Jens Happe and Viktoria Firus. Using Stochastic Petri Nets to Predict Quality of Service Attributes of Component-Based Software Architectures. In Proceedings of the Tenth Workshop on Component Oriented Programming (WCOP2005), 2005. [ bib | .pdf | Abstract ]
The Quality of Service attributes of a software component heavily depend on its environment. For example, if a component uses a highly unreliable service, its own reliability is likely to decrease as well. This relation can be described with parametric contracts, which model the dependence between provided and required services of a component. Until now, parametric contracts can only model single-threaded systems. We plan to extend parametric contracts with Stochastic Petri nets to model multi-threaded systems. This enables the detection of resource conflicts and the consideration of the influence of concurrency on Quality of Service attributes, like performance.
[34] Ralf Reussner, Jens Happe, and Annegreth Habel. Modelling Parametric Contracts and the State Space of Composite Components by Graph Grammars. In Fundamental Approaches to Software Engineering (FASE), 2005, volume 3442 of Lecture Notes in Computer Science, pages 80-95. Springer-Verlag Berlin Heidelberg. 2005. [ bib | .pdf | Abstract ]
Modeling the dependencies between provided and required services within a software component is necessary for several reasons, such as automated component adaptation and architectural dependency analysis. Parametric contracts for software components specify such dependencies and were successfully used for automated protocol adaptation and quality of service prediction. In this paper, a novel model for parametric contracts based on graph grammars is presented and a first definition of the compositionality of parametric contracts is given. Compared to the previously used finite state machine based formalism, the graph grammar formalism allows a more elegant formulation of parametric contract applications and considerably simpler implementations.
[35] Stefan Brüggemann, Jens Happe, Stefan Hildebrandt, Sascha Olliges, Heiko Koziolek, Florian Krohs, Philipp Sandhaus, Rico Starke, Christian Storm, Timo Warns, and Stefan Willer. Komponentenmarktplatz für Enterprise Java Beans. In BTW Studierenden-Programm, Dresden, Germany, September, 2003, 2003, pages 56-58. [ bib | .pdf ]

Technical Reports

[1] Ralf Reussner, Steffen Becker, Erik Burger, Jens Happe, Michael Hauck, Anne Koziolek, Heiko Koziolek, Klaus Krogmann, and Michael Kuperberg. The Palladio Component Model. Technical report, KIT, Fakultät für Informatik, Karlsruhe, 2011. [ bib | http | Abstract ]
This report introduces the Palladio Component Model (PCM), a novel software component model for business information systems, which is specifically tuned to enable model-driven quality-of-service (QoS, i.e., performance and reliability) predictions. The PCMs goal is to assess the expected response times, throughput, and resource utilization of component-based software architectures during early development stages. This shall avoid costly redesigns, which might occur after a poorly designed architecture has been implemented. Software architects should be enabled to analyse different architectural design alternatives and to support their design decisions with quantitative results from performance or reliability analysis tools.
[2] Hui Li, Wolfgang Theilmann, and Jens Happe. Sla translation in multi-layered service oriented architectures: Status and challenges. Technical Report 2009-8, Universität Karlsruhe (TH), April 2009. [ bib | Abstract ]
Service-Oriented Architecture (SOA) represents an architectural shift for building business applications based on loosely-coupled services. In a multi- layered SOA environment the exact conditions under which services are to be delivered can be formally specified by Service Level Agreements (SLAs). However, typical SLAs are just specified at the top-level and do not allow ser- vice providers to manage their IT stack accordingly as they have no insight on how top-level SLAs translate to metrics or parameters at the various layers of the IT stack. This paper addresses the research problems in the area of SLA translation, namely, the correlation and mapping of SLA-related metrics and parameters within and across IT layers. We introduce a conceptual frame- work for precise definition and classification of SLA translations in SOA. With such a framework, an in-depth review and analysis of the state of the art is carried out by the category, maturity, and applicability of approaches and methodologies. Furthermore, we discuss the fundamental research chal- lenges to be addressed for turning the vision of holistic and transparent SLA translation into reality.
[3] Steffen Becker, Tobias Dencker, Jens Happe, Heiko Koziolek, Klaus Krogmann, Martin Krogmann, Michael Kuperberg, Ralf Reussner, Martin Sygo, and Nikola Veber. Software-entwicklung mit eclipse. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, Germany, 2007. Interner Bericht. [ bib | http | Abstract ]
Die Entwicklung von Software mit Hilfe von Eclipse gehört heute zu den Standard-Aufgaben eines Software-Entwicklers. Die Artikel in diesem technischen Bericht beschäftigen sich mit den umfangreichen Möglichkeiten des Eclipse-Frameworks, die nicht zuletzt auf Grund zahlreicher Erweiterungsmöglichkeiten mittels Plugins möglich sind. Dieser technische Bericht entstand aus einem Proseminar im Wintersemester 2006/2007.
[4] Steffen Becker, Thomas Goldschmidt, Henning Groenda, Jens Happe, Henning Jacobs, Christian Janz, Konrad Jünemann, Benjamin Klatt, Christopher Köker, and Heiko Koziolek. Transformationen in der modellgetriebenen software-entwicklung. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, 2007. Interner Bericht. [ bib | http | Abstract ]
Software-Architekturen lassen sich durch Modell beschreiben. Sie sind weder auf eine Beschreibungssprache noch auf eine bestimmte Domänen beschränkt. Im Zuge der Bemühungen modellgetriebener Entwicklung lassen sich hier Entwicklungen hin zu standardisierten Beschreibungssprachen wie UML aber auch die Einführung von domänen-spezifischen Sprachen (DSL) erkennen. Auf diese formalisierten Modelle lassen sich schließlich Transformationen anwenden. Diese können entweder zu einem weiteren Modell ("Model-to-Model") oder einer textuellen Repräsentation ("Model-to-Text") erfolgen. Transformationen kapseln dabei wiederholt anwendbares Entwurfs-Wissen ("Muster") in parametrisierten Schablonen. Für die Definition der Transformationen können Sprachen wie beispielsweise QVT verwendet werden. Mit AndoMDA und openArchitectureWare existieren Werkzeuge, welche die Entwickler bei der Ausführung von Transformationen unterstützen.
[5] Steffen Becker, Jens Happe, Heiko Koziolek, Klaus Krogmann, Michael Kuperberg, Ralf Reussner, Sebastian Reichelt, Erik Burger, Igor Goussev, and Dimitar Hodzhev. Software-komponentenmodelle. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, 2007. Interner Bericht. [ bib | http | Abstract ]
In der Welt der komponentenbasierten Software-Entwicklung werden Komponentenmodelle unter Anderem dazu eingesetzt, Software-Systeme mit vorhersagbaren Eigenschaften zu erstellen. Die Bandbreite reicht von Forschungs- bis zu Industrie-Modellen. In Abhängigkeit von den Zielen der Modelle werden unterschiedliche Aspekte von Software in ein Komponentenmodell abgebildet. In diesem technischen Bericht wird ein überblick über die heute verfügbaren Software-Komponentenmodelle vermittelt.
[6] Ralf H. Reussner, Steffen Becker, Heiko Koziolek, Jens Happe, Michael Kuperberg, and Klaus Krogmann. The Palladio Component Model. Interner Bericht 2007-21, Universität Karlsruhe (TH), 2007. October 2007. [ bib | .pdf ]
[7] Steffen Becker, Aleksander Dikanski, Nils Drechsel, Aboubakr Achraf El Ghazi, Jens Happe, Ihssane El-Oudghiri, Heiko Koziolek, Michael Kuperberg, Andreas Rentschler, Ralf H. Reussner, Roman Sinawski, Matthias Thoma, and Marko Willsch. Modellgetriebene Software-Entwicklung - Architekturen, Muster und Eclipse-basierte MDA. Technical report, Universität Karlsruhe (TH), 2006. [ bib | http | Abstract ]
Modellgetriebene Software-Entwicklung ist in den letzten Jahren insbesondere unter Schlagworten wie MDA und MDD zu einem Thema von allgemeinem Interesse für die Software-Branche geworden. Dabei ist ein Trend weg von der Code-zentrierten Software-Entwicklung hin zum (Architektur-) Modell im Mittelpunkt der Software- Entwicklung festzustellen. Modellgetriebene Software-Entwicklung verspricht eine stetige automatisierte Synchronisation von Software-Modellen verschiedenster Ebenen. Damit einher geht eine mögliche Verkürzung von Entwicklungszyklen und mehr Produktivität. Primär wird nicht mehr reiner Quellcode entwickelt, sondern Modelle und Transformationen übernehmen als eine höhere Abstraktionsebene die Rolle der Entwicklungssprache für Software-Produkte. Derweil ist eine Evolution von Werkzeugen zur modellgetriebenen Entwicklung festzustellen, die einen zusätzlichen Gewinn an Produktivität und Effizienz ermöglichen sollen. Waren die Werkzeuge zur Jahrtausendwende in ihrer Mächtigkeit noch stark eingeschränkt, weil die Transformationssprachen nur eine begrenzte Ausdrucksstärke besaßen und die verfügbaren Werkzeuge eine nur geringe Integration von modellgetriebenen Entwicklungsprozessen boten, so ist heute mit den Eclipse-basiertenWerkzeugen rund um EMF ein deutlicher Fortschritt spürbar. In der Eclipse-Plattform werden dabei als Plugins verschiedenste Aspekte der modellgetriebenen Entwicklung vereint: � Modellierungswerkzeuge zur Erstellung von Software-Architekturen � Frameworks für Software-Modelle � Erstellung und Bearbeitung von Transformationen � Durchführung von Transformationen � Entwicklung von Quellcode Der Seminartitel enthält eine Reihe von Schlagworten: �MDA, Architekturen, Muster, Eclipse�. Unter dem Dach von MDA ergeben sich zwischen diesen Schlagworten Zusammenhänge, die im Folgenden kurz skizziert werden. Software-Architekturen stellen eine allgemeine Form von Modell für Software dar. Sie sind weder auf eine Beschreibungssprache noch auf eine bestimmte Domänen beschränkt. Im Zuge der Bemühungen modellgetriebener Entwicklung lassen sich hier Entwicklungen hin zu Standard-Beschreibungssprachen wie UML aber auch die Einführung von domänen-spezifischen Sprachen (DSL) erkennen. Auf diesen weiter formalisierten Beschreibungen von Software lassen sich schließlich Transformationen anwenden. Diese können entweder zu einem weiteren Modell (�Model-to-Model�) oder einer textuellen Repräsentation (�Model-to-Text�) erfolgen. In beiden Fällen spielen Muster eine wichtige Rolle. Transformationen kapseln in gewisser Weise wiederholt anwendbares Entwurfs-Wissen (�Muster�) in parametrisierbaren Schablonen. Eclipse stellt schließlich eine freie Plattform dar, die in letzter Zeit zunehmend Unterstützung für modellgetriebene Entwicklung bietet. In die Bemühungen zur Unterstützung modellgetriebener Entwicklung fällt auch das im Mai 2006 angekündigte �Eclipse Modeling Project�, das als �top level project� auf die Evolution und Verbreitung modellgetriebener Entwicklungs-Technologien in Eclipse zielt. Das Seminar wurde wie eine wissenschaftliche Konferenz organisiert: Die Einreichungen wurden in einem peer-to-peer-Verfahren begutachtet (vor der Begutachtung durch den Betreuer) und in verschiedenen �Sessions� wurden die �Artikel� an zwei �Konferenztagen� präsentiert. Es gab �best paper awards� und einen eingeladenen Gastredner, Herrn Achim Baier von der itemis AG & Co KG, der dankenswerter Weise einen aufschlussreichen Einblick in Projekte mit modellgetriebener Entwicklung in der Praxis gab. Die �best paper awards� wurden an Herrn El-Ghazi und Herrn Rentschler verliehen, denen hiermit nochmal herzlich zu dieser herausragenden Leistung gedankt wird.


[1] Jens Happe. Predicting Software Performance in Symmetric Multi-core and Multiprocessor Environments. Dissertation, University of Oldenburg, Germany, August 2008. [ bib | .pdf | Abstract ]
With today's rise of multi-core processors, concurrency becomes a ubiquitous challenge in software development. Concurrency allows the improvement of software performance by exploiting available processor cores. Performance prediction methods have to reflect the influence of multiprocessing environments on software performance in order to help software architects to find potential performance problems during early development phases. In this thesis, we address the influence of the operating system scheduler on software performance in symmetric multiprocessing environments. We propose a performance modelling framework for operating system schedulers such as Windows and Linux. Furthermore, the influence of the middleware on software performance is addressed by a performance modelling approach to message-oriented middleware. A series of case studies demonstrates that both techniques reduce the prediction error to less than 5% to 10% in most cases.
[2] Jens Happe. Reliability Prediction of Component-Based Software Architectures. Master's thesis, University of Oldenburg, 2004. [ bib | .pdf | Abstract ]
From the user's point of view, the reliability of a software component depends on its environment as well as its usage profile. The environment of a component includes the external services invoked by the component and the hardware and software it is deployed on. The usage profile determines which services of the component are needed and describes all possible call sequences in form of a Markov model. The in�uence of the usage profile and the reliability of external services on the reliability of a component- based software architecture has been analysed in [38]. There, parametric contracts are used to determine the reliability of a component in its environment. Parametric contracts use so-called service e�ect specifications which describe the usage of external services by a service provided by the component to create a mapping between the provides- and requires interfaces of the same component. We extend the approach described there and consider the reliability of resources like devices (hardware) and execution environments (software). Therefore, we develop a mathematical model to determine the usage period of the resources depending on the usage profile. We compute the reliabilities of the resources on the basis of their usage period. This extends user orientation of software reliability towards system reliability. The consideration of the usage period of a resource requires a mathematical model to determine the execution time of a service. Based on parametric contracts, we develop two approaches to compute the execution time of a service. The first approach makes use of the properties of Markov chains and yields the expected (or average) execution time of a service. The second approach is an extension of parametric performance contracts [37] which describe the execution time of a service in form of a probability density function. We overcome the limits of the approach described there and give a mathematical model to determine the execution time of a loop based on the discrete Fourier transform. Furthermore, we describe how parametric performance contracts can be applied using regular expressions. Furthermore, both computational models are modified to deal with the usage periods of the system resources. The computation of the resource reliability based on the usage period is discussed as well. We use a component-based webserver recently developed in the context of the Palladio project [34] to evaluate some of the predictions made by our model.