The authors previously showed that a complex layered performance model could be simplified by aggregating the contributions of subsystems, following a few simple principles which give good accuracy in many cases. The question of which subsystems to merge in layered performance models is further examined here, leading to identifying groups of subsystems (corresponding to "tasks" in layered queuing models) which can be safely aggregated. The grouping begins by identifying tasks which should be preserved, not aggregated, including those which are (or might become) bottlenecks. Then the groups are defined by their relationship to these preserved tasks. Aggregation by groups provides adequate accuracy in the vast majority of cases examined.

In Model Driven Engineering, the relationship between a source and target model can be maintained, when the source model undergoes changes, by a coupled transformation, whereby changes applied to the source model are incrementally propagated to the target model.Cross-model traceability links are key to applying the correct changes to the target model.The coupled transformation considered in this paper propagates changes to a Layered Queueing Network (LQN) performance model (originally derived from a UML design model of a SOA system) as an effect of applying design patterns to the SOA model.A special problem arises because of differences in the level of abstraction between UML and LQN (i.e. a performance model element may represent a set of many design model elements).This paper bridges the abstraction gap between models by proposing traceability links that use new collection types (not defined in the source metamodel) to represent complex source model elements, which are then mapped to simple target model elements.

Service Oriented Architecture (SOA) patterns can be applied to improve different qualities of SOA designs.The performance impact of a pattern (improvement or degradation) may affect its use, so we assess its impact by automatically generated performance models for the original design and for each candidate pattern and pattern variation.This paper proposes a technique to incrementally propagate the changes from the software to the performance model.The technique formally records the refactoring of the design model when applying a pattern, and uses this record to generate a coupled transformation of the performance model.The SOA design is modeled in UML extended with two profiles, SoaML and MARTE; the patterns are specified using Role Based Modeling and the performance model is expressed in Layered Queuing Networks.Application of the process, and pattern performance exploration, is demonstrated on a case study.

The problem of interpreting the results of performance analysis is quite critical, mostly because the analysis results (i.e. mean values, variances, and probability distributions) are hard to transform into feedback for software engineers that allows to remove performance problems. Approaches aimed at identifying and removing the causes of poor performance in software systems commonly fall in two categories: (i) bottleneck analysis, aimed at identifying overloaded software components and/or hardware resources that affect the whole system performance, and (ii) performance antipatterns, aimed at detecting and removing common design mistakes that notably induce performance degradation.

The compatibility verification between interacting components and the conformance verification of their internal behavior with the corresponding ports protocol behavior are important steps for the early identification of unexpected messages between components. The behavior models used for verification include erroneous behavior along with normal behavior, in order to ensure greater accuracy in reliability and availability analysis. We use our Component Erroneous Behavior Aspect Modeling (CeBAM) approach introduced in previous work, which applies aspect-oriented modeling for adding erroneous behavior to UML state machines representing normal behavior. In this paper we present transformation rules for deriving Stochastic Reward Net (SRN) from CeBAM representations. The first step is to generate SRN for individual component behavior in order to check the conformance between component internal behavior and their ports protocol behavior. Subsequently, we compose the generated SRNs models of the connected components to verify their compatibility. We show how to identify conformance and compatibility issues during the construction and composition of components SRN model by analyzing SRN properties (e.g., deadlocks). We illustrate the proposed verification approach through a case study modeled according to CeBAM.

Design patterns for Service Oriented Architecture (SOA) provide solutions to architectural, design and implementation problems, involving software models in different layers of a SOA design. For performance analysis, a performance model can be generated from the SOA design and used to predict its performance. The impact of the design patterns is also reflected in the performance model. It is helpful to be able to trace the causality from the design pattern to its predicted performance impact. This paper describes a technique for automatically refactoring a SOA design model by applying a design pattern and for propagating the incremental changes to its LQN performance model. A SOA design model is expressed in UML extended with two standard profiles: SoaML for expressing SOA solutions and MARTE for performance annotations. The SOA design pattern is specified using a Role Based Modeling Language (RBML) and their application is automated using QVT-O. Automated incremental transformations are explored and evaluated for effectiveness on a case study example.

