Performance evaluation of UML software architectures with multiclass Queueing Network models

Performance evaluation of Component-Based software systems should be performed as early as possible during the software development life cycle. Unfortunately, a detailed quantitative analysis is often not possible during such stages, as only the system outline is available, with very little quantitative knowledge. In this paper we propose an approach based on Queueing Network analysis for performance evaluation of component-based software systems at the software architectural level. Our approach provides performance bounds which can be efficiently computed. Starting from annotated UML diagrams we compute bounds on the system throughput and response time without explicitly deriving or solving the underlying multichain and multiclass Queueing Network model. We illustrate with an example how the technique can be applied to answer many performance-related questions which may arise during the software design phase.

Queueing Network Models (QNMs) with Finite Capacity provide powerful and realistic tools for the performance evaluation and prediction of discrete flow systems such as computer systems, communication networks and flexible manufacturing systems. Over recent years, there has been a great deal of progress towards the analysis and application of QNMs with finite capacity, and high quality research work has appeared in diverse scientific journals of learning and conference proceedings in the fields of Operations Research, Computer Science, Telecommunication Networks, Management and Industrial Engineering. However, there are still many important and interesting finite capacity queues and QNMs to be resolved, such as those involving multiple-job classes, bounds and theoretical properties, exact analysis, numerical solutions and approximate methods, as well as application studies to computer and distributed systems, high-speed networks and production systems.This volume of Annals of Operations Research on Queueing Networks with Finite Capacity presents 17 extended research papers, both from industry and academia, reflecting current original contributions in the theory and applications of finite capacity queues and networks worldwide. Earlier short versions of these papers were amongst those presented at QNets '95, The Third International Workshop on Queueing Networks with Finite Capacity, 6th-7th July, 1995, Ilkley, West Yorkshire, UK. The papers are classified into four parts covering exact analysis, approximate methods, error bounds and performance modelling studies.

The paper presents an approach to modeling programs for reconfigurable logic controllers using Unified Modeling Language and Petri net notations. The proposed design method attempts to combine the advantages of graphical notation (readability, convenience, intuitiveness) with the benefits of text specification languages (precision, versatility) and sophisticated model verification tools. The UML model and Petri net model are transformed separately into effective programs in Hardware Description Languages (Verilog, VHDL). Moreover, the Petri net model (created based on UML model) can be used for analysis and verification of the designed system. The obtained HDL specifications can be simulated, synthesized and implemented in modern reconfigurable Field Programmable Gate Array devices. A practical example illustrating the benefits of the proposed method is also presented.

Although the UML is considered to be the de facto standard notation with which to model software, there is still resistance to model-based development. UML modeling is perceived to be expensive and not necessarily cost-effective. It is therefore important to collect empirical evidence concerning the conditions under which the use of UML makes a practical difference. The focus of this paper is to investigate whether and how the Level of Detail (LoD) of UML diagrams impacts on the performance of maintenance tasks in a model-centric approach. A family of experiments consisting of one controlled experiment and three replications has therefore been carried out with 81 students with different abilities and levels of experience from 3 countries (The Netherlands, Spain, and Italy). The analysis of the results of the experiments indicates that there is no strong statistical evidence as to the influence of different LoDs. The analysis suggests a slight tendency toward better results when using low LoD UML diagrams, especially if used for the modification of the source code, while a high LoD would appear to be helpful in understanding the system. The participants in our study also favored low LoD diagrams because they were perceived as easier to read. Although the participants expressed a preference for low LoD diagrams, no statistically significant conclusions can be drawn from the set of experiments. One important finding attained from this family of experiments was that the participants minimized or avoided the use of UML diagrams, regardless of their LoD. This effect was probably the result of using small software systems from well-known domains as experimental materials.

With the growing use of UML diagrams for software architecture description and the importance of non-functional requirements evaluation at software architecture level, filling the scientific gap between architect and requirement analyst is considered to be significant. Software architects are not usually familiar with non-functional requirement analysis and are not able to analyze such requirements easily. On the other hand, non-functional requirements cannot be evaluated directly by UML diagrams. Therefore, the architect should annotate additional information of the nonfunctional requirements to software architecture description and then an executable model can be produced. These executable models can be petri nets, queuing networks, stochastic process algebra and etc. One kind of the UML diagrams that can be used to describe software architecture is component diagram. In this paper, we propose a new algorithm that enables an architect to transform a component diagram into an executable model based on different extensions of petri nets. Moreover, we show how to use this petri net model for performance evaluation and simulation and the implications of this transformation are described completely. Finally, to represent the usage of our proposed algorithm, we consider a case study as an example.

