Vittorio Cortellessa

A modeling approach to analyze the impact of error propagation on reliability of component-based systems

We present a novel approach to the analysis of the reliability of a component-based system that takes into account an important architectural attribute, namely the error propagation probability. This is the probability that an error, arising somewhere in the system, propagates to other components, possibly up to the system output. As we show in the paper, this attribute may heavily affect decisions on crucial architectural choices. Nonetheless, it is often neglected in modeling the reliability of component-based systems. Our modeling approach provides a useful support to the reliability engineering of component-based systems, since it can be used to drive several significant tasks, such as: (i) placing error detection and recovery mechanisms, (ii) focusing the design, implementation and selection efforts on critical components, (iii) devising cost-effective testing strategies. We illustrate the approach on an ATM example system.

Automatic derivation of software performance models from CASE documents

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.

Reliability Modeling and Analysis of Service-Oriented Architectures

Service selection and composition are central activities in service-oriented computing, and the prediction of the QoS attributes of a Service-Oriented Architecture (SOAs) plays a key role to appropriately drive these activities. Software composition driven by QoS criteria (e.g., optimization of performance, maximization of reliability) has been mostly studied in the Component-Based Software Engineering domain, whereas methodological approaches are not well established in the service-oriented area. Indeed, prediction methodologies for service-oriented systems should be supported by automated and efficient tools to remain compliant with the requirement that most of the activities connected with service discovery and composition must be performed automatically. Moreover, the adopted implementation should respect the autonomy and independence of each provider of the services we want to include in our analysis. In this chapter we focus on the modeling and analysis of the reliability attribute in Service-Oriented Architectures, with particular emphasis on two aspects of this problem: (i) the mathematical foundations of reliability modeling of a Service-Oriented Architecture as a function of the reliability characteristics of its basic elements and (ii) the automatization of service composition driven by reliability criteria.

UML based performance modeling of distributed systems

The development of distributed software systems satisfying performance requirements is achievable only spending careful attention to performance goals throughout the lifecycle, and especially from its very beginning. The aim of our approach is to encompass the performance validation task as an integrated activity within the development process of distributed systems. To this end we consider object oriented distributed systems based on UML, the Unified Modeling Language. We show how a system modeled by UML diagrams can be translated into a queueing network based performance model. The main contribution of this work consists of an extensive application to a case study of our methodological approach for the automatic generation of performance models. The considered case study falls in the domain of distributed software systems, where the proposed methodology suitably exploits and combines information derived from different UML diagrams to generate a quite accurate performance model.

Performance Validation of Mobile Software Architectures

Design paradigms based on the idea of code mobility have been recently introduced, where components of an application may (autonomously or upon request) move to different locations, during the application execution. Besides, software technologies are readily available (e.g. Javabased), that provide tools to implement these paradigms. Based on mobile code paradigms and technologies, different but functionally equivalent software architectures can be defined and it is widely recognized that, in general, the adoption of a particular architecture can have a large impact on quality attributes such as modifiability, reusability, reliability, and performance. Hence, validation against specific attributes is necessary and claims for a careful planning of this activity. Within this framework, the goal of this tutorial is twofold: to provide a general methodology for the validation of software architectures, where the focus is on the transition from the modeling of software architectures to the validation of nonfunctional requirements; to substantiate this general methodology into the specific case of software architectures exploiting mobile code.

Performance analysis of optimistic parallel simulations with limited rolled back events

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

Challenges in Automating Performance Tool Support

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.