Dorin Bogdan Petriu

An intermediate metamodel with scenarios and resources for generating performance models from UML designs

Performance analysis of a software specification in a language such as UML can assist a design team in evaluating performance-sensitive design decisions and in making design trade-offs that involve performance. Annotations to the design based on the UML Profile for Schedulability, Performance and Time provide necessary information such as workload parameters for a performance model, and many different kinds of performance techniques can be applied. The Core Scenario Model (CSM) described here provides a metamodel for an intermediate form which correlates multiple UML diagrams, extracts the behaviour elements with the performance annotations, attaches important resource information that is obtained from the UML, and supports the creation of many different kinds of performance models. Models can be made using queueing networks, layered queues, timed Petri nets, and it is proposed to develop the CSM as an intermediate language for all performance formalisms. This paper defines the CSM and describes how it resolves questions that arise in performance model-building.

A Metamodel for Generating Performance Models from UML Designs

Several different kinds of performance models can be generated from sets of scenarios that describe typical responses of a system, and their use of re-sources. The Core Scenario Model described here integrates the scenario and resource elements defined in a UML model with performance annotations, preparatory to generating performance models. It is based on, and aligned with the UML Profile for Schedulability, Performance and Time, and supports the generation of predictive performance models using queueing networks, layered queueing, or timed Petri nets. It is proposed to develop it as an intermediate language for all performance formalisms.

Analysing software requirements specifications for performance

The earliest moment when performance issues can be addressed is the initial specification of a software system, during the formulation of the architecture, and well before the design stage. A common form of specification at this stage is a set of scenarios to be executed by the system, which embody the Use Cases, and identify the sequence of responsibilities to be carried out in different kinds of responses. On the basis that earlier analysis is better, a performance modeling capability has been installed in a scenario modeling tool for Use Case Maps that is part of a proposed standard for User Requirements Notation. Using examples, the paper shows how this kind of early analysis can address high-level performance questions, at a comparable level of abstraction to the specification. The imprecision of early knowledge, and the risk of ignoring some performance limitations, are key factors whose impact is addressed.

Performance analysis of security aspects in UML models

The focus of the paper is on the analysis of performance effects of different security solutions modeled as aspects in UML. Aspect oriented modeling (AOM) allows software designers to isolate and separately address solutions for crosscutting concerns, which are defined as distinct UML aspect models, then are composed with the primary UML model of the system under development. For performance analysis we use techniques developed previously in the PUMA project, which take as input UML models annotated with the standard UML Profile for Schedulability, Performance and Time (SPT), and transform them first into Core Scenario Model (CSM) and then into different performance models. The contribution of this paper is in performing the composition of the aspects with the primary model at the CSM level. The input is represented by the primary model and a number of aspect models in UML+SPT, which are processed as follows: a) converted separately to CSM; b) composed into a single CSM model; c) transformed into a Layered Queueing Networks (LQN) model and d) analyzed. The proposed approach is illustrated with a case study based on two standards, TPC-W and SSL.

Performance analysis of security aspects by weaving scenarios extracted from UML models

Aspect-oriented modeling (AOM) allows software designers to describe features that address pervasive concerns separately as aspects, and to systematically incorporate the features into a design model using model composition techniques. The goal of this paper is to analyze the performance effects of different security features that may be represented as aspect models. This is part of a larger research effort to integrate methodologies and tools for the analysis of security and performance properties early in the software development process. In this paper, we describe an extension to the AOM approach that provides support for performance analysis. We use the performance analysis techniques developed previously in the PUMA project, which take as input UML models annotated with the standard UML Profile for Schedulability, Performance and Time (SPT), and transform them first into Core Scenario Model (CSM), and then into different performance models. The composition of the aspects with the primary (base) model is performed at the CSM level. A new formal definition of CSM properties and operations is described as a foundation for scenario-based weaving. The proposed approach is illustrated with an example that utilizes two standards, TPC-W and SSL.

Software performance models from system scenarios

The earliest definition of a software system may be in the form of Use Cases, which may be elaborated as scenarios. In this work, performance models are created from scenarios, to permit the earliest possible analysis of potential performance issues. Suitable forms of scenario models include Unified Modeling Language (UML) Activity or Sequence Diagrams (SD), and Use Case Maps (UCM) from the User Requirements Notation (URN) standard. They capture the causal flow of intended execution, and the operations, activities or responsibilities which may be allocated to components, with their expected resource demands. The Scenario to Performance (S2P) algorithm described here automatically transforms scenario models into performance models, and the LQNGenerator tool implements S2P to convert UCM scenario models into layered queueing performance models. S2P can, in principle, also be applied to other scenario models, including Message Sequence Charts, UML Activity Graphs (or Collaboration Diagrams, or Sequence Diagrams).

Transformation challenges: from software models to performance models

A software model can be analysed for non-functional requirements by extending it with suitable annotations and transforming it into analysis models for the corresponding non-functional properties. For quantitative performance evaluation, suitable annotations are standardized in the “UML Profile for Modeling and Analysis of Real-Time Embedded systems” (MARTE) and its predecessor, the “UML Profile for Schedulability, Performance and Time”. A range of different performance model types (such as queueing networks, Petri nets, stochastic process algebra) may be used for analysis. In this work, an intermediate “Core Scenario Model” (CSM) is used in the transformation from the source software model to the target performance model. CSM focuses on how the system behaviour uses the system resources. The semantic gap between the software model and the performance model must be bridged by (1) information supplied in the performance annotations, (2) in interpretation of the global behaviour expressed in the CSM and (3) in the process of constructing the performance model. Flexibility is required for specifying sets of alternative cases, for choosing where this bridging information is supplied, and for overriding values. It is also essential to be able to trace the source of values used in a particular performance estimate. The performance model in turn can be used to verify responsiveness and scalability of a software system, to discover architectural limitations at an early stage of development, and to develop efficient performance tests. This paper describes how the semantic gap between software models in UML+MARTE and performance models (based on queueing or Petri nets) can be bridged using transformations based on CSMs, and how the transformation challenges are addressed.

Traceability and evaluation in scenario analysis by use case maps

The Use Case Map (UCM) scenario notation has some strong features related to rapid capture and evaluation of requirements models. In this paper, we explain how a UCM model was developed from a requirements oracle case study: the Autonomous Shuttle Transport System. We further consider establishing links between scenario elements and other types of requirements. These links, which can be supported by requirements management tools, are useful to maintain both the scenarios and requirements during their evolution. We also demonstrate how simple performance models generated from UCMs may impact high-level requirements and architectures.