C. Murray Woodside

The stochastic rendezvous network model for performance of synchronous client-server-like distributed software

Distributed or parallel software with synchronous communication via rendezvous is found in client-server systems and in proposed open distributed systems, in implementation environments such as Ada, V, remote procedure call systems, in transputer systems, and in specification techniques such as CSP, CCS and LOTOS. The delays induced by rendezvous can cause serious performance problems, which are not easy to estimate using conventional models which focus on hardware contention, or on a restricted view of the parallelism which ignores implementation constraints. Stochastic rendezvous networks are queueing networks of a new type which have been proposed as a modelling framework for these systems. They incorporate the two key phenomena of included service and a second phase of service. This paper extends the model to also incorporate different services or entries associated with each task. Approximations to arrival-instant probabilities are employed with a mean-value analysis framework, to give approximate performance estimates. The method has been applied to moderately large industrial software systems. >

The Future of Software Performance Engineering

Performance is a pervasive quality of software systems; everything affects it, from the software itself to all underlying layers, such as operating system, middleware, hardware, communication networks, etc. Software Performance Engineering encompasses efforts to describe and improve performance, with two distinct approaches: an early-cycle predictive model-based approach, and a late-cycle measurement-based approach. Current progress and future trends within these two approaches are described, with a tendency (and a need) for them to converge, in order to cover the entire development cycle.

A toolset for performance engineering and software design of client-server systems

Abstract TimeBench/SRVN is a prototype toolset for computer-aided design and performance analysis of software, with an emphasis on distributed client-server systems. The performance behaviour of such systems may defy intuition because it involves factors in the software design (such as the partitioning of the functionality and the frequency with which requests will be made to each server) and in the configuration of the distributed system (including replication of services, the distribution of data, and the speed of network access). The novelty of the tool consists in providing support both for developing design specifications and also for performance analysis. The integrated approach avoids the semantic gap between a designers domain and the performance modeling domain, and assists the designer to explore factors that impact the performance of a design. The performance models are based on the Stochastic Rendezvous Network (SRVN) formalism for client-server systems with synchronous service requests. The distinctive features of SRVNs are nested services (since servers can also act as clients to other servers) and the existence of two or more phases of service (the first executed while the client is blocked, and the others executed in parallel with the client). TimeBench/SRVN is intended as a demonstration of the concept of an integrated designer/performance interface, and as a research environment for fast analytic solvers for the models. Besides a simulation solver, it offers three approximate analytic solvers based on recent research, a Markovian solver, a technique for finding bounds on the throughput without too many assumptions, and a tool for rapidly exploring the space of possible parameter values.

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.

Throughput calculation for basic stochastic rendezvous networks

Abstract Distributed computer programs using rendezvous for intertask communication have performance effects due to tasks waiting for rendezvous. Tasks have a dual nature as being both servers of requests and customers in making requests of other tasks. In a previous paper, such tasks have been termed ‘active servers’. In this paper, a distributed program is modelled as a stochastic network of tasks related by their rendezvous requests. For purposes of defining the throughput, the tasks are assumed to have maximum concurrency as if each task were executed on its own processor. For small networks, exact throughput values can be found by translating them into equivalent times Petri nets, and the translation procedure is given as an algorithm. An approximation suitable for larger networks, which was found to be accurate to within a few percent in most of the cases tested, is also given.

Software Performance Models from System Scenarios in Use Case Maps

Software performance concerns begin at the very outset of a new project. The first definition of a software system may be in the form of Use Cases, which may be elaborated as scenarios: this work creates performance models from scenarios. The Use Case Maps notation captures the causal flow of intended execution in terms of responsibilities, which may be allocated to components, and which are annotated with expected resource demands. The SPT algorithm was developed to transform scenario models into performance models. The UCM2LQN tool implements SPT and converts UCM scenario models to layered queueing performance models, allowing rapid evaluation of an evolving scenario definition. The same reasoning can be applied to other scenario models such as Message Sequence Charts, UML Activity Graphs (or Collaboration Diagrams, or Sequence Diagrams), but UCMs are particularly powerful, in that they can combine interacting scenarios and show scenario interactions. Thus a solution for UCMs can be applied to multiple scenarios defined with other notations.

Hierarchical model-based autonomic control of software systems

Various control algorithms are used in autonomic control to maintain Quality of Service (QoS) and Service Level Agreements (SLAs). Controllers are all based to some extent on models of the relationship between resources, QoS measures, and the workload imposed by the environment. This work discusses the range of algorithms with an emphasis on richer and more powerful models to describe non-linear performance relationships, and strong interactions among the system resources. A hierarchical framework is described which accommodates different scopes and timescales of control actions, and different control algorithms. The control algorithms and architectures can be considered in three stages: tuning, load balancing and provisioning. Different situations warrant different solutions, so this work shows how different control algorithms and architectures at the three stages can be combined to fit into different autonomic environments to meet QoS and SLAs across a large variety of workloads.

Performance modeling and prediction of enterprise JavaBeans with layered queuing network templates

Component technologies, such as Enterprise Java Beans (EJB) and .NET, are used in enterprise servers with requirements for high performance and scalability. This work considers performance prediction from the design of an EJB system, based on the modular structure of an application server and the application components. It uses layered queueing models, which are naturally structured around the software components. This paper describes a framework for constructing such models, based on layered queue templates for EJBs, and for their inclusion in the server. The resulting model is calibrated and validated by comparison with an actual system.

Trace-based load characterization for generating performance software models

Performance models of software designs can give early warnings of problems such as resource saturation or excessive delays. However models are seldom used because of the considerable effort needed to construct them. The ANGIOTRACE/sup TM/ was developed to gather the necessary information from an executable design and develop a model in an automated fashion. It applies to distributed and concurrent software with synchronous (send-reply or RPC) communications, developing a layered queuing network model. The trace-based load characterization (TLC) technique presented here extends the ANGIOTRACE/sup TM/ to handle software with both synchronous and asynchronous interactions. TLC also detects interactions which are effectively synchronous or partly-synchronous (forwarding) but are built up from asynchronous messages. These patterns occur in telephony software and in other systems. The TLC technique can be applied throughout the software life-cycle, even after deployment.

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.