Search

Context: Software architecture refactoring can be induced by multiple reasons, such as satisfying new functional requirements or improving non-functional properties. Multi-objective optimization approaches have been widely used in the last few years to introduce automation in the refactoring process, and they have revealed their potential especially when quantifiable attributes are targeted. However, the effectiveness of such approaches can be heavily affected by configuration characteristics of the optimization algorithm, such as the composition of solutions. Objective: In this paper, we analyze the behavior of E A S I E R , which is an Evolutionary Approach for Software archItecturE Refactoring, while varying its configuration characteristics, with the objective of studying its potential to find near-optimal solutions under different configurations. Method: In particular, we use two different solution space inspection algorithms (i.e., N S G A − I I and S P E A 2 ) while varying the genome length and the solution composition. Results: We have conducted our experiments on a specific case study modeled in AEmilia ADL, on which we have shown the ability of E A S I E R to identify performance-critical elements in the software architecture where refactoring is worth to be applied. Beside this, from the comparison of multi-objective algorithms, N S G A − I I has revealed to outperform S P E A 2 in most of cases, although the latter one is able to induce more diversity in the proposed solutions. Conclusion: Our results show that the E A S I E R thoroughly automated process for software architecture refactoring allows to identify configuration contexts of the evolutionary algorithm in which multi-objective optimization more effectively finds near-optimal Pareto solutions.

Refactoring is often needed to ensure that software systems meet their performance requirements in deployments with different operational profiles, or when these operational profiles are not fully known or change over time. This is a complex activity in which software engineers have to choose from numerous combinations of refactoring actions. Our paper introduces a novel approach that uses performance antipatterns and stochastic modelling to support this activity. The new approach computes the performance antipatterns present across the operational profile space of a software system under development, enabling engineers to identify operational profiles likely to be problematic for the analysed design, and supporting the selection of refactoring actions when performance requirements are violated for an operational profile region of interest. We demonstrate the application of our approach for a software system comprising a combination of internal (i.e., in-house) components and external third-party services.

The extent of epistemic uncertainty in modeling and analysis of complex systems is ever growing, mainly due to increasing levels of the openness, heterogeneity and versatility in cloud-based applications that are being adopted in critical sectors, like banking and finance. State-of-the-art approaches for model-based performance assessment do not embed such uncertainty in analytic models, hence the predicted results do not account for the parametric uncertainty. In this paper, we develop a method for incorporating epistemic uncertainty of the input parameters (i.e., the arrival rate λ and the service rate μ ) to the M/M/1 queueing models, that are commonly used to analyze system performance. We consider two steady state and average output measures: the number of entities in the system and the response time. We start with closed-form solutions for these measures that enable us to study the propagation of epistemic uncertainty in input parameters to these output measures. We demonstrate the suitability of our method for the performance analysis of a cloud-based system, where the epistemic uncertainty comes from continuous re-deployment of applications across servers of different computational capabilities. System simulation results validate the ability of our models to produce satisfactorily accurate predictions of system performance indices under epistemic uncertainty.

Context Software refactoring is a common practice aimed at addressing requirements or fixing bugs during the software development. While refactoring related to functional requirements has been widely studied in the last few years, non-functional-driven refactoring is still critical, mostly because non-functional characteristics of software are hard to assess and appropriate refactoring actions can be difficult to identify. In the context of performance, which is the focus of this paper, antipatterns represent effective instruments to tackle this issue, because they document common mistakes leading to performance problems as well as their solutions. Objective In order to effectively reuse the knowledge beyond performance antipatterns, automation is required to detect and remove them. In this paper we introduce a framework that enables, in an unique tool context, the refactoring of software models driven by performance antipattern detection and removal. Method We have implemented, within the EPSILON platform, detection rules and refactoring actions on UML models for a set of well-known performance antipatterns. By exploiting the EPSILON languages to check properties and apply refactoring on models, we enable three types of refactoring sessions. Results We experiment our framework on a Botanical Garden Management System to show, on one side, that antipatterns can effectively drive software refactoring towards models that satisfy performance requirements and, on the other side, that the automation introduced by EPSILON-based sessions enables to inspect multiple paths and to propose a variety of solutions. Conclusion This work demonstrates that automation in performance-driven software model refactoring can be beneficial, and that performance antipatterns can be powerful instruments in the hands of software engineers for detecting (and solving) performance problems usually hidden to traditional bottleneck analysis. This work also opens the road to the integration of well-known techniques for software refactoring driven by functional requirements with novel techniques addressing non-functional requirements like performance.

