Performance-driven software evolution presents a high complexity due to two causes: (i) performance is a quality attribute that emerges from the combination of different factors (e.g., workload, software deployment, hardware utilization), hence it is difficult to estimate in advance the impact of software changes on such attribute; (ii) the causes of performance degradation are ever more difficult to detect, due to the complexity and heterogeneity of software systems.
This MegaMArt2 paper: Automating Performance Antipattern Detection and Software Refactoring in UML Models by Davide Arcelli, Vittorio Cortellessa, Daniele Di Pompeo (presented at SANER 2019) presents PADRE (Performance Antipattern Detection and REfactoring), a tool for detection and removal of performance antipatterns on UML models. PADRE aims to address some of the challenges around automating performance improvements.
So far, the analysis of performance indices has been traditionally based on bottleneck identification and removal, which has been applied for decades on traditional software systems. More recently, performance antipatterns have emerged as more effective instruments to detect and remove non-trivial performance problems both on models and on code. A performance antipattern is a formalization of a bad design practice that induces performance degradation, and it consists of conditions for its detection along with refactorings for its removal. Many critical performance problems usually emerge in the late lifecycle phases, because system integration highlights the combination of factors mentioned above. However, the identification and removal of performance problems in the initial lifecycle phases, conducted on early artifacts as models, allows to narrow down the search space for possible later empirical performance tuning.
This is the goal of PADRE. PADRE is founded on a well-assessed approach for the formalization of performance antipattern conditions with first-order logics , and on a methodology for model refactoring aimed at removing performance antipatterns. It has been designed and implemented within Epsilon, a widely adopted Eclipse-based open-source model-based software engineering platform.
A novelty of PADRE is that it introduces automation in the performance antipattern detection, in the identification and execution of refactorings that can remove antipatterns. PADRE can be currently used to suggest possible architectural refactoring that might show better performance than the current system architecture. In perspective, it can be adopted in production, by exploiting traceability links between a running system and its corresponding model, which could be fed with actual performance measurements coming from profiling results; once a possible beneficial evolution is identified, the corresponding refactoring should be (semi-)automatically propagated to the implementation level.
The featured image in this post shows one of the antipattern rules and the list of potential improvements once the set of available of antipattern detection rules has been run over a model. You can see PADRE in action in this video: