inproceedings_happe.bib

@inproceedings{becker2008c,
  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.},
  author = {Steffen Becker and Tobias Dencker and Jens Happe},
  booktitle = {Performance Evaluation: Metrics, Models and Benchmarks (SIPEW 2008)},
  doi = {10.1007/978-3-540-69814-2_7},
  isbn = {978-3-540-69813-5},
  pages = {79--98},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{Model-Driven Generation of Performance Prototypes}},
  url = {http://www.springerlink.com/content/62t1277642tt8676/fulltext.pdf},
  volume = {5119},
  year = {2008}
}

@inproceedings{bruggemann2003a,
  author = {Br{\"u}ggemann, Stefan and Happe, Jens and Hildebrandt, Stefan and Olliges, Sascha and Koziolek, Heiko and Krohs, Florian and Sandhaus, Philipp and Starke, Rico and Storm, Christian and Warns, Timo and Willer, Stefan},
  booktitle = {BTW Studierenden-Programm, Dresden, Germany, September, 2003},
  pages = {56--58},
  title = {{K}omponentenmarktplatz f{\"u}r {E}nterprise {J}ava {B}eans},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/bruggemann2003a.pdf},
  year = {2003}
}

@inproceedings{Westermann2011b,
  author = {Dennis, Westermann and Rouven, Krebs and Jens, Happe},
  booktitle = {Proceedings of the Computer Performance Engineering - 8th European Performance Engineering Workshop (EPEW 2011)},
  day = {12--13},
  location = {Borrowdale, UK},
  month = {October},
  pages = {325-339},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/Westermann2011b.pdf},
  publisher = {Springer},
  title = {{E}fficient {E}xperiment {S}election in {A}utomated {S}oftware {P}erformance {E}valuations},
  year = {2011}
}

@inproceedings{FaHa2012-ICPE,
  address = {New York, NY, USA},
  author = {Michael Faber and Jens Happe},
  booktitle = {Proceedings of 3rd ACM/SPEC Internatioanl Conference on Performance Engineering (ICPE 2012)},
  day = {22--25},
  isbn = {978-1-4503-1202-8},
  location = {Boston, USA},
  month = {April},
  pages = {33--44},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/FaHa2012-ICPE.pdf},
  publisher = {ACM},
  title = {Systematic adoption of genetic programming for deriving software performance curves},
  url = {http://doi.acm.org/10.1145/2188286.2188295},
  year = {2012}
}

@inproceedings{firus2005b,
  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.},
  author = {Firus, Viktoria and Becker, Steffen and Happe, Jens},
  booktitle = {Formal {F}oundations of {E}mbedded {S}oftware and {C}omponent-based {S}oftware {A}rchitectures ({FESCA})},
  pages = {73--90},
  series = {Electronic Notes in Theoretical Computer Science},
  title = {{P}arametric {P}erformance {C}ontracts for {QML}-specified {S}oftware {C}omponents},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/firus2005b.pdf},
  volume = {141},
  year = {2005}
}

@inproceedings{happe2007a,
  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.},
  author = {Happe, Jens},
  booktitle = {Proceedings of the 6th Workshop on Process Algebra and Stochastically Timed Activities},
  pages = {51--55},
  title = {{T}owards a {M}odel of {F}air and {U}nfair {S}emaphores in {M}o{D}e{ST}},
  url = {http://pastaworkshop.org/2007/proceedings/fair-semaphores.pdf},
  year = {2007}
}

@incollection{happe2005a,
  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.},
  author = {Happe, Jens},
  booktitle = {First {I}nternational {C}onference on {Q}uality of {S}oftware {A}rchitectures},
  pages = {53--70},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{P}rediction {M}ean {S}ervice {E}xecution {T}imes of {S}oftware {C}omponents {B}ased on {M}arkov {M}odels},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/happe2005a.pdf},
  volume = {3712},
  year = {2005}
}

@inproceedings{happe2005b,
  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.},
  author = {Happe, Jens},
  booktitle = {Trustworthy Software Systems},
  pages = {173--196},
  title = {{P}erformance {P}rediction for {E}mbedded {S}ystems},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/happe2005b.pdf},
  volume = {2},
  year = {2005}
}