Context awareness is a first-class attribute of today software systems. Indeed, many applications need to be aware of their context in order to adapt their structure and behavior for offering the best quality of service even in case the software and hardware resources are limited. Modeling the context, its evolution, and its influence on the services provided by (possibly resource constrained) applications are becoming primary activities throughout the whole software life cycle, although it is still difficult to capture the multidimensional nature of context. We propose a framework for modeling and reasoning on the context and its evolution along multiple dimensions. Our approach enables (1) the representation of dependencies among heterogeneous context attributes through a formally defined semantics for attribute composition and (2) the stochastic analysis of context evolution. As a result, context can be part of a model-based software development process, and multidimensional context analysis can be used for different purposes, such as non-functional analysis. We demonstrate how certain types of analysis, not feasible with context-agnostic approaches, are enabled in our framework by explicitly representing the interplay between context evolution and non-functional attributes. Such analyses allow the identification of critical aspects or design errors that may not emerge without jointly taking into account multiple context attributes. The framework is shown at work on a case study in the eHealth domain.

Context: 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. Performance antipatterns represent effective instruments to tackle this issue, because they document common mistakes leading to performance problems as well as their solutions.Objective: Up today performance antipatterns have been only studied in the context of software modeling languages like UML, whereas in this manuscript our objective is to catch them in the context of ADL-based software architectures to investigate their effectiveness.Method: We have implemented a model-driven approach that allows the automatic detection of four performance antipatterns in AEmilia, that is a stochastic process algebraic ADL for performance-aware component-oriented modeling of software systems.Results: We evaluate the approach by applying it to three case studies in different application domains. Experimental results demonstrate the effectiveness of our approach to support the performance improvement of ADL-based software architectures.Conclusion: We can conclude that the detection of performance antipatterns, from the earliest stages of software development, represents an effective instrument to tackle the issue of identifying flaws and improving system performance.

Model-Driven Engineering techniques may achieve a major support to the software development when they allow to manage relationships between a running system and its architectural model. These relationships can be exploited for different goals, such as the software evolution due to new functional requirements. In this paper, we define and use relationships that work as support to the performance improvement of a running system. In particular, we combine: (i) a bidirectional model transformation framework tailored to define relationships between performance monitoring data and an architectural model, with (ii) a technique for detecting performance antipatterns and for suggesting architectural changes, aimed at removing performance problems identified on the basis of runtime information. The result is an integrated approach that exploits traceability relationships between the monitoring data and the architectural model to derive recommended refactoring solutions for the system performance improvement. The approach has been applied to an e-commerce application based on microservices that has been designed by means of UML software models profiled with MARTE.

Multi-objective optimization has demonstrated, in the last few years, to be an effective paradigm to tackle different architectural problems, such as service selection, composition and deployment. In particular, multi-objective approaches for searching architectural configurations that optimize quality properties (such as performance, reliability and cost) have been introduced in the last decade. However, a relevant amount of complexity is introduced in this context when performance are considered, often due to expensive iterative generation and solution of performance models. In this paper we introduce EASIER (Evolutionary Approach for multi-objective Software archItecturE Refactoring), that is an approach for applying architecture refactoring based on performance aspects and on the cost of architectural changes. In order to mitigate the complexity related to performance, we exploit the knowledge dwelling in performance antipatterns for more effectively driving the evolutionary algorithm towards optimal solutions. We have implemented our approach on AEmilia ADL, so to carry out performance analysis, antipatterns detection and architecture refactoring within the same environment. We demonstrate the effectiveness and applicability of our approach through a non-trivial experimentation on a case study.

