Software architecture plays an important role in determining software quality characteristics, such as maintainability, reliability, reusability, and performance. Performance effects of architectural decisions can be evaluated at an early stage by constructing and analyzing quantitative performance models, which capture the interactions between the main components of the system as well as the performance attributes of the components themselves. The paper proposes a systematic approach to building Layered Queueing Network (LQN) performance models from a UML description of the high-level architecture of a system, and more exactly from the architectural patterns used for the system. The performance model structure retains a clear relationship with the system architecture, which simplifies the task of converting performance analysis results into conclusions and recommendations related to the software architecture. In the second part of the paper, the proposed approach is applied to a telec...

We survey seminal work on software architecture evaluation methods. We then look at an emerging class of methods that explicates evaluating software architectures for stability and evolution. We define architectural stability and formulate the problem of evaluating software architectures for stability and evolution. We draw the attention on the use of Architectures Description Languages (ADLs) for supporting the evaluation of software architectures in general and for architectural stability in specific.

this paper we present and compare some recently proposed approaches on the transformation of UML models of SAs into performance evaluation models. We aim at pointing out how the model transformation techniques make use of the UML diagrams

Quantitative analysis of software systems has been recognized to be important and useful for requirements and design, and, specifically, performance analysis should be integrated in the software development life cycle from the early stages. To this aim, several approaches have been recently proposed to integrate or combine performance analysis and software architecture specification. In this paper we present a brief review and a comparison of some approaches that derive performance models from SA specification. We focus on the generality of the proposed methodologies, the required constraints and assumptions, the type of performance model, the separation of performance model and specification language, the implementation, and how easily the obtained performance results can provide a feedback to the software designer.

An object diagram makes explicit the object structures that are only implicit in a class diagram. An object diagram may be missing and must extracted from the code. Alternatively, an existing diagram may be inconsistent with the code, and must be analyzed for conformance with the implementation. One can generalize the global object diagram of a system into a runtime architecture which abstracts objects into components, represents how those components interact, and can decompose a component into a nested sub-architecture. A static object diagram represents all objects and interobject relations possibly created, and is recovered by static analysis of a program. Existing analyses extract static object diagrams that are non-hierarchical, do not scale, and do not provide meaningful architectural abstraction. Indeed, architectural

The use of design patterns in object-oriented software development is recommended to improve both the software structure and the development process. On the other hand, their effect on the performance of the final product may greatly depend on the particular application and the projected workload. In addition to intentional use, the design may also contain patterns (and anti-patterns) that have not been used on purpose. We propose an approach where all patterns and anti-patterns embedded in the design are discovered by a mining tool and their performance effects are evaluated using previous experience stored in a pattern library. Categories and Subject Descriptors D.2.8 [Software Engineering]: Metrics---performance measures; D.2.11 [Software Engineering]: Software Architectures ---patterns 1. INTRODUCTION Inadequate performance is among the leading reasons why fully implemented and functional systems are sometimes discarded by the users. The users of interactive systems have little...

Software engineering community has proposed several methods to evaluate software architectures with respect to desired quality attributes such as maintainability, performance, and so on. There is, however, little effort on systematically comparing such methods to discover similarities and differences between existing approaches. In this paper, we compare four well known scenario-based SA evaluation methods using an evaluation framework. The framework considers each method from the point of view of method context, stakeholders, structure, and reliability. The comparison reveals that most of the studied methods are structurally similar but there are a number of differences among their activities and techniques. Therefore, some methods overlap, which guides us to identify five common activities that can form a generic process model.

Performance is determined by a system’s resources and its workload. Some of these resources are software resources which are embedded in the software architecture; some of them are even created by the software architecture. This paper considers software resources and resource architecture, as an aspect of software architecture, It considers how resource architecture emerges, the relationship of software and hardware resources, some classes of resource architecture, and what they can tell us about system performance.

We address the problem of describing and analyzing and nonfunctional...

There is growing recognition of the importance of the role of architecture in determining the quality of a software system. While a good architecture cannot guarantee attainment of quality goals, a poor architecture can prevent their achievement. It is particularly important to evaluate the performance of a distributed system architecture. Errors made early can cause excessive overhead for communication and coordination and they are far more difficult – if not impossible – to correct with tuning. This paper discusses assessment of the performance characteristics of distributed software architectures in early life cycle stages. The techniques are described and illustrated with a simple example. 1.