Lucia Kapova

Evaluating maintainability with code metrics for model-to-model transformations

Using model-to-model transformations to generate analysis models or code from architecture models is sought to promote compliance and reuse of components. The maintainability of transformations is influenced by various characteristics - as with every programming language artifact. Code metrics are often used to estimate code maintainability. However, most of the established metrics do not apply to declarative transformation languages (such as QVT Relations) since they focus on imperative (e.g. object-oriented) coding styles. One way to characterize the maintainability of programs are code metrics. However, the vast majority of these metrics focus on imperative (e.g., object-oriented) coding styles and thus cannot be reused as-is for transformations written in declarative languages. In this paper we propose an initial set of quality metrics to evaluate transformations written in the declarative QVT Relations language. We apply the presented set of metrics to several reference transformations to demonstrate how to judge transformation maintainability based on our metrics.

Statistical inference of software performance models for parametric performance completions

Software performance engineering (SPE) enables software architects to ensure high performance standards for their applications. However, applying SPE in practice is still challenging. Most enterprise applications include a large software basis, such as middleware and legacy systems. In many cases, the software basis is the determining factor of the system’s overall timing behavior, throughput, and resource utilization. To capture these influences on the overall system’s performance, established performance prediction methods (model-based and analytical) rely on models that describe the performance-relevant aspects of the system under study. Creating such models requires detailed knowledge on the system’s structure and behavior that, in most cases, is not available. In this paper, we abstract from the internal structure of the system under study. We focus on message-oriented middleware (MOM) and analyze the dependency between the MOM’s usage and its performance. We use statistical inference to conclude these dependencies from observations. For ActiveMQ 5.3, the resulting functions predict the performance with a relative mean square error 0.1.

Automated Feature Model-Based Generation of Refinement Transformations

Model-driven application engineering builds on the concept of model transformations. To weave additional refinement parts into an application model, so-called refinement transformations are used. In many cases these refinement parts are highly variable and configurable. Such a configuration could depend on application specific features. Today, application developers need to define refinement transformations manually, including all possible configuration combinations. Due to the high number of possible initial requirements such a development method is costly and means significant effort. Therefore configurable refinements should be embedded in an overall model-driven application development process. Currently there is a lack of automated support for integrating these configuration decisions into the development process of refinement transformations. In this paper, we introduce a novel approach for automated feature model-based generation of refinement transformations. To express application features, we consider configurations specified by extended feature diagrams. In addition, we provide a running example giving insight into the application of the presented approach.

State dependence in performance evaluation of component-based software systems

Integrating rising variability of software systems in performance prediction models is crucial to allow widespread industrial use of performance prediction. One of such variabilities is the dependency of system performance on the context and history-dependent internal state of the system (or its components). The questions that rise for current prediction models are (i) how to include the state properties in a prediction model, and (ii) how to balance the expressiveness and complexity of created models. Only a few performance prediction approaches deal with modelling states in component-based systems. Currently, there is neither a consensus in the definition, nor in the method to include the state in prediction models. For these reasons, we have conducted a state-of-the-art survey of existing approaches addressing their expressiveness to model stateful components. Based on the results, we introduce a classification scheme and present the state-defining and state-dependent model parameters. We extend the Palladio Component Model (PCM), a model-based performance prediction approach, with state-modelling capabilities, and study the performance impact of modelled state. A practical influences of the internal state on software performance is evaluated on a realistic case study.

Application of advanced model-driven techniques in performance engineering

Software performance engineering supports software architects to identify potential performance problems, such as bottlenecks, in their software systems during the design phase. In such early stages of the software life-cycle, only little information is available about the systems implementation and execution environment. However, these details are crucial for accurate performance predictions. Performance completions close the gap between available high-level models and required low-level details. Using model-driven technologies, transformations can include details of the implementation and execution environment into abstract performance models. Existing approaches do not consider the relation of actual implementations and performance models used for prediction. Furthermore, they neglect the broad variety of implementations and middleware platforms, possible configurations, and varying usage scenarios. To allow more accurate performance predictions, we extend classical performance engineering by automated model refinements based on a library of reusable performance completions. We use model-driven techniques, more specifically higher-order transformations, to implement and automatically integrate performance completions in the context of the Palladio Component Model. With our tool set, software architects can model an application in a language specific to their domain. They can annotate the model elements that require further refinement. Higher-order transformations then apply the selected completion with its configuration. In a case study of a middleware configuration, we illustrate the benefit of performance completions with respect to the accuracy of performance predictions.

Domain-specific templates for refinement transformations