Model-Driven Engineering techniques may achieve a major support to the software development when they allow to manage relationships between a running system and its architectural model. These relationships can be exploited for different goals, such as the software evolution due to new functional requirements. In this paper, we define and use relationships that work as support to the performance improvement of a running system. In particular, we combine: (i) a bidirectional model transformation framework tailored to define relationships between performance monitoring data and an architectural model, with (ii) a technique for detecting performance antipatterns and for suggesting architectural changes, aimed at removing performance problems identified on the basis of runtime information. The result is an integrated approach that exploits traceability relationships between the monitoring data and the architectural model to derive recommended refactoring solutions for the system performance improvement. The approach has been applied to an e-commerce application based on microservices that has been designed by means of UML software models profiled with MARTE.

International audience; Context: Managing Non-Functional Requirements (NFRs) in software projects is challenging, and projects that adopt Model-Driven Development (MDD) are no exception. Although several methods and techniques have been proposed to face this challenge, there is still little evidence on how NFRs are handled in MDD by practitioners. Knowing more about the state of the practice may help researchers to steer their research and practitioners to improve their daily work. Objective: In this paper, we present our findings from an interview-based survey conducted with practitioners working in 18 different companies from 6 European countries. From a practitioner's point of view, the paper shows what barriers and benefits the management of NFRs as part of the MDD process can bring to companies, how NFRs are supported by MDD approaches, and which strategies are followed when (some) types of NFRs are not supported by MDD approaches. Results: Our study shows that practitioners perceive MDD adoption as a complex process with little to no tool support for NFRs, reporting productivity and maintainability as the types of NFRs expected to be supported when MDD is adopted. But in general, companies adapt MDD to deal with NFRs. When NFRs are not supported, the generated code is sometimes changed manually, thus compromising the maintainability of the software developed. However, the interviewed practitioners claim that the benefits of using MDD outweight the extra effort required by these manual adaptations. Conclusion: Overall, the results indicate that it is important for practitioners to handle NFRs in MDD, but further research is necessary in order to lower the barrier for supporting a broad spectrum of NFRs with MDD. Still, much conceptual and tool implementation work seems to be necessary to lower the barrier of integrating the broad spectrum of NFRs in practice.

Cyber-foraging is a technique to enable mobile de- vices to extend their computing power and storage by offloading computation or data to more powerful servers located in the cloud or in single-hop proximity. While there is a large amount of research in this area, the reality is that there are not many deployed, operational cyber-foraging systems. As these systems become more prevalent due to their proven benefits, combined with the emergence of micro data centers and edge clouds, a need will arise for guidance on their architecture and development. To start providing this guidance, we present a decision model based on a mapping of functional and non-functional requirements for cyber-foraging systems to a set of architectural tactics. The decision model was validated by developers to obtain an expert opinion on its correctness and usefulness for guiding the architecture, design, and evolution of cyber-foraging systems that meet their intended functional and non-functional requirements, while understanding the effects of decisions.

Context With the ever-increasing evolution of software systems, their architecture is subject to frequent changes due to multiple reasons, such as new requirements. Appropriate architectural changes driven by non-functional requirements are particularly challenging to identify because they concern quantitative analyses that are usually carried out with specific languages and tools. A considerable number of approaches have been proposed in the last decades to derive non-functional analysis models from architectural ones. However, there is an evident lack of automation in the backward path that brings the analysis results back to the software architecture. Objective In this paper, we propose a model-driven approach to support designers in improving the availability of their software systems through refactoring actions. Method The proposed framework makes use of bidirectional model transformations to map UML models onto Generalized Stochastic Petri Nets (GSPN) analysis models and vice versa. In particular, after availability analysis, our approach enables the application of model refactoring, possibly based on well-known fault tolerance patterns, aimed at improving the availability of the architectural model. Results We validated the effectiveness of our approach on an Environmental Control System. Our results show that the approach can generate: (i) an analyzable availability model from a software architecture description, and (ii) valid software architecture models back from availability models. Finally, our results highlight that the application of fault tolerance patterns significantly improves the availability in each considered scenario. Conclusion The approach integrates bidirectional model transformation and fault tolerance techniques to support the availability-driven refactoring of architectural models. The results of our experiment showed the effectiveness of the approach in improving the software availability of the system.

