Catia Trubiani

An approach for modeling and detecting software performance antipatterns based on first-order logics

The problem of interpreting the results of performance analysis is quite critical in the software performance domain. Mean values, variances and probability distributions are hard to interpret for providing feedback to software architects. Instead, what architects expect are solutions to performance problems, possibly in the form of architectural alternatives (e.g. split a software component in two components and re-deploy one of them). In a software performance engineering process, the path from analysis results to software design or implementation alternatives is still based on the skills and experience of analysts. In this paper, we propose an approach for the generation of feedback based on performance antipatterns. In particular, we focus on the representation and detection of antipatterns. To this goal, we model performance antipatterns as logical predicates and we build an engine, based on such predicates, aimed at detecting performance antipatterns in an XML representation of the software system. Finally, we show the approach at work on a case study.

Antipattern-based model refactoring for software performance improvement

Identifying and removing the causes of poor performance in software systems are complex problems due to a variety of factors to take into account. Nowadays these problems are usually tackled after the software deployment only with human-based means, which frequently boil down to developer skills and previous experiences. Performance antipatterns can be used to cope with these problems since they capture typical design patterns that are known leading to performance problems, as well as refactoring actions that can be taken to remove them. The goal of this paper is to introduce an approach that allows the refactoring of architectural models, based on antipatterns, that aims at providing performance improvement. To this end, we use a Role-Based Modeling Language to represent: (i) antipattern problems as Source Role Models (SRMs), and (ii) antipattern solutions as Target Role Models (TRMs). Hence, SRM-TRM pairs represent new instruments in the hands of developers to achieve architectural model refactorings aimed at removing sources of performance problems. Model refactoring for antipattern removal can be in fact obtained by replacing an SRM with the corresponding TRM. This approach has been applied to a case study in the e-commerce domain, whose experimental results demonstrate its effectiveness.

A process to effectively identify “guilty” performance antipatterns

The problem of interpreting the results of software performance analysis is very critical. Software developers expect feedbacks in terms of architectural design alternatives (e.g., split a software component in two components and re-deploy one of them), whereas the results of performance analysis are either pure numbers (e.g. mean values) or functions (e.g. probability distributions). Support to the interpretation of such results that helps to fill the gap between numbers/functions and software alternatives is still lacking. Performance antipatterns can play a key role in the search of performance problems and in the formulation of their solutions. In this paper we tackle the problem of identifying, among a set of detected performance antipatterns, the ones that are the real causes of problems (i.e. the “guilty” ones). To this goal we introduce a process to elaborate the performance analysis results and to score performance requirements, model entities and performance antipatterns. The cross observation of such scores allows to classify the level of guiltiness of each antipattern. An example modeled in Palladio is provided to demonstrate the validity of our approach by comparing the performance improvements obtained after removal of differently scored antipatterns.

Digging into UML models to remove performance antipatterns

Performance antipatterns have been informally defined and characterized as bad practices in software design that can originate performance problems. Such special type of patterns can involve static and dynamic aspects of software as well as deployment features. It has been shown that quite often the inability to meet performance requirements is due to the presence of antipatterns in the software design. However the problem of formally defining antipatterns and automatically detect them within a design model has not been investigated yet. In this paper we examine this problem within the UML context and show how performance antipatterns can be defined and detected in UML models by mean of OCL. A case study in UML annotated with the MARTE profile is presented where, after a performance analysis that shows unsatisfactory results, performance antipatterns are detected through an OCL engine. The identification of an antipattern suggests the architectural alternatives that can remove that specific problem. We show in our example that the removal of a certain antipattern actually allows to overcome a specific performance problem.

Performance Antipatterns as Logical Predicates

The problem of interpreting the results of performance analysis is quite critical in the software performance domain. Mean values, variances, probability distributions are hard to interpret for providing feedback to software architects. Instead, what architects expect are solutions to performance problems, possibly in the form of architectural alternatives (e. g. split a software component in two components and re-deploy one of them). In a software performance engineering approach this path from analysis results to software alternatives still lacks of automation and is based on the skills and experience of analysts. In this paper we propose an automated approach for the performance feedback generation process based on performance antipatterns. To this aim, we model performance antipatterns as logical predicates and we provide a java engine, based on such predicates, that is able to detect performance antipatterns in an XML representation of the software system. Finally, we show the approach at work on a simple case study.

