This paper proposes a higher-order transformation (HOT) for realizing Incremental Change Propagation (ICP) from software UML models extended with performance annotations to performance Layered Queueing Network (LQN) models. Such a transformation is necessary for integrating quantitative performance analysis into the model-driven engineering of real-time systems. The entire process starts by automatically generating an LQN and a trace model from a UML model extended with MARTE annotations, with a batch Epsilon ETL transformation previously developed by the authors. The textual ETL transformation definition is translated to an ETL transformation model using the Epsilon Haetae tool. The ETL transformation model conforms to the ETL metamodel and represents the mapping between source and target models at a high level of abstraction. We use it to answer the question: what needs to be changed in the target model upon detecting changes in the source model? During the development process, when the UML model evolves, we detect such changes with the Eclipse EMF Compare tool, then incrementally propagate them to the LQN model to keep it synchronized. The extended approach is illustrated by applying it to an e-commerce model from the literature. The execution time of ICP is measured and compared to the traditional batch transformation.

Performance models of server systems, based on layered queues, may be very complex. This is particularly true for cloud-based systems based on microservices, which may have hundreds of distinct components, and for models derived by automated data analysis. Often only a few of these many components determine the system performance, and a smaller simplified model is all that is needed. To assist an analyst, this work describes a focused model that includes the important components (the focus ) and aggregates the rest in groups, called dependency groups. The method Focus-based Simplification with Preservation of Tasks described here fills an important gap in a previous method by the same authors. The use of focused models for sensitivity predictions is evaluated empirically in the article on a large set of randomly generated models. It is found that the accuracy depends on a “saturation ratio” ( SR ) between the highest utilization value in the model and the highest value of a component excluded from the focus; evidence suggests that SR must be at least 2 and must be larger to evaluate larger model changes. This dependency was captured in an “Accurate Sensitivity Hypothesis” based on SR, which can be used to indicate trustable sensitivity results.

The modeling of system non-functional properties is a broad field. Among these properties, dependability is an important one for real-time and embedded systems. On the other hand, UML offers the profiling mechanism to address specific modeling domains. In particular, the DAM (dependability analysis and modeling) profile provides a modeling framework for dependability in the model-driven paradigm. This work is for practitioners to understand the basics of dependability modeling, using DAM. In this sense, the paper digests the literature to understand the concept of the UML profile, the MARTE profile and to obtain a practical guide on dependability modeling using DAM. The modeling approach is illustrated through a case study taken from the literature.

This paper discusses the progress made so far and future challenges in integrating the analysis of multiple Non-Functional Properties (NFP) (such as performance, schedulability, reliability, availability, scalability, security, safety, and maintainability) into the Model-Driven Engineering (MDE) process. The goal is to guide the design choices from an early stage and to ensure that the system under construction will meet its non-functional requirements. The evaluation of the NFPs considered in this paper uses various kinds of NFP analysis models (also known as quality models) based on existent formalisms and tools developed over the years. Examples are queueing networks, stochastic Petri nets, stochastic process algebras, Markov chains, fault trees, probabilistic time automata, etc. In the MDE context, these models are automatically derived by model transformations from the software models built for development. Developing software systems that exhibit a good trade-off between multiple NFPs is difficult because the design of the software under construction and its underlying platforms have a large number of degrees of freedom spanning a very large discontinuous design space, which cannot be exhaustively explored. Another challenge in balancing the NFPs of a system under construction is due to the fact that some NFPs are conflicting—when one gets better the other gets worse—so an appropriate software process is needed to evaluate and balance all the non-functional requirements. The integration approach discussed in this paper is based on an ecosystem of inter-related heterogeneous modeling artifacts intended to support the following features: feedback of analysis results, consistent co-evolution of the software and analysis models, cross-model traceability, incremental propagation of changes across models, (semi)automated software process steps, and metaheuristics for reducing the design space size to be explored.

Virtual Private Networks (VPNs) provide an inexpensive and scalable solution for the transfer of sensitive data through an unsecured network by creating a “tunnel” from sender to receiver. One of the most popular protocols for creating VPNs is the IPSec protocol suite, where secure key negotiation and exchange must be done first, before any encryption of data can take place. This article examines the latest VPN technologies focusing on one of the factors that have an effect on VPN performance and scalability, namely security key management. A new aggregation key exchange approach compatible to current technologies is proposed for improving the key exchange performance in large VPN systems. The new approach represents a trade-off between performance and security. A simulation model based on the Network Simulator (ns) was developed for this new approach. Simulation experiments for various scenarios were conducted and their results were compared to the traditional key exchange scheme.

Safety-Critical Systems (SCS) must operate inside of their prescribed specifications, otherwise they can cause harm to the user(s) and/or the environment. These systems are used in a multitude of domains, such as aerospace, automotive, railway, and healthcare. Safety Analysis (SA) is performed on SCS to ensure that they are safe enough to be operational. In this paper, we propose a pattern-based transformation of SysML system models annotated with failure information using MARTE and DAM profiles into static combinatorial Fault Tree (FT) target models. A set of behavioral and structural failure patterns are identified and mapped to FT constructs. Based on the mappings, two transformation algorithms are developed: one generates component fault trees (CFT) and the other system fault trees (SFT). The proposed method is applied to a case study, illustrating how the failure patterns are guiding the transformation that synthesizes the target FT models.

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.

