Davide Arcelli

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.

Software model refactoring based on performance analysis: better working on software or performance side?

Several approaches have been introduced in the last few years to tackle the problem of interpreting model-based performance analysis results and translating them into architectural feedback. Typically the interpretation can take place by browsing either the software model or the performance model. In this paper, we compare two approaches that we have recently introduced for this goal: one based on the detection and solution of performance antipatterns, and another one based on bidirectional model transformations between software and performance models. We apply both approaches to the same example in order to illustrate the differences in the obtained performance results. Thereafter, we raise the level of abstraction and we discuss the pros and cons of working on the software side and on the performance side.

Control Theory for Model-based Performance-driven Software Adaptation

Self-adaptive techniques have been introduced in the last few years to tackle the growing complexity of software systems, where a major complexity factor leans on their dynamic nature subject to sudden and unpredictable changes that can heavily impact on the software architecture quality. Nonfunctional models, as generated from architectural descriptions of software, have been proven as effective instruments to support designers meeting non-functional requirements since the early architectural phases. However, such models still lack of intrinsic support for adaptable software. Goal of this paper is to extend the modeling capabilities to the case of software adaptation aimed at satisfying performance requirements. In particular, we illustrate how control theory can solve the problem of keeping within pre-defined ranges the indices of a Queueing Network model (such as queue length) through software adaptation actions (such as replacing software services with less resource-demanding ones), while the model is subject to disturbances (such as workload and/or operational profile variations). For this goal we first introduce a library of Modelica components that represent Queueing Network (QN) elements with adaptable parameters (that can be used as knobs for adaptation actions). Then we use such components to build “adaptable” QN models that are subject to disturbances. Finally, in the same framework, we introduce controllers that drive the QN adaptation. We demonstrate the soundness of our approach on a simple representative example in two ways: (i) on one end, we provide a formal proof of controller performance guarantees, and (ii) on the other end we show the sensitivity over time of software adaptation actions to different (types and intensities of) disturbances.

Experimenting the Influence of Numerical Thresholds on Model-based Detection and Refactoring of Performance Antipatterns

Performance antipatterns are well-known bad design practices that lead to software products suffering from poor performance. A number of performance antipatterns has been defined and classified and refactoring actions have also been suggested to remove them. In the last few years, we have dedicated some effort to the detection and refactoring of performance antipatterns in software models. A specific characteristic of performance antipatterns is that they contain numerical parameters that may represent thresholds referring to either performance indices (e.g., a device utilization) or design features (e.g., number of interface operations of a software component). In this paper, we analyze the influence of such thresholds on the capability of detecting and refactoring performance antipatterns. In particular, (i) we analyze how a set of detected antipatterns may change while varying the threshold values and (ii) we discuss the influence of thresholds on the complexity of refactoring actions. With the help of a leading example, we quantify the influence using precision and recall metrics.

Performance-Based Software Model Refactoring in Fuzzy Contexts

The detection of causes of performance problems in software systems and the identification of refactoring actions that can remove the problems are complex activities (even in small/medium scale systems). It has been demonstrated that software models can nicely support these activities, especially because they enable the introduction of automation in the detection and refactoring steps. In our recent work we have focused on performance antipattern-based detection and refactoring of software models. However performance antipatterns suffer from the numerous thresholds that occur in their representations and whose binding has to be performed before the detection starts (as for many pattern/antipattern categories).

Applying Model Differences to Automate Performance-Driven Refactoring of Software Models

Identifying and removing the causes of poor performance in software systems are complex problems, and these issues are usually tackled after software deployment only with human-based means. Performance antipatterns can be used to harness these problems since they capture design patterns that are known leading to performance problems, and they suggest refactoring actions that can solve the problems. This paper introduces an approach to automate software model refactoring based on performance antipatterns. A Role-Based Modeling Language is used to model antipattern problems as Source Role Models (SRMs), and antipattern solutions as Target Role Models (TRMs). Each (SRM, TRM) pair is represented by a difference model that encodes refactoring actions to be operated on a software model to remove the corresponding antipattern. Differences are applied to software models through a model transformation automatically generated by a higher-order transformation. The approach is shown at work on an example in the e-commerce domain.

Assisting Software Designers to Identify and Solve Performance Problems

In order to deal with performance of software systems, it is important to introduce approaches and tools that work in the early phases of the software life-cycle, even before the code is developed. In fact, if performance requirement violations are discovered too late, then there may be significant impacts on project costs. Some work has been done in the last few years to tackle the problem of automatically interpreting model-based performance analysis results and translating them into feedback for software designers. However, this effort is still far from providing tools that can actually assist designers to identify and solve performance problems. In this paper, we present a framework aimed at supporting automated feedback generation from software performance analysis results, based on Model-Driven Engineering principles and techniques. In particular, we focus on the level of automation that such framework introduces, and we provide a vision of a design assistant that implements it.

Challenges in Applying Control Theory to Software Performance Engineering for Adaptive Systems

Control theory has recently started to be applied to software engineering domain, mostly for managing the behavior of adaptive software systems under external disturbances. In general terms, the main advantage of control theory is that it can be formally proven that controllers achieve their goals (with certain characteristics), whereas the price to pay is that controllers and system-to-be-controlled have to be modeled by equations. The investigation of how suited are control theory techniques to address performance problems is, however, still at the beginning. In this paper we devise the main challenges behind the adoption of control theory in the context of Software Performance Engineering applied to adaptive software systems.

Performance Antipattern Detection through fUML Model Library

Identifying performance problems is critical in the software design, mostly because the results of performance analysis (i.e., mean values, variances, and probability distributions) are difficult to be interpreted for providing feedback to software designers. Performance antipatterns support the interpretation of performance analysis results and help to fill the gap between numbers and design alternatives. In this paper, we present a model-driven framework that enables an early detection of performance antipatterns, i.e., without generating performance models. Specific design features (e.g., the number of sent messages) are monitored while simulating the specified software model, in order to point out the model elements that most likely contribute for performance flaws. To this end, we propose to use fUML models instrumented with a reusable library that provides data structures (as Classes) and algorithms (as Activities) to detect performance antipatterns while simulating the fUML model itself. A case study is provided to show our framework at work, its current capabilities and future challenges.

Automated translation among EPSILON languages for performance-driven UML software model refactoring

Although performance represents a crucial non-functional attribute of software, few model-based approaches have been introduced up today for reducing the gap between performance analysis results (e.g., mean response time) and the feedback expected by software engineers when performance problems are detected (i.e., refactoring actions). However, existing approaches aimed at performance-driven refactoring of software models suffer from fragmentation across different paradigms, languages, and meta-models. This paper aims at reducing such fragmentation by exploiting the EPSILON environment, which provides a suite of languages for checking properties and applying refactoring on models. In particular, we introduce automation aimed at translating performance antipattern detection rules and refactoring actions among three EPSILON languages. Such automation helps to reduce code writing effort, in the context of performance-driven refactoring of UML models, while exploiting the specific support provided by the different execution semantics of considered languages.