Model-based performance analysis of software architectures under uncertainty

Performance analysis is often conducted before achieving full knowledge of a software system, in other words under a certain degree of uncertainty. Uncertainty is particularly critical in the performance domain when it relates to values of parameters such as workload, operational profile, resource demand of services, service time of hardware devices, etc. The goal of this paper is to explicitly consider uncertainty in the performance modelling and analysis process. In particular, we use probabilistic formulation of parameter uncertainties and present a Monte Carlo simulation-based approach to systematically assess the robustness of an architectural model despite its uncertainty. In case of unsatisfactory results, we introduce refactoring actions aimed at generating new software architectural models that better tolerate the uncertainty of parameters. The proposed approach is illustrated on a case study from the e-Health domain.

Approaching the Model-Driven Generation of Feedback to Remove Software Performance Flaws

The problem of interpreting results of performance analysis and providing feedback on software models to overcome performance flaws is probably the most critical open issue in the field of software performance engineering. Automation in this step would help to introduce performance validation as an integrated activity in the software lifecycle, without dramatically affecting the daily practices of software developers. In this paper we approach the problem with model-driven techniques, on which we build a general solution. Basing on the concept of performance antipatterns, that are bad practices in software modeling leading to performance flaws, we introduce metamodels and transformations that can support the whole process of flaw detection and solution. The approach that we propose is notation-independent and can be embedded in any (existing or future) concrete modeling notation by using weaving models and automatically generated model transformations. Finally, we discuss the issues opened from this work and the future achievements that are at the hand in this domain thanks to model-driven techniques.

Performance-based selection of software and hardware features under parameter uncertainty

Configurable software systems allow stakeholders to derive variants by selecting software and/or hardware features. Performance analysis of feature-based systems has been of large interest in the last few years, however a major research challenge is still to conduct such analysis before achieving full knowledge of the system, namely under a certain degree of uncertainty. In this paper we present an approach to analyze the correlation between selection of features embedding uncertain parameters and system performance. In particular, we provide best and worst case performance bounds on the basis of selected features and, in cases of wide gaps among these bounds, we carry on a sensitivity analysis process aimed at taming the uncertainty of parameters. The application of our approach to a case study in the e-health domain demonstrates how to support stakeholders in the identification of system variants that meet performance requirements.

Enabling Performance Antipatterns to Arise from an ADL-based Software Architecture

While the performance analysis of a software architecture is a quite well-assessed task nowadays, the issue of interpreting the performance results for providing feedback to software architects is still very critical. This is mostly due to the gap between results representation (i.e. mean values, variances, and/or probability distributions) and expected feedback (i.e. architectural alternatives). Performance antipatterns represent effective instruments to tackle this issue, because they document common mistakes leading to performance problems as well as their solutions. In this paper we present a model-driven approach that enables performance antipatterns to arise in the context of an ADL-based software architecture. Such approach automatically detects them in AEmilia, i.e. an ADL allowing the performance evaluation of software systems. The approach has been applied to a case study, and experimental results demonstrate its effectiveness.

Towards a library of composable models to estimate the performance of security solutions

Complex distributed dependable systems, such as web-based applications that contain sensitive data and are exposed to many users, have to meet different, and sometimes conflicting, non functional requirements, such as security and performance requirements. A typical example of this trade-off is the performance degradation introduced in a system by the raising of security solutions. Several proposals have been made to estimate the performance of security methodologies, but they are often grounded to existing standards such as IPsec and SSL. In this paper we tackle the problem from a model-based viewpoint: we introduce basic performance models for security mechanisms, which can be considered as building bricks to compose in order to model security services. To this goal, we introduce rules that drive the composition. Security service models can then be integrated with functional models of critical applications to estimate the performance of the adopted security solutions. We represent models as Generalized Stochastic Petri Nets (GSPNs). This is a first step towards a Security Library containing composable performance models of security mechanisms and services and representing an instrument to support designers in decisions related to the security vs performance trade-off. We show how to use our models on an example of banking system.