Safety Critical Systems (SCS) are those systems that may cause harm to the user(s) and/or the environment if operating outside of their prescribed specifications. Such systems are used in a wide variety of domains, such as aerospace, automotive, railway transportation and healthcare. In this paper, we propose an approach to integrate safety analysis of SCSs within the Model Driven Engineering (MDE) system development process. The approach is based on model transformation and uses standard well-known techniques and open source tools for the modeling and analysis of SCSs. More specifically, the system modeled with the OMG’s standard systems modeling language, SysML, is automatically transformed in Fault Tree (FT) models, that can be analyzed with existing FT tools. The proposed model transformation takes place in two steps: a) generate FTs at the component level, in order to tackle complexity and enable reuse; and b) generate system level FTs by composing the components and their FTs. The approach is illustrated by applying it to a simplified industry-inspired case study.

Model-Driven Engineering (MDE) 1 enables automatic generation of performance models from software design models by model transformations. The performance models thus obtained are used for performance analysis of software under development. In previous work, we have used a specialized model transformation language, Epsilon ETL, to generate Layered Queueing Network (LQN) performance models from UML software models annotated with the MARTE profile. When the UML model evolves during the development process, the traditional solution for keeping the performance model synchronized is to rerun the entire transformation each time the software model changes. Such a solution is expensive, especially in large-scale models. In this paper, we propose an incremental change propagation (ICP) approach to propagate changes from the UML+MARTE software model to the corresponding LQN model. The entire process starts by automatically generating an LQN model with the previously developed Epsilon ETL transformation. During the development process, when the UML model evolves, we detect the changes with the Eclipse EMF Compare tool, then incrementally propagate them to the LQN model to keep it synchronized. Note that Epsilon does not support incremental model transformation. The proposed ICP is implemented with the Epsilon Object Language (EOL) and it is evaluated by applying it to a set of case studies.

Motivated by the problem of detecting software performance anti-patterns in data-intensive applications (DIAs), we present a tool, Tulsa, for transforming software architecture models specified through UML into Layered Queueing Networks (LQNs), which are analytical performance models used to capture contention across multiple software layers. In particular, we generalize an existing transformation based on the Epsilon framework to generate LQNs from UML models annotated with the DICE profile, which extends UML to modelling DIAs based on technologies such as Apache Storm.

This paper proposes an approach for performance analysis roundtrip in the context of model-driven engineering (MDE) of real-time distributed and embedded systems. The starting point is a UML software model with MARTE performance annotations, such as performance requirements and resource demands. The source software model is automatically transformed into a Layered Queueing Network (LQN) performance model. We developed the transformation with Epsilon, a family of languages for model-to-model transformation, model validation and model management. Using specialized languages helped us create a more compact transformation, easier to understand and maintain than transformations developed with general purpose languages, such as Java. Beside the performance model, the transformation also generates a traceability model containing trace links between mapped elements of the software and performance model. After solving the performance model with an existing solver, the performance results are fed back to the software model by following in reverse the cross-model trace links. The software developers can see the performance results as MARTE stereotype attributes, using a standard UML editor. The approach is illustrated by applying it to an e-commerce application.

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.

This paper is part of a larger research project aiming to integrate dependability analysis in the early phases of the software development process, by generating and analyzing Stochastic Reward Net (SRN) models from UML software models. The paper is focused on adding fault tolerance to software designs by using Aspect-Oriented Modeling. More specifically, single-version fault tolerance tactics are modeled as generic reusable aspects annotated with dependability attributes. The paper describes how the generic aspects are instantiated, bound to the context and composed with the original UML software model. Since an SRN analysis model is generated from the UML model, the paper discusses what kind of transformation rules are necessary for translating fault tolerance tactics from UML to SRN, giving as an example the transformation rule for checkpoint synchronization. A case study illustrates the proposed approach.

The amount of detail to include in a performance model is usually regarded as a judgment to be made by an expert modeler and the question “how much detail is necessary?” is seldom asked and is difficult to answer. However, if a simpler model gives essentially the same performance predictions, it may be more useful than a detailed model. It may solve more quickly, for instance, and may be easier to understand. Or a model for a complex sub-system such as a database server may be usefully simplified so it can be included in larger system models. This paper describes an aggregation process for layered queuing models that reduces the number of queues (called tasks and processors, in layered models) while preserving the total execution demand and the bottleneck characteristics of the detailed model. It demonstrates that this process can greatly reduce the number of tasks and processors with a very small relative error.

Service Oriented Architecture (SOA) patterns can be applied to improve different qualities of SOA designs. The performance impact of a pattern (improvement or degra- dation) 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.

A software design often does not describe the software infrastructure it will need to run, but a performance analysis must account for its effects. “Performance completions” represent the infrastructure and must be incorporated in the application performance model. This paper considers completions for middleware. It proposes a unified framework for describing all kinds of middleware in the Layered Queuing Network (LQN) model, based on a generic template and elaborations for middleware features. The template is applied to several common request-reply middleware systems. A process is given for building a new middleware completion model and for incorporating it into a LQN model.

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. In this paper, we look for possible synergies between these two categories of approaches in order to empower the performance investigation capabilities. In particular, we aim at showing that the approach combination allows to provide software engineers with broader sets of alternative solutions leading to better performance results. We have explored this research direction in the context of Layered Queueing Network models, and we have considered a case study in the e-commerce domain. After comparing the results achievable with each approach separately, we quantitatively show the benefits of merging bottleneck analysis and performance antipatterns.

In cloud computing, an "edge cloud" may be introduced close to some of the end users, to give faster service for very demanding applications. The transactions that require heavy processing capacity and longer processing times are seen as more suitable to be carried out at the "core" cloud. Parts in the core and edge may then have to communicate, introducing associated network latencies. An application should be deployed across edge and core with the aim to reduce the overall effect of network latencies, in order to meet end user response time goals. In this paper, we use a Layered Queueing Network performance model to explore the impact of network latency and some possible deployment choices on the responsiveness of an application called HCAT (Home Care Aides Technology). The evaluations show that the use of the edge cloud may cause performance degradation, rather than gain, for some kinds of applications.