The reconfiguration of Wireless Sensor Networks is a well-known problem that has been tackled in the last few years mostly with approaches operating at the network level. In this paper, we introduce an approach for the automated reconfiguration of WSNs, driven by energy problems, at the level of software application. In particular, we define reconfiguration actions with Proteus, that is a framework to specify and implement reconfiguration plans on top of Agilla, that is a mobile agent middleware for Wireless Sensor Networks. A Reconfiguration Engine acts on agents within a WSN to activate reconfiguration plans when required, e.g. when the batteries of several sensors located in a critical geographical area are exhausted. We have started to experiment the approach on a real application.

Research and development (R&D) of new tools for performance analysis faces many challenges from immaturity and lack of documentation of supporting tools and infrastructure, incompatibility of tools, lack of access to realistic case studies and performance parameters for them, validation of results, time required versus benefit of results, subsequent maintenance, and many, many others. Yet tool development is an essential part of practical R&D. The panelists relay experiences in developing tools, discuss what needs improvement, opportunities in developing R&D tools, and offer advice for researchers. After introductory remarks from each panelist, there will be a discussion session with the audience.

Refactoring has become a valuable activity during the software development lifecycle, because it can be induced by different causes, like new requirements or quality improvement. In code-based development contexts this activity has been widely studied, whereas in model-driven ones, where models are first-class development entities, there are many issues yet to be tackled. In this paper, we present a metamodel that supports the specification of pre- and post- conditions of model refactoring actions, and the automated derivation and verification of such conditions in specific modeling languages. Our work is aimed at helping users to implement refactoring actions in the adopted modelling language by providing an environment for guaranteeing the feasibility of refactoring actions. Our primary focus is on the definition of applicable sequences of refactoring actions, rather than on the user-driven step-by-step application of refactoring actions. As an example, we illustrate the applicability of our metamodel for UML models refactoring.

Antipatterns are conceptually similar to patterns in that they document recurring solutions to common design problems. Software performance antipatterns document common performance problems in the design as well as their solutions. The definition of performance antipatterns concerns software properties that can include static, dynamic, and deployment aspects. To make use of such knowledge, we propose an approach that helps software architects to identify and solve performance antipatterns. Our approach provides software performance feedback to architects, since it suggests the design alternatives that allow overcoming the detected performance problems. The feedback process may be quite complex since architects may have to assess several design options before achieving the architectural model that best fits the end-user expectations. In order to optimise such process we introduce a ranking methodology that identifies, among a set of detected antipatterns, the ''guilty'' ones, i.e. the antipatterns that more likely contribute to the violation of specific performance requirements. The introduction of our ranking process leads the system to converge towards the desired performance improvement by discarding a consistent part of design alternatives. Four case studies in different application domains have been used to assess the validity of the approach.

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.

Welcome to the WICSA, QoSA, and CBSE 2016 conferences. While we had separate calls for papers, separate chairs and review processes for each conference, we had a unified, stronger community with a joint program committee. Even though the proceedings separate the papers in distinct chapters for each conference, there is a single conference program designed jointly by the program chairs of the three conferences. More precisely, papers accepted separately by the WICSA 2016, QoSA 2016, and CBSE 2016 conferences will be presented together in shared sessions. Hence, this year’s event is a great opportunity to bring together the researchers from the WICSA, QoSA and CBSE conference series. This year, WICSA, QoSA and CBSE calls for papers have attracted 149 submissions in total. Papers submitted to either WICSA, QoSA or CBSE were evaluated separately for each conference. After a careful evaluation by at least three reviewers and a following discussion period, 30 papers were accepted from WICSA, 12 from QoSA and 14 from CBSE. During the technical sessions, conference attendees will have the opportunity to listen to 56 presentations in 18 shared sessions. Some of these sessions will be working sessions with time slots dedicated to extended open discussions. In their calls for papers WICSA, QoSA, and CBSE addressed key concerns of software architectures across the system life cycle, such as designing for longevity, designing for reliability, and designing for flexibility. When we allocated the accepted papers to presentations sessions, it became evident that these concerns were shared by the three conferences. Hence the sessions were assembled to focus on these concerns.

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.

