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.

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.

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.

There is an increasing demand for the multi-agent systems (MAS) in the automation of manufacturing systems. However, similar to other distributed systems, autonomous agents' interaction in the automated manufacturing systems (AMS) can potentially lead to runtime behavioral failures including deadlock. Deadlocks can cause major financial consequences by negatively affecting the production cost and time. Therefore, a multi-agent manufacturing system should be monitored against the unwanted emergent behaviors such as deadlocks. In this paper, we propose a monitoring technique for deadlock detection in multi-agent manufacturing system based on the MAS design models. In this technique, the MAS is instrumented with a dedicated communication protocol to use the potential deadlock information derived from the design models to propagate deadlock detection query messages. The technique is able to reduce the message communication overhead among the agents by limiting the number of agents that the deadlock detection query messages should be initiated to.

The increasing demand for multi-agent systems (MAS) in the software industry has led to development of several agent oriented software engineering (AOSE) methodologies. The autonomous agents' interaction in a dynamic software environment can potentially lead to runtime behavioral failures such as deadlock. Therefore, the MAS environment should be tested and monitored against the unwanted emergent behaviors. The AOSE methodologies usually do not cover monitoring and testing. On the other hand model-based software development practices such as the Unified Modeling Languages (UML) are commonly used in practice and are equipped with a rich set of model based testing and monitoring tools. In this paper, we propose a conversion tool to help MAS engineers use UML-based monitoring and testing tools to test and monitor MAS design and analysis artifacts created by multi-agent software engineering (MaSE) as one of the most powerful and famous AOSE methodologies.