Context-aware systems often use rule-based reasoning engines for decision making without involving explicit interaction with the user. While rule-based systems excel in filtering out unsuitable solutions based on clear criteria, it is difficult to rank suitable solutions based on vague, qualitative criteria with a rule-based approach. Moreover, the description of such systems is typically ad-hoc without well-defined modeling tasks. CARGO (Context-Aware Reasoning using Goal-Orientation) aims to address these problems by combining rule-based and goal-based reasoning as well as scenario-based modeling to provide a more comprehensive way to define context-aware systems and to process contextual information. This demo presents CARGO, a modeling, simulation, and execution environment for context-aware systems built on existing tool support for the User Requirements Notation.

A Software Product Line (SPL) is a set of similar software systems that share a common set of features. Instead of building each product from scratch, SPL development takes advantage of the reusability of the core assets shared among the SPL members. In this work, we integrate performance analysis in the early phases of SPL development process, applying the same reusability concept to the performance annotations. Instead of annotating from scratch the UML model of every derived product, we propose to annotate the SPL model once with generic performance annotations. After deriving the model of a product from the family model by an automatic transformation, the generic performance annotations need to be bound to concrete product-specific values provided by the developer. Dealing manually with a large number of performance annotations, by asking the developer to inspect every diagram in the generated model and to extract these annotations is an error-prone process. In this paper we propose to automate the collection of all generic parameters from the product model and to present them to the developer in a user-friendly format (e.g., a spreadsheet per diagram, indicating each generic parameter together with guiding information that helps the user in providing concrete binding values). There are two kinds of generic parametric annotations handled by our approach: product-specific (corresponding to the set of features selected for the product) and platform-specific (such as device choices, network connections, middleware, and runtime environment). The following model transformations for (a) generating a product model with generic annotations from the SPL model, (b) building the spreadsheet with generic parameters and guiding information, and (c) performing the actual binding are all realized in the Atlas Transformation Language (ATL).

We propose to integrate performance analysis in the early phases of the model-driven development process for Software Product Lines (SPL). We start with a multi-view UML model of the core family assets representing the commonality and variability between different products, which we call the SPL model. We add another perspective to the SPL model, annotating it with generic performance specifications expressed in the standard UML profile MARTE, recently adopted by OMG. The runtime performance of a product is affected by factors contained in the UML model of the product (derived from the SPL model), but also by external factors depending on the implementation and execution environments. The external factors not contained in the SPL model need to be eventually represented in the performance model. In order to do so, we propose to represent the variability space of different possible implementation and execution environments through a so called "performance completion (PC) feature model". These PC features are mapped to MARTE performance-related stereotypes and attributes attached to the SPL model elements. A first model transformation realized in the Atlas Transformation Language (ATL) derives the UML model of a specific product with concrete MARTE annotations from the SPL model. A second transformation generates a Layered Queueing Network (LQN) performance model for the given product by applying an existing transformation named PUMA, developed in previous work. The proposed technique is illustrated with an e-commerce case study. A LQN model is derived for a product and the impact of different levels of secure communication channels on its performance is analyzed by using the LQN model.

Patterns employed for the development of a service oriented system may affect its non-functional properties, including performance. Service Oriented Architecture (SOA) design patterns provide generic solutions for many architectural, design and implementation problems, and any pattern may have an impact on performance, either positive or negative. This research considers how to characterize the performance impact of a SOA design pattern, which includes characterizing some aspects of the design and usage environment as a whole (for example, the scale of the workload and the availability of concurrent platforms for the eventual deployment). The approach uses performance models to characterize the application and the impact of the pattern on it. The planned approach exploits the context of model driven engineering (MDE) to give rapid feedback to developers about the potential impact of a pattern. Model transformations are used to generate the performance model, and to propagate the effect of applying a SOA design pattern to the performance model. The approach is sketched here with a preliminary case study, demonstrating its feasibility.

The Internet has evolved into a multi-service infrastructure for the telecom and computer industries. Internet services are affected by congestions caused by the operations of Internet routing protocols. We propose a novel information service that guides the operations of Internet routing protocols to avoid such congestion. The information service maintains information about utilization of inter-domain links. The proposed service minimizes the maximum of utilization of Internet links by selecting potential network domains to be traversed by Internet services. Simulation results show better balanced distribution of traffic workloads among network links using the proposed service. We show that the proposed service scales well as network size grows. This comes at the cost of greater control messaging overhead which suggests using the proposed service with long-lived and higher bandwidth services

A reengineered approach to the early prediction of preterm birth is presented as a complimentary technique to the current procedure of using costly and invasive clinical testing on high-risk maternal populations. Artificial neural networks (ANNs) are employed as a screening tool for preterm birth on a heterogeneous maternal population; risk estimations use obstetrical variables available to physicians before 23 weeks gestation. The objective was to assess if ANNs have a potential use in obstetrical outcome estimations in low-risk maternal populations. The back-propagation feedforward ANN was trained and tested on cases with eight input variables describing the patient's obstetrical history; the output variables were: 1) preterm birth; 2) high-risk preterm birth; and 3) a refined high-risk preterm birth outcome excluding all cases where resuscitation was delivered in the form of free flow oxygen. Artificial training sets were created to increase the distribution of the underrepresented class to 20%. Training on the refined high-risk preterm birth model increased the network's sensitivity to 54.8%, compared to just over 20% for the nonartificially distributed preterm birth model.

This paper has three contributions: 1) to evaluate how changing the a priori distribution of the training set affects the performance of a back-propagation feed-forward artificial neural network (ANN) in predicting PreTerm Birth (PTB) for obstetrical patients, 2) to assess the effectiveness of the weight elimination cost function in improving the ANN's classification of PTB and in identifying a new minimal dataset, and (3) to determine if PTB can be predicted outside of clinical trial situations using data readily available to the physician during obstetrical care. The ANN was trained and tested on cases with 8 input variables describing the patient's obstetrical history; the output variable was PTB before 37 weeks gestation. To observe the impact of training with a higher-than-normal prevalence, an artificial training set with a PTB rate of 23% was created. Networks trained on higher-than-normal prevalence achieved higher sensitivity rates and greater C-index values, at the cost of slightly lower specificity and correct classification rates.

The paper presents a novel scalable end-to-end routing protocol, HDRA, which combines the characteristics of both hierarchical and distributed routing protocols. HDRA selects a number of network domains to be traversed by a requested route. Only the selected domains are flooded with probing messages. This enables the deployment of flooding-based routing algorithms in large networks. The protocol has smaller setup time because it performs no central routing computation. HDRA does not require global state maintenance. However, it has higher message overheads when compared to PNNI (private network-network interface).

Network service provisioning involves the control of network resources through signaling, routing and management protocols that achieve quality of service and traffic engineering objectives. Network service providers are typically faced with scalability problems due to the explosion in network size and demand. In this paper we propose a new hierarchical distributed protocol for the provisioning of MPLS-based tunnels. The protocol encapsulates the required signaling and routing. The protocol alleviates the scalability problem through extending the current two-tier architecture of the Internet to a multi-level hierarchical one. It enables mechanisms for quality of service, and intra- and inter-domain traffic engineering. Analytical analysis and simulation results show that the protocol exploits parallelism in routing computation to reduce the setup time of an MPLS path. This comes at the expense of an increased message complexity relative to other hierarchical protocols.

One of the goals of network service providers (SP) is to provision efficiently value-added networking services to their end users. The services may have different duration, connectivity, and quality of service (QoS) requirements. An SP meets such requirements by exploiting various routing and management mechanisms for edge and core networks. We focus on network services that require the establishment of virtual networks (VNs). This paper considers a VN creation architecture based on multi-protocol label switching (MPLS). MPLS is one approach for implementing VNs that enables programmability for network infrastructure and hence the creation of value-added services. An analytic performance model is developed to assess the scalability of the architecture as the underlying physical network infrastructure evolves. The model we present describes only coarse features of the architecture, yet offers insights regarding its performance and scalability. In particular we assess the impact of a flat versus hierarchical MPLS mechanism on the response time of service creation.

In this paper, we describe an experimental performance-driven animation system for an avatar face using model-based video coding and audio-track driven lip animation.

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. The proposed approach is applied to a telecommunication product for which an LQN model is built and analyzed. The analysis shows how the performance bottleneck is moving from component to component (hardware or software) under different loads and configurations and exposes some weaknesses in the original software architecture, which prevent the system from using the available processing power at full capacity due to excessive serialization.

This paper describes a flexible, coherent framework for organizing and operating a robotic assembly cell that has multiple robots. This framework, which is based on the concept of an agent as understood in the field of multiagent systems, supports the task-level programming and scheduling of assembly operations. In this framework, we decompose an assembly operation into two distinct phases: part fetching and part assembling. The agents of the cell correspond to these two assembly phases plus an agent to manage the shared physical space of the cell and an agent to properly schedule the assembly operations. The simulations and experiments with this framework are presented and discussed.

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

Software bottlenecks are performance constraints caused by slow execution of a software task, in typical client-server systems a client task must wait in a blocked state for the server task to respond to its requests, so a saturated server will slow down all its clients. A rendezvous network generalizes this relationship to multiple layers of servers with send-and-wait interactions (rendezvous), a two-phase model of task behavior, and to a unified model for hardware and software contention. Software bottlenecks have different symptoms, different behavior when the system is altered, and a different cure from the conventional bottlenecks seen in queueing network models of computer systems, caused by hardware limits. The differences are due to the "push-back" effect of the rendezvous, which spreads the saturation of a server to its clients. The paper describes software bottlenecks by examples, gives a definition, shows how they can be located and alleviated, and gives a method for estimating the performance benefit to be obtained. Ultimately, if all the software bottlenecks can be removed, the performance limit will be due to a conventional hardware bottleneck.>

Stochastic Rendezvous Networks (SRVNs) are performance models for multitasking parallel software with intertask communication via rendezvous introduced in [1], which are very appropriate to model client-server systems. SRVNs differ from Queueing Networks (QNs) in two ways: nodes act as both clients and servers (allowing for nested service), and servers have two distinct phases of service—the first one “in RV” with the client, and the second “after RV”, executed in parallel with the client. Early work on solving SRVN models has used a kind of approximate Mean Value Analysis based on heuristic ad hoc assumptions to determine the task queue properties at the instant of RV request arrivals. Approximation are necessary since SRVN violates product form. Recently, a more rigorous approach was proposed in [2] for the solution of SRVN models, based on a special aggregation (named “Task-Directed Aggregation” TDA) of the Markov chain model describing the interference of different clients that contend for a single server with FIFO queueing discipline and different service times. The algorithm derived in [2] has the limitation that each client may require only a single class of service. In general, a software server offers a range of services with different workloads and functionalities, and a client may need more than one service. The present paper uses the TDA approach to derive an extended algorithm which allows a client to require any number of services from a server by changing randomly the request class. The new algorithm is incorporated into a decomposition method for models with any number of servers. The SRVN modelling technique is applied to a large case study of a distributed database system, giving insight into the behaviour of the system and helping to identify performance problems such as software bottle-neck.

To use queuing theory to analyze real systems such as computer communications networks, one makes assumptions that are, strictly speaking, untrue. The authors provide an exact analysis for cases with greatly relaxed assumptions. Service times can have general increasing failure rate distributions, different by class even at FIFO nodes. Routing can be arbitrary, including dependencies along the route, provided the number of visits to each node is a random variable. Only the mean service time and mean visit rates at nodes need be specified. A lower throughput bound is found which gives a minimum guaranteed throughput for each class; together with the familiar multiclass asymptotic upper bounds they give a convex feasible region in a multidimensional throughput space. A detailed analysis is given for systems with FIFO and infinite-server nodes, and the extension to processor-sharing nodes is described. The results can be reinterpreted as a set of bounds on the separate throughputs. This is equivalent to a circumscribed rectangular region called the robust box bounds.>

Stochastic rendezvous networks (SRVN) are models for the throughput of distributed programs executed concurrently and synchronously on distributed computing nodes. Server tasks respond to requests from user tasks and execute in a two-phase pattern (in-rendezvous phase, then postrendezvous phase), and may themselves act as user tasks to further servers, to any depth. The authors extend the model to permit the execution time and the occurrence of nested rendezvous calls to depend on the identity of the calling user task. An iterative approximation method is developed, and compared to exact throughput calculations found with timed Petri nets. The approximation has errors of a few percent in most cases, and executes very much faster than the Petri-net calculation.>