In this paper, we report on our experience with the application of validated models to assess performance, reliability, and adaptability of a complex mission critical system that is being developed to dynamically monitor and control the position of an oil-drilling platform. We present real-time modeling results that show that all tasks are schedulable. We performed stochastic analysis of the distribution of task execution time as a function of the number of system interfaces. We report on the variability of task execution times for the expected system configurations. In addition, we have executed a system library for an important task inside the performance model simulator. We report on the measured algorithm convergence as a function of the number of vessel thrusters. We have also studied the system architecture adaptability by comparing the documented system architecture and the implemented source code. We report on the adaptability findings and the recommendations we were able to provide to the system's architect. Finally, we have developed models of hardware and software reliability. We report on hardware and software reliability results based on the evaluation of the system architecture.

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.

Building a software architecture that meets functional requirements is a quite consolidated activity, whereas keeping high quality attributes is still an open challenge. In this paper we introduce an optimization framework that supports the decision whether to buy software components or to build them in-house upon designing a software architecture. We devise a non-linear cost/quality optimization model based on decision variables indicating the set of architectural components to buy and to build in order to minimize the software cost while keeping satisfactory values of quality attributes. From this point of view, our tool can be ideally embedded into a Cost Benefit Analysis Method to provide decision support to software architects. The novelty of our approach consists in building costs and quality attributes on a common set of decision variables related to software development. We start from a special case of the framework where the quality constraints are related to the delivery time and the product reliability, and the model solution also devises the amount of unit testing to be performed on built components. We generalize the framework formulation to represent a broader class of architectural cost-minimization problems under quality constraints, and discuss advantages and limitations of such approach.

The ability to predict Quality of Service (QoS) of a software architecture supports a large set of decisions across multiple lifecycle phases that span from design through implementation-integration to adaptation phase. However, due to the different amount and type of information available, different prediction approaches can be introduced in each phase. A major issue in this direction is that QoS attribute cannot be analyzed separately, because they (sometime adversely) affect each other. Therefore, approaches aimed at the tradeoff analysis of different attributes have been recently introduced (e.g., reliability versus cost, security versus performance). In this chapter we focus on modeling and analysis of QoS tradeoffs of a software architecture based on optimization models. A particular emphasis will be given to two aspects of this problem: (i) the mathematical foundations of QoS tradeoffs and their dependencies on the static and dynamic aspects of a software architecture, and (ii) the automation of architectural decisions driven by optimization models for QoS tradeoffs.

International audience; Model-Driven Development (MDD) is no longer a novel development paradigm. It has become mature from a research perspective and recent studies show its adoption in industry. Still, some issues remain a challenge. Among them, we are interested in the treatment of non-functional requirements (NFRs) in MDD processes. Very few MDD approaches have been reported to deal with NFRs (and they do it in a limited way). However, it is clear that NFRs need to be considered somehow in the final product of the MDD process. To better understand how NFRs are integrated into the existing MDD approaches, we have initiated the NFR4MDD project, a multinational empirical study, based on interviews with companies working on MDD projects. Our project aims at surveying the state of the practice for this topic. In this paper, we summarize our research protocol and present the current status of our study. The discussion will focus on the peculiarities of our study's context and organization involving about 20 researchers from 8 European countries.

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. Non-functional 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.

