59 research outputs found
A model-driven approach to broaden the detection of software performance antipatterns at runtime
Performance antipatterns document bad design patterns that have negative
influence on system performance. In our previous work we formalized such
antipatterns as logical predicates that predicate on four views: (i) the static
view that captures the software elements (e.g. classes, components) and the
static relationships among them; (ii) the dynamic view that represents the
interaction (e.g. messages) that occurs between the software entities elements
to provide the system functionalities; (iii) the deployment view that describes
the hardware elements (e.g. processing nodes) and the mapping of the software
entities onto the hardware platform; (iv) the performance view that collects
specific performance indices. In this paper we present a lightweight
infrastructure that is able to detect performance antipatterns at runtime
through monitoring. The proposed approach precalculates such predicates and
identifies antipatterns whose static, dynamic and deployment sub-predicates are
validated by the current system configuration and brings at runtime the
verification of performance sub-predicates. The proposed infrastructure
leverages model-driven techniques to generate probes for monitoring the
performance sub-predicates and detecting antipatterns at runtime.Comment: In Proceedings FESCA 2014, arXiv:1404.043
Approaching the Model-Driven Generation of Feedback to Remove Software Performance Flaws
Abstract—The problem of interpreting results of perfor-mance 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 perfor-mance 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
Detailed Overview of Software Smells
This document provides an overview of literature concerning software smells covering various dimensions of smells along with their corresponding references
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
Definitions of a Software Smell
Many authors have defined smells from their perspective. This document attempts to provide a consolidated list of such definitions
Performance assessment of an architecture with adaptative interfaces for people with special needs
People in industrial societies carry more and more portable electronic devices (e.g., smartphone or console) with some kind of wireles connectivity support. Interaction with auto-discovered target devices present in the environment (e.g., the air conditioning of a hotel) is not so easy since devices may provide inaccessible user interfaces
(e.g., in a foreign language that the user cannot
understand). Scalability for multiple concurrent users and response times are still problems in this domain. In this paper, we assess an interoperable architecture, which enables interaction between people with some kind of special need and their environment. The assessment, based on performance patterns and antipatterns, tries to detect
performance issues and also tries to enhance the architecture design for improving system performance. As a result of the assessment, the initial design changed substantially. We refactorized the design according to the Fast Path pattern and The Ramp antipattern. Moreover,
resources were correctly allocated. Finally, the required response time was fulfilled in all system scenarios. For a specific scenario, response time was reduced from 60 seconds to less than 6 seconds
Many-Objective Optimization of Non-Functional Attributes based on Refactoring of Software Models
Software quality estimation is a challenging and time-consuming activity, and
models are crucial to face the complexity of such activity on modern software
applications. In this context, software refactoring is a crucial activity
within development life-cycles where requirements and functionalities rapidly
evolve. One main challenge is that the improvement of distinctive quality
attributes may require contrasting refactoring actions on software, as for
trade-off between performance and reliability (or other non-functional
attributes). In such cases, multi-objective optimization can provide the
designer with a wider view on these trade-offs and, consequently, can lead to
identify suitable refactoring actions that take into account independent or
even competing objectives. In this paper, we present an approach that exploits
NSGA-II as the genetic algorithm to search optimal Pareto frontiers for
software refactoring while considering many objectives. We consider performance
and reliability variations of a model alternative with respect to an initial
model, the amount of performance antipatterns detected on the model
alternative, and the architectural distance, which quantifies the effort to
obtain a model alternative from the initial one. We applied our approach on two
case studies: a Train Ticket Booking Service, and CoCoME. We observed that our
approach is able to improve performance (by up to 42\%) while preserving or
even improving the reliability (by up to 32\%) of generated model alternatives.
We also observed that there exists an order of preference of refactoring
actions among model alternatives. We can state that performance antipatterns
confirmed their ability to improve performance of a subject model in the
context of many-objective optimization. In addition, the metric that we adopted
for the architectural distance seems to be suitable for estimating the
refactoring effort.Comment: Accepted for publication in Information and Software Technologies.
arXiv admin note: substantial text overlap with arXiv:2107.0612
Introducing Interactions in Multi-Objective Optimization of Software Architectures
Software architecture optimization aims to enhance non-functional attributes
like performance and reliability while meeting functional requirements.
Multi-objective optimization employs metaheuristic search techniques, such as
genetic algorithms, to explore feasible architectural changes and propose
alternatives to designers. However, the resource-intensive process may not
always align with practical constraints. This study investigates the impact of
designer interactions on multi-objective software architecture optimization.
Designers can intervene at intermediate points in the fully automated
optimization process, making choices that guide exploration towards more
desirable solutions. We compare this interactive approach with the fully
automated optimization process, which serves as the baseline. The findings
demonstrate that designer interactions lead to a more focused solution space,
resulting in improved architectural quality. By directing the search towards
regions of interest, the interaction uncovers architectures that remain
unexplored in the fully automated process
A Process to Effectively Identify “Guilty” Performance Antipatterns
Abstract. The problem of interpreting the results of software perfor-mance analysis is very critical. Software developers expect feedbacks in terms of architectural design alternatives (e.g., split a software compo-nent 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 intro-duce 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 guilti-ness 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
- …