@inproceedings{happe2005c,
  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.},
  author = {Happe, Jens and Firus, Viktoria},
  booktitle = {Proceedings of the Tenth Workshop on Component Oriented Programming (WCOP2005)},
  title = {{U}sing {S}tochastic {P}etri {N}ets to {P}redict {Q}uality of {S}ervice {A}ttributes of {C}omponent-{B}ased {S}oftware {A}rchitectures},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/happe2005c.pdf},
  year = {2005}
}

@inproceedings{happe2008a,
  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.},
  address = {New York, NY, USA},
  author = {Jens Happe and Holger Friedrich and Steffen Becker and Ralf H. Reussner},
  booktitle = {Proceedings of the 7th International Workshop on Software and Performance (WOSP '08)},
  isbn = {978-1-59593-873-2},
  location = {Princeton, NJ, USA},
  pages = {165--176},
  publisher = {ACM},
  title = {{A} {P}attern-{B}ased {P}erformance {C}ompletion for {M}essage-{O}riented {M}iddleware},
  year = {2008}
}

@inproceedings{happe2010b,
  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%.},
  acmid = {1906836},
  address = {Washington, DC, USA},
  author = {Jens Happe and Henning Groenda and Michael Hauck and Ralf H. Reussner},
  booktitle = {Proceedings of the 2010 7th International Conference on the Quantitative Evaluation of Systems},
  doi = {http://dx.doi.org/10.1109/QEST.2010.15},
  isbn = {978-0-7695-4188-4},
  numpages = {10},
  pages = {59--68},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/happe2010b.pdf},
  publisher = {IEEE Computer Society},
  series = {QEST '10},
  title = {{A Prediction Model for Software Performance in Symmetric Multiprocessing Environments}},
  url = {http://dx.doi.org/10.1109/QEST.2010.15},
  year = {2010}
}

@inproceedings{happe2009b,
  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.},
  author = {Jens Happe and Henning Groenda and Ralf H. Reussner},
  booktitle = {Proceedings of the 17th IEEE International Symposium on Modelling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'09)},
  title = {{P}erformance {E}valuation of {S}cheduling {P}olicies in {S}ymmetric {M}ultiprocessing {E}nvironments},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/happe2009b.pdf},
  year = {2009}
}

@inproceedings{happe2006a,
  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.},
  author = {Happe, Jens and Koziolek, Heiko and Reussner, Ralf H.},
  booktitle = {Proceedings of the 3rd International Workshop on Formal Aspects of Component Software (FACS)},
  editor = {de Boer, Frank S. and Mencl, Vladimir},
  issn = {1571-0661},
  pages = {91--106},
  series = {Electronic Notes in Theoretical Computer Science},
  title = {{P}arametric {P}erformance {C}ontracts for {S}oftware {C}omponents with {C}oncurrent {B}ehaviour},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/happe2006a.pdf},
  volume = {182},
  year = {2006}
}

@inproceedings{happe2009c,
  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.},
  author = {Jens Happe and Hui Li and Wolfgang Theilmann},
  booktitle = {Proceedings of the 1st International Workshop on the Quality of Service-Oriented Software Systems (QUASOSS)},
  doi = {10.1145/1596473.1596479},
  pages = {19--24},
  publisher = {ACM, New York, NY, USA},
  title = {{B}lack-box {P}erformance {M}odels: {P}rediction based on {O}bservation},
  year = {2009}
}

@inproceedings{happe2010a,
  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.},
  author = {Jens Happe and Dennis Westermann and Kai Sachs and Lucia Kapova},
  booktitle = {{Research into Practice - Reality and Gaps (Proceedings of QoSA 2010)}},
  editor = {George Heineman and Jan Kofron and Frantisek Plasil},
  pages = {20--35},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/happe2010a.pdf},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science (LNCS)},
  title = {{Statistical Inference of Software Performance Models for Parametric Performance Completions}},
  volume = {6093},
  year = {2010}
}

@inproceedings{hauck2011a,
  author = {Michael Hauck and Jens Happe and Ralf Reussner},
  booktitle = {Proceedings of the 1st International Conference on Cloud Computing and Services Science (CLOSER 2011)},
  http = {http://closer.scitevents.org/},
  isbn = {978-989-8425-52-2},
  pages = {616--622},
  pdf = {http://sdqweb.ipd.uka.de/publications/pdfs/hauck2011a.pdf},
  publisher = {SciTePress},
  title = {{T}owards {P}erformance {P}rediction for {C}loud {C}omputing {E}nvironments {B}ased on {G}oal-oriented {M}easurements},
  year = {2011}
}

@inproceedings{hauck2010a,
  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.},
  author = {Michael Hauck and Jens Happe and Ralf H. Reussner},
  booktitle = {Proceedings of the 18th IEEE International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'10)},
  doi = {10.1109/MASCOTS.2010.44},
  isbn = {978-0-7695-4197-6},
  issn = {1526-7539},
  numpages = {9},
  pages = {361--369},
  publisher = {IEEE Computer Society},
  title = {{Automatic Derivation of Performance Prediction Models for Load-balancing Properties Based on Goal-oriented Measurements}},
  url = {http://dx.doi.org/10.1109/MASCOTS.2010.44},
  year = {2010}
}

@inproceedings{heger2013a,
  acmid = {2479879},
  address = {New York, NY, USA},
  author = {Heger, Christoph and Happe, Jens and Farahbod, Roozbeh},
  booktitle = {Proceedings of the 4th ACM/SPEC International Conference on Performance Engineering},
  doi = {10.1145/2479871.2479879},
  isbn = {978-1-4503-1636-1},
  keywords = {performance regression, root cause analysis},
  location = {Prague, Czech Republic},
  note = {Best Paper Award nominee},
  numpages = {12},
  pages = {27--38},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/heger2013a.pdf},
  publisher = {ACM},
  series = {ICPE '13},
  title = {Automated root cause isolation of performance regressions during software development},
  url = {http://doi.acm.org/10.1145/2479871.2479879},
  year = {2013}
}

@inproceedings{kapova2010d,
  address = {New York, NY, USA},
  author = {Kapova, Lucia and Goldschmidt, Thomas and Happe, Jens and Reussner, Ralf H.},
  booktitle = {MDI '10: Proceedings of the First International Workshop on Model-Drive Interoperability},
  doi = {http://doi.acm.org/10.1145/1866272.1866282},
  isbn = {978-1-4503-0292-0},
  location = {Oslo, Norway},
  pages = {69--78},
  publisher = {ACM},
  title = {Domain-specific templates for refinement transformations},
  year = {2010}
}

@inproceedings{kapova2009b,
  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.},
  address = {New York, NY, USA},
  author = {Lucia Kapova and Barbora Zimmerova and Anne Martens and Jens Happe and Ralf H. Reussner},
  booktitle = {Proceedings of the 1st Joint WOSP/SIPEW International Conference on Performance Engineering (WOSP/SIPEW '10)},
  doi = {10.1145/1712605.1712613},
  location = {San Jose, California, USA},
  pages = {37--48},
  publisher = {ACM},
  title = {State Dependence in Performance Evaluation of Component-Based Software Systems},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/kapova2009b.pdf},
  year = {2010}
}

@inproceedings{koziolek2007b,
  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.},
  author = {Koziolek, Heiko and Becker, Steffen and Happe, Jens},
  booktitle = {Proc. 3rd International Conference on the Quality of Software Architectures (QoSA'07)},
  month = {July},
  pages = {145--163},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{P}redicting the {P}erformance of {C}omponent-based {S}oftware {A}rchitectures with different {U}sage {P}rofiles},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/koziolek2007b.pdf},
  volume = {4880},
  year = {2007}
}

@inproceedings{koziolek2007a,
  author = {Heiko Koziolek and Steffen Becker and Jens Happe and Ralf Reussner},
  booktitle = {{M}odel-{D}riven {S}oftware {D}evelopment: {I}ntegrating {Q}uality {A}ssurance},
  editor = {J{\"o}rg Rech and Christian Bunse},
  month = {December},
  pages = {95-118},
  publisher = {IDEA Group Inc.},
  title = {Evaluating Performance of Software Architecture Models with the Palladio Component Model},
  year = {2008}
}

@inproceedings{koziolek2008d,
  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).},
  address = {Universit{\"a}t Karlsruhe (TH), Karlsruhe, Germany},
  author = {Heiko Koziolek and Steffen Becker and Jens Happe and Ralf Reussner},
  booktitle = {Proceedings of the 11th International Symposium on Component-Based Software Engineering (CBSE)},
  month = {October},
  pages = {278-285},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{L}ife-{C}ycle {A}ware {M}odelling of {S}oftware {C}omponents},
  year = {2008}
}

@inproceedings{koziolek2006b,
  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.},
  author = {Koziolek, Heiko and Happe, Jens},
  booktitle = {Proc. 9th Int. Symposium on Component-Based Software Engineering (CBSE'06)},
  editor = {Gorton, Ian and Heineman, George T. and Crnkovic, Ivica and Schmidt, Heinz W. and Stafford, Judith A. and Szyperski, Clemens A. and Wallnau, Kurt C.},
  isbn = {3-540-35628-2},
  pages = {336--343},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{A} {Q}o{S} {D}riven {D}evelopment {P}rocess {M}odel for {C}omponent-{B}ased {S}oftware {S}ystems},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/koziolek2006b.pdf},
  volume = {4063},
  year = {2006}
}

@inproceedings{koziolek2006f,
  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.},
  author = {Koziolek, Heiko and Happe, Jens and Becker, Steffen},
  booktitle = {Proc. 2nd Int. Conf. on the Quality of Software Architectures (QoSA'06)},
  editor = {Hofmeister, Christine and Crnkovic, Ivica and Reussner, Ralf H. and Becker, Steffen},
  month = {July},
  pages = {163--179},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{P}arameter {D}ependent {P}erformance {S}pecification of {S}oftware {C}omponents},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/koziolek2006f.pdf},
  volume = {4214},
  year = {2006}
}

@inproceedings{reussner2005a,
  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.},
  author = {Ralf Reussner and Jens Happe and Annegreth Habel},
  booktitle = {Fundamental Approaches to Software Engineering (FASE)},
  pages = {80--95},
  publisher = {Springer-Verlag Berlin Heidelberg},
  series = {Lecture Notes in Computer Science},
  title = {{M}odelling {P}arametric {C}ontracts and the {S}tate {S}pace of {C}omposite {C}omponents by {G}raph {G}rammars},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/reussner2005a.pdf},
  volume = {3442},
  year = {2005}
}

@inproceedings{wert2012integrating,
  author = {Alexander Wert and Jens Happe and Dennis Westermann},
  booktitle = {Proceedings of the third joint WOSP/SIPEW international conference on Performance Engineering},
  organization = {ACM},
  pages = {283--286},
  title = {Integrating software performance curves with the palladio component model},
  url = {http://dl.acm.org/citation.cfm?id=2188339},
  year = {2012}
}

@inproceedings{Wert:2013:SSR:2486788.2486861,
  acmid = {2486861},
  address = {Piscataway, NJ, USA},
  author = {Wert, Alexander and Happe, Jens and Happe, Lucia},
  booktitle = {Proceedings of the 2013 International Conference on Software Engineering},
  isbn = {978-1-4673-3076-3},
  location = {San Francisco, CA, USA},
  numpages = {10},
  pages = {552--561},
  publisher = {IEEE Press},
  series = {ICSE '13},
  title = {Supporting swift reaction: automatically uncovering performance problems by systematic experiments},
  url = {http://dl.acm.org/citation.cfm?id=2486788.2486861},
  year = {2013}
}

@inproceedings{westermann2010b,
  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.},
  address = {Karlsruhe, Germany},
  author = {Dennis Westermann and Jens Happe},
  booktitle = {Proceedings of the Fifteenth International Workshop on Component-Oriented Programming (WCOP) 2010},
  editor = {B{\"{u}}hnov{\'{a}}, Barbora and Reussner, Ralf H. and Szyperski, Clemens and Weck, Wolfgang},
  isbn = {ISSN 1432 - 7864},
  month = {June},
  pages = {71--78},
  publisher = {Karlsruhe Institue of Technology, Faculty of Informatics},
  series = {Interne Berichte},
  title = {Towards Performance Prediction of Large Enterprise Applications Based on Systematic Measurements},
  url = {http://digbib.ubka.uni-karlsruhe.de/volltexte/1000018464},
  volume = {2010-14},
  year = {2010}
}

@inproceedings{westermann2011a,
  address = {New York, NY, USA},
  author = {Dennis Westermann and Jens Happe},
  booktitle = {ICPE'11: Proceedings of the 2nd ACM/SPEC International Conference on Performance Engineering},
  location = {Karlsruhe, Germany},
  publisher = {ACM},
  title = {{P}erformance {C}ockpit: {S}ystematic {M}easurements and {A}nalyses},
  url = {http://icpe2011.ipd.kit.edu},
  year = {2011}
}

@inproceedings{westermann2013a,
  author = {Dennis Westermann and Jens Happe and Roozbeh Farahbod},
  booktitle = {Proc. of the ACM Symposium on Applied Computing, {SAC 2013}},
  pages = {to appear},
  timestamp = {2012.12.13},
  title = {An Experiment Specification Language for Goal-Driven, Automated Performance Evaluations},
  year = {2013}
}

@inproceedings{westermann2010a,
  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.},
  author = {Dennis Westermann and Jens Happe and Michael Hauck and Christian Heupel},
  booktitle = {Proceedings of the 36th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA 2010)},
  pages = {31-38},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/westermann2010a.pdf},
  publisher = {IEEE Computer Society},
  title = {The Performance Cockpit Approach: A Framework for Systematic Performance Evaluations},
  year = {2010}
}

@inproceedings{westermann2012b,
  author = {Dennis Westermann and Jens Happe and Rouven Krebs and Roozbeh Farahbod},
  booktitle = {Proceedings of the 27th IEEE/ACM International Conference On Automated Software Engineering (ASE 2012)},
  day = {3--7},
  location = {Essen, Germany},
  month = {September},
  title = {Automated Inference of Goal-oriented Performance Prediction Functions},
  year = {2012}
}

@inproceedings{winteler2006a,
  abstract = {Bei den Entwicklern propriet\"{a}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\"{o}nnen auf andere Projekte \"{u}bertragen werden, die GPL-lizenzierte Software einbeziehen.},
  author = {Winteler, Daniel and Koziolek, Heiko and Happe, Jens and Lipskoch, Henrik},
  booktitle = {Proceedings of the 3rd Workshop Informationsysteme mit Open Source (ISOS2006), Dresden, Germany},
  editor = {Jasper, Heinrich and Zukunft, Olaf},
  series = {Lecture Notes in Informatics},
  title = {{D}ie urheberrechtliche {P}roblematik geschlossener {L}inux {K}ernelmodule aus {S}icht des deutschen {R}echts},
  url = {http://sdqweb.ipd.uka.de/publications/pdfs/winteler2006a.pdf},
  year = {2006}
}

@inproceedings{heinrich2018icse,
  author = {Heinrich, Robert and Werle, Dominik and Klare, Heiko and Reussner, Ralf and Kramer, Max and Becker, Steffen and Happe, Jens and Koziolek, Heiko and Krogmann, Klaus},
  title = {The Palladio-Bench for Modeling and Simulating Software Architectures},
  booktitle = {Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings (ICSE 2018)},
  year = {2018},
  isbn = {978-1-4503-5663-3},
  location = {Gothenburg, Sweden},
  pages = {37--40},
  numpages = {4},
  url = {http://doi.acm.org/10.1145/3183440.3183474},
  doi = {10.1145/3183440.3183474},
  acmid = {3183474},
  publisher = {ACM},
  address = {New York, NY, USA},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/heinrich2018icse.pdf}
}