Model transformations are a major instrument of model-driven software development. Especially in declarative transformation approaches, the structuring of transformations depends to a large extent on the structure of the source models and the generated artefacts. In many cases, similar code is written for transformations that deal with the same source or target metamodel. Writing such transformations can be simplified significantly if re-occurring parts within the transformation rules can be specified in a reusable way. Current approaches to transformation development include means for transformation reuse as well as inheritance. However, modularisation along the boundaries of different parts of domain metamodels is still lacking. Furthermore, the possibilities to reuse transformation fragments that re-occur in multiple transformations is limited. In this paper, we introduce domain-specific templates for refinement transformations with well-defined variation points. Transformation templates are based on known design patterns and enable a modular specification of refinement transformations and thus yield a simpler definition of transformations that can be grasped more easily and developed more efficiently. In addition, we present a real-world case study of transformation templates in the context of component based software architectures. The case study gives insight into the application of the presented approach.

Systematic Refinement of Performance Models for Concurrent Component-based Systems

Model-driven performance prediction methods require detailed design models to evaluate the performance of software systems during early development stages. However, the complexity of detailed prediction models and the semantic gap between modelled performance concerns and functional concerns prevents many developers to address performance. As a solution to this problem, systematic model refinements, called completions, hide low-level details from developers. Completions automatically integrate performance-relevant details into component-based architectures using model-to-model transformations. In such scenarios, conflicts between different completions are likely. Therefore, the application order of completions must be determined unambiguously in order to reduce such conflicts. Many existing approaches employ the concept of performance completions to include performance-relevant details to the prediction model. So far researcher only address the application of a single completion on an architectural model. The reduction of conflicting completions have not yet been considered. In this paper, we present a systematic approach to reduce and avoid conflicts between completions that are applied to the same model. The method presented in this paper is essential for the automated integration of completions in software performance engineering. Furthermore, we apply our approach to reduce conflicts of a set of completions based on design patterns for concurrent software systems.

Experience building non-functional requirement models of a complex industrial architecture

In this paper, we report on our experience with the application of validated models to assess performance, reliability, and adaptability of a complex mission critical system that is being developed to dynamically monitor and control the position of an oil-drilling platform. We present real-time modeling results that show that all tasks are schedulable. We performed stochastic analysis of the distribution of tasks execution time as a function of the number of system interfaces. We report on the variability of task execution times for the expected system configurations. In addition, we have executed a system library for an important task inside the performance model simulator. We report on the measured algorithm convergence as a function of the number of vessel thrusters. We have also studied the system architecture adaptability by comparing the documented system architecture and the implemented source code. We report on the adaptability findings and the recommendations we were able to provide to the systems architect. Finally, we have developed models of hardware and software reliability. We report on hardware reliability results based on the evaluation of the system architecture. As a topic for future work, we report on an approach that we recommend be applied to evaluate the system under study software reliability.

Performance-driven stepwise refinement of component-based architectures

Detailed models of component-based software architectures are crucial for the accurate evaluation and prediction of systems quality attributes (e.g., performance) during early development stages. Ideally, the increased complexity of such models should not incur additional modelling effort for developers. Specific incremental model refinements called completions provide a systematic approach to reduce the modelling effort. Completions transparently integrate low-level details that affect systems quality (e.g. performance impact of middleware configuration) into component-based architectural models, using model-to-model transformations. When multiple completions are to be applied, the necessary model transformations are executed in a chain. In such scenarios, conflicts between different completions are likely. In current practice, the conflicts are supposed to be resolved by software architects, who decide on the suitable transformation order manually. However, this approach is time-consuming, can be error-prone, and is likely to result in suboptimal designs. In this paper, we aim to automate the resolution of conflicts. We define a technique to identify and resolve possible conflicts. The technique locally optimises the completions order, based on its validity and quality attributes semantics. We validate our approach by applying it to an architecture model of a component-based business information system and analyse the impact of different completions orders and the complexity of possible conflicts.

Experience building non-functional requirement models of a complex industrial architecture (abstracts only)

In this paper, we report on our experience with the application of validated models to assess performance, reliability, and adaptability of a complex mission critical system that is being developed to dynamically monitor and control the position of an oil-drilling platform. We present real-time modeling results that show that all tasks are schedulable. We performed stochastic analysis of the distribution of tasks execution time as a function of the number of system interfaces. We report on the variability of task execution times for the expected system configurations. In addition, we have executed a system library for an important task inside the performance model simulator. We report on the measured algorithm convergence as a function of the number of vessel thrusters. We have also studied the system architecture adaptability by comparing the documented system architecture and the implemented source code. We report on the adaptability findings and the recommendations we were able to provide to the systems architect. Finally, we have developed models of hardware and software reliability. We report on hardware reliability results based on the evaluation of the system architecture. As a topic for future work, we report on an approach that we recommend be applied to evaluate the system under study software reliability.