Managing a software architecture after the deployment phase is a very complex task due to frequent changes in the software requirements and environment. The software architecture must evolve in order to tackle such changes. The goal of this paper is to provide support for the decisions that software architects make after deployment. This approach is based on an optimization model whose solution suggests the "best" actions to be taken according to a given change scenario (i.e., a set of new requirements that induce changes in the structural and behavioral aspects of the software architecture). The model aims to minimize the costs while keeping the reliability and the performance of the software architecture within certain thresholds. The approach has been implemented as a framework named SHEPhERd, which is composed of a UML case tool, a model builder and a model solver. We show how SHEPhERd works on a smartphone mobile application example, and we highlight its potential to drive architectural decisions through sensitivity analysis. The achieved results are compared with those obtained by two groups of (human) maintainers composed of experts and non-experts with respect to the system and the execution environment, and we show that SHEPhERd outperforms the human judgment-based approaches. We introduce an optimization-based approach for choosing evolution actions.It provides support for the decisions that architects make after deployment.It suggests the "best" actions to be taken according to a set of new requirements.It minimizes the evolution cost under reliability and performance constraints.

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).

Performance is a nonfunctional software attribute that plays a crucial role in wide application domains spreading from safety-critical systems to e-commerce applications. Software risk can be quantified as a combination of the probability that a software system may fail and the severity of the damages caused by the failure. In this paper, we devise a methodology for estimation of performance-based risk factor, which originates from violations, of performance requirements, (namely, performance failures). The methodology elaborates annotated UML diagrams to estimate the performance failure probability and combines it with the failure severity estimate which is obtained using the functional failure analysis. We are thus able to determine risky scenarios as well as risky software components, and the analysis feedback can be used to improve the software design. We illustrate the methodology on an e-commerce case study using step-by step approach, and then provide a brief description of a case study based on large real system.

The separation of functional and non-functional analysis of software systems often prevents from considering design solutions that would be evident if an integrated analysis would be possible. Lack of analysis integration is in fact leading software developers to loose precious feedback that would improve the quality of the software product or, even better, would avoid late software inconsistencies with respect to functional or non-functional requirements. In this paper we introduce a framework for software analysis integration. The framework core is XML-based and consists of software models and formal relations among models. The relations help to automatically propagate the analysis feedback among software models. We specify how different analysis methodologies can be integrated in our framework. We also show how the Eclipse platform represents a natural implementation environment for such a framework.

Modern programming languages and hardware technologies require (and effectively enable) ever more software to be distributed. Different paradigms (client–server, mobility-based, etc.) can be adopted to design distributed software, and deciding the “best” paradigm is a typical choice to be made in the very early software design phases. Several factors should drive this choice, that can also change depending on the software application domain. Within this framework, we focus on a class of attributes related to the performance, and the contribution of this paper is twofold: we extend an existing architecture description language (ADL) to model the physical and logical mobility of components; we introduce a methodology that, starting from a software architecture described using this extended notation, generates a performance model (namely a Markov decision process (MDP)) that allows the designer to evaluate the convenience of introducing logical mobility into a software application. The insights gained by applying our methodology do not consist only in deciding whether a mobile paradigm is effective for the performance improvement of a given application, but also how to use the paradigm, that is where a component should move, based on a certain type of performance indices.

This project has focused on the problem of filling the gap between non-functional analysis of software models and software development artifacts. Its main motivation stems from the fact that, still today, non-functional analysis and software development activities are quite loosely interconnected, thus the additional value that they can lead to each other is often lost. Instead it is commonly recognized that a tighter interconnection of practices, instruments and notations would give rise to more accurate analyses and more effective feedback from analysis results back to software artifacts. The confidence that advanced model-driven techniques can be suitable within this context came from previously successful collaborations among members of our research group that includes researchers from the Model-Driven Engineering and from the Non-functional Analysis areas. The seed of this project's activities was our first experiments on bidirectional transformations between software artifacts and performance models. Our intent was to understand whether this type of transformations could close the loop in both directions that are: transforming software artifacts into analyzable performance models (forward path), interpreting performance analysis results in order to remove problems from performance models and propagate the changes back to software artifacts (backward path). Starting from that point, the project has addressed three main research questions that, along the project development, have emerged as key points in the backward path context, which is the most problematic one. They can be summarized as follows: (1) Is it more advantageous working on the performance side or on the software side to solve problems identified with performance analysis? Can synergy be found among techniques adopted on these sides? (2) How can advanced model-driven techniques help in the model refactoring that is required to remove performance problems detected from the analysis?