A software toolset which allows unified modelling language (UML) modellers to annotate models with performance information is described. An equivalent performance model is extracted from the UML, solved, and the results reflected back to the UML level. Used in this way, the toolset gives a high-level approach to software performance modelling where the benefits of the performance modelling process are achieved without significant additional notational burden.

In this paper we propose a component-based analytical performance model for IP-SAN. We model four key components within IP-SAN individually and they are IP network, cache, RAID and disks. We validate these component models and compose them to give an entire IP-SAN performance model. The entire IP-SAN model analyzes the performance of an IP-SAN configuration under multiple synchronous workloads by using closed queueing network model and under asynchronous workload by using open queueing network model. We also validate the entire IP-SAN performance model against a real IP-SAN system. The theoretical results are compared with the results from a real IP-SAN using a variety of synthetic workloads. These experiments prove that the component-based method is an appropriate way to build performance model for a complex storage system. To our knowledge, this is the first exploration into building analytical performance model for entire IP-SAN system and validating against a real system. We also identify areas for future research in the performance analysis of real IP-SAN.

Database system performance evaluation models: A survey

Queueing networks have been widely used to evaluation performance of mainframe computer systems. In contrast, few results have been reported for modern open systems, so it was not clear whether queueing networks are useful for modern systems or not. We think this situation has partly been due to lack of handy evaluation tools. This paper presents tow tools that we developed to evaluate open system performance. On is a measuring tool that is capable of accurately obtaining the service times of system resources requested by an application transaction. The other is an estimating tool which calculates various performance measures based on queueing network models. This paper also describes a case study in which the performance of a medium‐sized UNIX client–server system (up to 24 clients) is estimated using the tools and these estimates are then compared with experimental results. The estimates closely agree with the measured results and are accurate enough for practical applications. Based on this, we conclude that queueing network models are also useful for modern systems.

In this paper, we present an approach for model transformation from Queueing Network Models (QNMs) into Queueing Petri Nets (QPNs). The performance of QPNs can be analyzed using a powerful simulation engine, SimQPN, designed to exploit the knowledge and behavior of QPNs to improve the efficiency of simulation. When QNMs are transformed into QPNs, their performance can be analyzed efficiently using SimQPN. To validate our approach, we apply it to analyze the performance of several queueing network models including a model of a database system. The evaluation results show that the performance analysis of the transformed QNMs has high accuracy and low overhead. In this context, model transformation enables the performance analysis of queueing networks using different ways that can be more efficient.

Because of their structural and semantic inter-dependency, UML diagrams describing a software product must be consistent to ensure the success of the development process. This inter-diagram consistency is often not easy to ensure considering the multi-views the diagrams cover, the different levels of abstraction they encode, and the different development phases during which they are produced. In this paper, we tackle the consistency problem between the functional and dynamic views in behavioral diagrams of software. We propose an approach to detect and localize inter-consistency errors among UML use cases and activity diagrams. This approach is composed of two phases: measurement phase (1) and controlling phase (2). This approach is illustrated and validated through a "Restaurant management system" case study. The proposed approach will help both software designers/developers and quality assurance/testing engineers identifying and localizing the causes of software errors at early phases (specification and design).

Software performance models from system scenarios

Performance is one of the key features of parallel and distributed computing systems. Therefore, in the past a significant research effort was invested in the development of approaches for performance modeling and prediction of parallel and distributed computing systems. In this paper we identify the trends, contributions, and drawbacks of the state of the art approaches. We describe a wide range of the performance modeling approaches that spans from the high-level mathematical modeling to the detailed instruction-level simulation. For each approach we describe how the program and machine are modeled and estimate the model development and evaluation effort, the efficiency, and the accuracy. Furthermore, we present an overall evaluation of the presented approaches

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.

In this paper we describe our experience in performance evaluation of CMP-based VoIP SPS (signaling parse system). We also present a performance model of the system using GI/G/m-FCFS multi-class open QNs (queuing networks). And deal with approximate performance analysis of open non-product-form QNs, based on the method of decomposition. Our approach predicts the major performance evaluation parameters of the system under the workloads and also identifies bottlenecks in the system. Performance results are inserted back into the QN model as initial values associated to the relevant model elements. The theoretical estimates are shown to be in excellent consistence with testing results. It shows the effectiveness of the proposed model. This work explores performance issues of CMP-based applications by means of performance modeling. In this way we may get an immediate feedback on the system performances. The use of QN model allows us to achieve better multi-core application performance.