In this paper, we present an approach to validation of system performance models for a Border Inspection Management System (BIMS), which guide the tradeoff between the throughput and security requirements. System models used to analyze the operational status of an application and plan for a potentially optimized execution are diverse and increasingly complex. Yet, the practice of software engineering teaches us that optimal operational behavior can be correlated with the simplicity of design and implementation. Adaptive systems are more complex because they typically include monitoring, analysis, planning, and execution (MAPE) loop. Therefore, striving for the "simplest" model that enables appropriate adaptive control actions is a legitimate research direction.

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.

Lifecycle validation of software performance (or prediction of the product ability to satisfy the user performancerequirements) is based on the automatic derivation of software performance models from CASE documents or rapid prototypes. This paper deals with the CASE document alternative. After a brief overview of existing automatic derivation methods, it introduces a method that unifies existing techniques that use CASE documents. The method is step-wise clear, can be used from the early phases of the software lifecycle, is distributed-software oriented, and can be easily incorporated into modern (e.g., UML-based) CASE tools. The method enables the software designer with no specific knowledge of performance theory to predict at design time the performance of various final product alternatives. The designer does only need to feed the CASE documents into the performance model generator. The paper carries on an application case study that deals with the development of distributed software, where the method is used to predict the performance of different distributed architectures the designer could select at preliminary design time to obtain the best performing final product. The method can be easily incorporated into modern object-oriented software development environments to encourage software designers to introduce lifecycle performance validation into their development best practices. © 2001 Elsevier Science B.V. All rights reserved.

Using the parallel simulation approach is not always the best choice. There are situations in which the sequential approach works better, in terms of simulation effectiveness. Indeed, the optimistic parallel simulation time consists of two basic components: the forward execution time, and the rollback mechanism time-overhead. It is convenient to parallelize a simulation until the latter component is not predominant with respect to the former one. The breakeven point depends on the nature of the model to simulate, on the characteristics of the simulation platform, and on the choice of tuning parameters such as the number of processors and the checkpoint interval. This paper deals with an evaluation of the performances of the sequential and parallel approach, in case the optimistic parallel method is used. An analytical model is introduced to study the sensitivity of the parallel simulation effectiveness to the forward event time, in case each event is rolled back no more than once. The model is first experimentally validated and then used to determine the breakeven point between the parallel and sequential approach.

The analysis of non-functional properties of Service-Based Systems (SBSs) is a complex task, mostly because it requires models that encompass the composition of service properties into architectural properties. For example, the reliability of a SBS is given by the composition of service and interconnection reliabilities. Although several approaches have been introduced in the last few years to address these issues, the tradeoff analysis among non-functional properties of software services has not yet been studied enough. The goal of this paper is to introduce a set of optimization models that allow quantifying the costs of service failure repair/mitigation actions aimed at keeping the whole SBS reliability over a certain threshold. On the basis of our previous work in this area, we first introduce an optimization model aimed at selecting either in-house built or provided services with the goal of minimizing the SBS cost while guaranteeing a certain level of reliability. Thereafter we strengthen the reliability constraints, and we build two different optimization models that aim to solve the same problem under new constraints, where one model starts from the solution obtained in the original model and tries to improve it, while the other one looks for an optimal solution in the whole search space. Finally, we introduce a fourth model, based on stochastic optimization, with the goal of rather searching for solutions that explicitly take into account the stochastic nature of the problem and search for new repair/mitigation actions cheaper than the ones identified by the other models. Each optimization model has been experimented on about 300 variations of a nominal model. The experimental results show the efficacy of our optimization models to quantify the costs of different failure repairing/mitigation actions in different contexts.