Model interoperability for performance engineering: survey of milestones and evolution
---
paper_title: The Future of Software Performance Engineering

paper_content:

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.
---
paper_title: Performance Solutions A Practical Guide To Creating Responsive Scalable Software

paper_content:

Thank you for downloading performance solutions a practical guide to creating responsive scalable software. As you may know, people have search numerous times for their favorite books like this performance solutions a practical guide to creating responsive scalable software, but end up in infectious downloads. Rather than reading a good book with a cup of tea in the afternoon, instead they cope with some malicious bugs inside their laptop.
---
paper_title: Towards a Performance Modelling Environment: News on Hit

paper_content:

HIT is a comprehensive software tool supporting the model-based evaluation of computing system performance. HIT models exhibit a highly structured view of the systems to be assessed, based on (vertical) functional hierarchies and (horizontal) modularization as employed in modern software engineering and hardware architecture approaches. Analysis of HIT models is provided by analytic-algebraical, analytic-numerical, exact and approximate techniques and by discrete-event simulation. Both model description and model analysis utilize the model structure for convenient problem specification and efficient evaluation, respectively. Particular emphasis is placed on decomposition and aggregation options and on a mixed (heterogeneous) use of different analysis techniques. Great care is also employed with respect to tool handling aspects. This paper describes recent extensions of the HIT modelling environment and illustrates it by way of an extended office model example.
---
paper_title: A Performance Model Interchange Format

paper_content:

Abstract A performance model interchange format (PMIF) provides a mechanism whereby system model information may be transferred among performance modeling tools. The PMIF allows diverse tools to exchange information and requires only that the importing and exporting tools support the PMIF. This paper presents the definition of a PMIF by describing a meta-model of the information requirements and the transfer format derived from it. It describes how tool developers can implement the PMIF, how the model interchange via export and import works in practice, and how the PMIF can be extended. A simple case study illustrates the format. The paper concludes with the current status of the PMIF, lessons learned, some suggestions for extensions, and current work in progress.
---
paper_title: Towards a Performance Modelling Environment: News on Hit

paper_content:

HIT is a comprehensive software tool supporting the model-based evaluation of computing system performance. HIT models exhibit a highly structured view of the systems to be assessed, based on (vertical) functional hierarchies and (horizontal) modularization as employed in modern software engineering and hardware architecture approaches. Analysis of HIT models is provided by analytic-algebraical, analytic-numerical, exact and approximate techniques and by discrete-event simulation. Both model description and model analysis utilize the model structure for convenient problem specification and efficient evaluation, respectively. Particular emphasis is placed on decomposition and aggregation options and on a mixed (heterogeneous) use of different analysis techniques. Great care is also employed with respect to tool handling aspects. This paper describes recent extensions of the HIT modelling environment and illustrates it by way of an extended office model example.
---
paper_title: Performance model interchange format (PMIF 2.0): XML definition and implementation

paper_content:

A performance model interchange format (PMIF) provides a mechanism whereby system model information may be transferred among performance modeling tools. The PMIF allows diverse tools to exchange information and requires only that the importing and exporting tools either support the PMIF or provide an interface that reads/writes model specifications from/to a file. This paper presents a new version of the PMIF specification (PMIF 2.0) and its XML implementation. The paper also describes a prototype that was implemented to prove the concept, in which the exporting tool is SPE/spl middot/ED and the importing tool is Qnap, and it discusses the issues in this and the reverse exchange. It shows the validation of the prototype based on the solution of examples that were exported from SPE/spl middot/ED and imported by Qnap. In addition, it proposes some extensions to PMIF 2.0.
---
paper_title: Performance Model Interchange Format (PMIF 2): A comprehensive approach to Queueing Network Model interoperability

paper_content:

The Performance Model Interchange Format (PMIF) provides a mechanism for transferring the system model information among performance modeling tools requiring only that the tools either internally support PMIF or provide an interface that reads/writes model specifications from/to a file. This paper presents the latest version of the specification (PMIF 2): a metamodel defining the information requirements and the corresponding XML schema. It defines the semantic properties for a pmif.xml interchange, the prescribed validation order, errors and warnings, and a tool and Web service implementation. Import and export prototypes for two different types of tools prove the concept. Generally available examples are used for repeatability.
---
paper_title: From UML to LQN by XML algebra-based model transformations

paper_content:

The change of focus from code to models promoted by OMG's Model Driven Development raises the need for verification of non-functional characteristics of UML models. such as performance, reliability, scalability, security, etc. Many modeling formalisms, techniques and tools have been developed over the years for the analysis of different non-functional characteristics. The challenge is not to reinvent new analysis methods for UML models, but to bridge the gap between UML-based software development tools and different kinds of existing analysis tools. Traditionally, the analysis models were built "by hand". However, a new trend is starting to emerge, that involves the automatic transformation of UML models (annotated with extra information) into various kinds of analysis models. This paper proposes a transformation method of an annotated UML model into a performance model. The mapping between the input model and the output model is defined at a higher level of abstraction based on graph transformation concepts, whereas the implementation of the transformation rules and algorithm uses lower-level XML trees manipulations techniques, such as XML algebra. The target performance model used as an example in this paper is the Layered Queueing Network (LQN); however, the transformation approach can be easily tailored to other performance modelling formalisms.
---
paper_title: XSLT transformation from UML models to LQN performance models

paper_content:

A graph grammar-based transformation of a UML design model into a Layered Queueing Network (LQN) performance model was previously proposed by the authors of this paper. The actual transformation was implemented in two ways: first by using an existing graph-rewriting tool, and secondly through an ad-hoc graph transformation implemented in Java.This paper extends the previous work of the authors by proposing a third approach to implement the UML to LQN transformation by using XSLT. Recommended by the World Wide Web Consortium (W3C) the Extensible Stylesheet Language for Transformations (XSLT) is a flexible language for transforming XML documents into various formats including HTML, XML, text, PDF, etc. The input to our XSLT transformation is an XML file that contains the UML model in XML format according to the standard XML Metadata Interchange (XMI). The output is the corresponding LQN model description file, which can be read directly by existing LQN solvers. The paper compares the relative advantages and disadvantages of the XSLT transformation with the previous approaches proposed by the authors, describes the principles of the XSLT transformation and applies it to a case study.
---
paper_title: Performance evaluation of UML software architectures with multiclass Queueing Network models

paper_content:

Software performance based on performance models can be applied at early phases of the software development cycle to characterize the quantitative behavior of software systems. We propose an approach based on queueing networks models for performance prediction of software systems at the software architecture level, specified by UML. Starting from annotated UML Use Case, Activity and Deployment diagrams we derive a performance models based on multichain and multiclass Queueing Networks (QN). The UML model is annotated according to the UML Profile for Schedulability, Performance and Time Specification. The proposed algorithm translates the annotated UML specification into QN performance models, which can then be analyzed using standard solution techniques. Performance results are reported back at the software architecture level in the UML diagrams. As our approach can be fully automated and uses standard UML annotations, it can be integrated with other performance modeling approaches. Specifically, we discuss how this QN-based approach can be integrated with an existing simulation-based performance modeling tool.
---
paper_title: From UML activity diagrams to Stochastic Petri nets: application to software performance engineering

paper_content:

Over the last decade, the relevance of performance evaluation in the early stages of the software development life-cycle has been steadily rising. We honestly believe that the integration of formal models in the software engineering process is a must, in order to enable the application of wellknown, powerful analysis techniques to software models. In previous papers the authors have stated a proposal for SPE, dealing with several UML diagram types. The proposal for malizes their semantics, and provides a method to translate them into (analyzable) GSPN models. This paper focuses on activity diagrams, which had not been dealt with so far. They will be incorporated in our SPE method, enhancing its expressivity by refining abstraction levels in the statechart diagrams. Performance requirements will be annotated according to the UML profile for schedulability, performance and time. Last but not least, our CASE tool prototype will be introduced. This tool deals with every model element from activity diagrams and ensures an automatic translation from ADs into GSPNs strictly following the process related in this paper.
---
paper_title: A model transformation framework for the automated building of performance models from UML models

paper_content:

In order to effectively validate the performance of software systems throughout their development cycle it is necessary to continuously build performance models from software models and then use the obtained models to check whether the system is being developed according to its performance requirements. The model building activity is a critical and effort-consuming activity. Several approaches have been envisaged to endow software designers with tools that automatically build ready-to-evaluate performance models from software development models. One essential requirement of such tools, often disregarded by current approaches, is a high degree of interoperability with software development tools, which has the positive effect of reducing both the level of required expertise in performance theory and the burden of learning separate tools. This paper introduces a framework for transforming source software models into target performance models. The transformation requires a clear understanding of the abstract syntax and semantics of both the source and target models, which is obtained by use of metamodeling techniques for defining the abstract syntax of models, the interrelationships between model elements and the model transformation rules. In the paper case, the framework is applied to the transformation of source models of UML type into target models of LQN (layered queueing network) type. The proposed approach is founded on the precepts recently introduced by model-driven development (MDA) and makes use of the set of related standards (MOF, QVT, XMI). This allows to obtain a high degree of automation, so that interoperable model transformation tools can be implemented in a timely and efficient way, leading to improvements in terms of software designers' productivity and system quality.
---
paper_title: From UML models to software performance results: an SPE process based on XML interchange formats

paper_content:

The SPE process uses multiple performance assessment tools depending on the state of the software and the amount of performance data available. This paper describes two XML based interchange formats that facilitate using a variety of performance tools in a plug-and-play manner thus enabling the use of the tool best suited to the analysis. The Software Performance Model Interchange Format (S-PMIF) is a common representation that is used to exchange information between (UML-based) software design tools and software performance engineering tools. On the other hand, the performance model interchange format (PMIF 2.0) is a common representation for system performance model data that can be used to move models among system performance modeling tools that use a queueing network model paradigm. This paper first defines an XML based S-PMIF based on an updated SPE meta-model Then it demonstrates the feasibility of using both the S-PMIF and the PMIF 2.0 to automatically translate an architecture description in UML into both a software performance model and a system performance model to study the performance characteristics of the architecture. This required the implementation of some extensions to the XPRIT software in order to export UML models into the S-PMIF and a new function in the SPEED software to import S-PMIF models, which are also described. The SPE process and an experimental proof of concept are presented.
---
paper_title: Performance by unified model analysis (PUMA)

paper_content:

Evaluation of non-functional properties of a design (such as performance, dependability, security, etc.) can be enabled by design annotations specific to the property to be evaluated. Performance properties, for instance, can be annotated on UML designs by using the "UML Profile for Schedulability, Performance and Time (SPT)". However the communication between the design description in UML and the tools used for non-functional properties evaluation requires support, particularly for performance where there are many alternative performance analysis tools that might be applied. This paper describes a tool architecture called PUMA, which provides a unified interface between different kinds of design information and different kinds of performance models, for example Markov models, stochastic Petri nets and process algebras, queues and layered queues.The paper concentrates on the creation of performance models. The unified interface of PUMA is centered on an intermediate model called Core Scenario Model (CSM), which is extracted from the annotated design model. Experience shows that CSM is also necessary for cleaning and auditing the design information, and providing default interpretations in case it is incomplete, before creating a performance model.
---
paper_title: From design to analysis models: a kernel language for performance and reliability analysis of component-based systems

paper_content:

To facilitate the use of non-functional analysis results in the selection and assembly of components for component-based systems, automatic prediction tools should be devised, to predict some overall quality attribute of the application without requiring extensive knowledge of analysis methodologies to the application designer. To achieve this goal, a key idea is to define a model transformation that takes as input some "design-oriented" model of the component assembly and produces as a result an "analysis-oriented" model that lends itself to the application of some analysis methodology. However, to actually devise such a transformation, we must face both the heterogeneous design level notations for component-based systems, and the variety of non-functional attributes and related analysis methodologies we could be interested in. In this perspective, we define a kernel language whose aim is to capture the relevant information for the analysis of non-functional attributes of component-based systems, with a focus on performance and reliability. Using this kernel language as a bridge between design-oriented and analysis-oriented notations we reduce the burden of defining a variety of direct transformations from the former to the latter to the less complex problem of defining transformations to/from the kernel language. The proposed kernel language is defined within the MOF (Meta-Object Facility) framework, to allow the exploitation of MOF-based model transformation facilities.
---
paper_title: A general performance model interchange format

paper_content:

A common, XML-based interface between specifications of quantitative system models and programmed solutions is developed and illustrated with several examples. It is based on the PMIF (Performance Model Interchange Format), which allows queueing network models to be specified in XML and solved by calling any appropriate modelling tool, such as Qnap. The definition of PMIF specifications is generalised by considering more abstract collections of interacting nodes, using concepts compatible with the Reversed Compound Agent Theorem (RCAT). The interactions are more general in that they synchronise transitions in a pair of nodes rather than being restricted to describing traffic flows. The generalised nodes are characterised by the interactions in which they participate, together with their rates and reversed rates, which may be implicit. In this way, generalised queueing networks with negative customers and triggers can be incorporated and fixpoint models can also be handled uniformly through the use of symbolic variables.
---
paper_title: How far are we from the definition of a common software performance ontology?

paper_content:

The recent approaches to software performance modeling and validation share the idea of annotating software models with information related to performance (e.g. operational profile) and transforming the annotated model into a performance model (e.g. a Stochastic Petri Net). Up to date, no standard has been defined to represent the information related to performance in software artifacts, although clear advantages in tool interoperability and model transformations would stem from it. This paper is aimed at questioning whether a software performance ontology (i.e. a standard set of concepts and relations) is achievable or not. We consider three meta-models defined for software performance, that are the Schedulability, Performance and Time profile of UML, the Core Scenario Model and the Software Performance Engineering meta-model. We devise two approaches to the creation of an ontology: (i) bottom-up, that extracts common knowledge from the meta-models, (ii) top-down, that is driven from a set of requirements.
---
paper_title: Performance by unified model analysis (PUMA)

paper_content:

Evaluation of non-functional properties of a design (such as performance, dependability, security, etc.) can be enabled by design annotations specific to the property to be evaluated. Performance properties, for instance, can be annotated on UML designs by using the "UML Profile for Schedulability, Performance and Time (SPT)". However the communication between the design description in UML and the tools used for non-functional properties evaluation requires support, particularly for performance where there are many alternative performance analysis tools that might be applied. This paper describes a tool architecture called PUMA, which provides a unified interface between different kinds of design information and different kinds of performance models, for example Markov models, stochastic Petri nets and process algebras, queues and layered queues.The paper concentrates on the creation of performance models. The unified interface of PUMA is centered on an intermediate model called Core Scenario Model (CSM), which is extracted from the annotated design model. Experience shows that CSM is also necessary for cleaning and auditing the design information, and providing default interpretations in case it is incomplete, before creating a performance model.
---
paper_title: Performance Model Interchange Format (PMIF 2): A comprehensive approach to Queueing Network Model interoperability

paper_content:

The Performance Model Interchange Format (PMIF) provides a mechanism for transferring the system model information among performance modeling tools requiring only that the tools either internally support PMIF or provide an interface that reads/writes model specifications from/to a file. This paper presents the latest version of the specification (PMIF 2): a metamodel defining the information requirements and the corresponding XML schema. It defines the semantic properties for a pmif.xml interchange, the prescribed validation order, errors and warnings, and a tool and Web service implementation. Import and export prototypes for two different types of tools prove the concept. Generally available examples are used for repeatability.
---
paper_title: Performance Model Interchange Format: Semantic Validation

paper_content:

A Performance Model Interchange Format (PMIF) provides a mechanism whereby system model information may be transferred among queueing network model (QNM) based modeling tools. The PMIF allows diverse tools to exchange information and requires only that those tools provide importing/exporting mechanisms from/to the PMIF. The XML specification of the PMIF allows implementers to use widely available tools to parse the XML file, check the syntax, and simplify the translation to/from the XML format. Those tools, however, do not know the semantics of a QNM so they cannot check the XML to ensure that it contains a valid QNM. This paper presents the study of the validations needed to carry out such a semantic analysis, and the development of a semantic validation tool that can be used by any developer who wants to implement PMIF import/export mechanisms.
---
paper_title: Automatic Generation of Performance Analysis Results: Requirements and Demonstration

paper_content:

This paper presents a performance model interoperability framework that brings together performance model interchange formats and experiment specifications with the automatic generation of performance analysis results for presentation and publication. We define the Use Cases and requirements and survey output and results used in practice. We present the output specification, the issues in the output-to-results transformation, the results specification schema extension, and a prototype implementation. A proof of concept example demonstrates the framework.
---
paper_title: PRISM: probabilistic model checking for performance and reliability analysis

paper_content:

Probabilistic model checking is a formal verification technique for the modelling and analysis of stochastic systems. It has proved to be useful for studying a wide range of quantitative properties of models taken from many diffierent application domains. This includes, for example, performance and reliability properties of computer and communication systems. In this paper, we give an overview of the probabilistic model checking tool PRISM, focusing in particular on its support for continuous-time Markov chains and Markov reward models, and how these can be used to analyse performability properties.
---
paper_title: Design of Experiments within the Mobius Modeling Environment

paper_content:

Models of complex systems often contain model parameters for important rates, probabilities, and initial state values. By varying the parameter values, the system modeler can study the behavior of the system under a wide range of system and environmental assumptions. However, exhaustive exploration of the parameter space of a large model is computationally expensive. Design of experiments techniques provide information about the degree of sensitivity of output variables to various input parameters. Design of experiments makes it possible to find parameter values that optimize measured outputs of the system by running fewer experiments than required by less rigorous techniques. This paper describes the design of experiments techniques that have been integrated in the Mobius tool.
---
paper_title: COMPONENT-BASED MODELS AND SIMULATIONS FOR SUPPORTING VALID MULTI-AGENT SYSTEM SIMULATIONS

paper_content:

The more simulation becomes an established tool in the design of multi-agent systems, the more urgent the question becomes how valid the induced properties and behavior patterns are. Answering this question depends on the validity of the models, the correctness of the simulators, and the simulations. In all of these aspects, reuse and a declarative representation plays a crucial role. With James II, we developed a customizable framework for modeling and simulation. Its component-based architecture supports a reuse of models, simulators, and experimental settings. The benefits of this architecture for agent-based modeling and simulation will be illuminated by an excerpt of a simulation study about trading strategies for mobile ad hoc networks.
---
paper_title: Interchange Formats for Performance Models: Experimentation and Ouput

paper_content:

XML-based interchange formats for performance models provide a mechanism whereby performance model information may be transferred among modeling tools. For example, the PMIF allows diverse tools to exchange queueing network model information. Formats have also been defined for the interchange of LQN, UML, Petri Nets, and others. These formats specify the model and a set of parameters for one run. For model studies, however, it is useful to be able to specify multiple runs, or experiments, for the model. This paper presents an XML interchange schema extension for defining a set of model runs and the output desired from them. It has the expressive power to specify iterations, alternations, assignments of values, actions based on model results and more. Examples illustrate how the experiment interchange extension can be used with a wide variety of performance modeling paradigms. A prototype proves the concept.
---
paper_title: Automatic Generation of Performance Analysis Results: Requirements and Demonstration

paper_content:

This paper presents a performance model interoperability framework that brings together performance model interchange formats and experiment specifications with the automatic generation of performance analysis results for presentation and publication. We define the Use Cases and requirements and survey output and results used in practice. We present the output specification, the issues in the output-to-results transformation, the results specification schema extension, and a prototype implementation. A proof of concept example demonstrates the framework.
---
paper_title: Interchange Formats for Performance Models: Experimentation and Ouput

paper_content:

XML-based interchange formats for performance models provide a mechanism whereby performance model information may be transferred among modeling tools. For example, the PMIF allows diverse tools to exchange queueing network model information. Formats have also been defined for the interchange of LQN, UML, Petri Nets, and others. These formats specify the model and a set of parameters for one run. For model studies, however, it is useful to be able to specify multiple runs, or experiments, for the model. This paper presents an XML interchange schema extension for defining a set of model runs and the output desired from them. It has the expressive power to specify iterations, alternations, assignments of values, actions based on model results and more. Examples illustrate how the experiment interchange extension can be used with a wide variety of performance modeling paradigms. A prototype proves the concept.
---
paper_title: Performance analysis of real-time component architectures: a model interchange approach

paper_content:

Model interchange approaches support the analysis of software architecture and design by enabling a variety of tools to automatically exchange performance models using a common schema. This paper builds on one of those interchange formats, the Software Performance Model Interchange Format (S-PMIF), and extends it to support the performance analysis of real-time systems. Specifically, it addresses real-time system designs expressed in the Construction and Composition Language (CCL) and their transformation into the S-PMIF for additional performance analyses. This paper defines extensions and changes to the S-PMIF meta-model and schema required for real-time systems. It describes transformations for both simple, best-case models and more detailed models of concurrency and synchronization. A case study demonstrates the techniques and compares performance results from several analyses.
---
paper_title: Performance modeling from software components

paper_content:

When software products are assembled from pre-defined components, performance prediction should be based on the components also. This supports rapid model-building, using previously calibrated sub-models or "performance components", in sync with the construction of the product. The specification of a performance component must be tied closely to the software component specification, but it also includes performance related parameters (describing workload characteristics and demands), and it abstracts the behaviour of the component in various ways (for reasons related to practical factors in performance analysis). A useful set of abstractions and parameters are already defined for layered performance modeling. This work extends them to accommodate software components, using a new XML-based language called Component-Based Modeling Language (CBML). With CBML, compatible components can be inserted into slots provided in a hierarchical component specification based on the UML component model.
---
paper_title: Model-Based performance prediction with the palladio component model

paper_content:

One aim of component-based software engineering (CBSE) is to enable the prediction of extra-functional properties, such as performance and reliability, utilising a well-defined composition theory. Nowadays, such theories and their accompanying prediction methods are still in a maturation stage. Several factors influencing extra-functional properties need additional research to be understood. A special problem in CBSE stems from its specific development process: Software components should be specified and implemented independent from their later context to enable reuse. Thus, extra-functional properties of components need to be specified in a parametric way to take different influence factors like the hardware platform or the usage profile into account. In our approach, we use the Palladio Component Model (PCM) to specify component-based software architectures in a parametric way. This model offers direct support of the CBSE development process by dividing the model creation among the developer roles. In this paper, we present our model and a simulation tool based on it, which is capable of making performance predictions. Within a case study, we show that the resulting prediction accuracy can be sufficient to support the evaluation of architectural design decisions.
---
paper_title: Performance analysis of real-time component architectures: An enhanced model interchange approach

paper_content:

Model interchange approaches support the analysis of software architecture and design by enabling a variety of tools to exchange performance models using a common schema. This paper builds on the Software Performance Model Interchange Format (S-PMIF), extending it to support the analysis of real-time systems and adapting it to be suitable for implementation with modeling frameworks such as MOF or EMF. This enhances the model interchange process by making it possible to define model-to-model transformations from design models into software performance models. The paper addresses real-time system designs expressed in CCL and their transformation into the S-PMIF for additional performance analyses.
---
paper_title: A model-driven approach to performability analysis of dynamically reconfigurable component-based systems

paper_content:

Dynamic reconfiguration techniques appear promising to build component-based (C-B) systems for application domains that have strong adaptability requirements, like the mobile and the service-oriented computing domains. However, introducing dynamic reconfiguration features into a C-B application makes even more challenging the design and verification of functional and non functional requirements. Our goal is to support the model-based analysis of the effectiveness of reconfigurable C-B applications, with a focus on the assessment of the non-functional performance and reliability attributes. As a first step towards this end, we address the issue of selecting suitable analysis models for reconfigurable systems, suggesting to this end the use of joint performance and reliability (performability) models. Furthermore, we propose a model-driven approach to automatically transform a design model into an analysis model. For this purpose, we build on the existence of intermediate languages that have been proposed to facilitate this transformation and we extend one of them, to capture the core features (from a performance/reliability viewpoint) of a dynamically reconfigurable C-B system. Finally, we illustrate by a simple application example the main steps of the proposed approach.
---
paper_title: How far are we from the definition of a common software performance ontology?

paper_content:

The recent approaches to software performance modeling and validation share the idea of annotating software models with information related to performance (e.g. operational profile) and transforming the annotated model into a performance model (e.g. a Stochastic Petri Net). Up to date, no standard has been defined to represent the information related to performance in software artifacts, although clear advantages in tool interoperability and model transformations would stem from it. This paper is aimed at questioning whether a software performance ontology (i.e. a standard set of concepts and relations) is achievable or not. We consider three meta-models defined for software performance, that are the Schedulability, Performance and Time profile of UML, the Core Scenario Model and the Software Performance Engineering meta-model. We devise two approaches to the creation of an ontology: (i) bottom-up, that extracts common knowledge from the meta-models, (ii) top-down, that is driven from a set of requirements.
---
paper_title: How far are we from the definition of a common software performance ontology?

paper_content:

The recent approaches to software performance modeling and validation share the idea of annotating software models with information related to performance (e.g. operational profile) and transforming the annotated model into a performance model (e.g. a Stochastic Petri Net). Up to date, no standard has been defined to represent the information related to performance in software artifacts, although clear advantages in tool interoperability and model transformations would stem from it. This paper is aimed at questioning whether a software performance ontology (i.e. a standard set of concepts and relations) is achievable or not. We consider three meta-models defined for software performance, that are the Schedulability, Performance and Time profile of UML, the Core Scenario Model and the Software Performance Engineering meta-model. We devise two approaches to the creation of an ontology: (i) bottom-up, that extracts common knowledge from the meta-models, (ii) top-down, that is driven from a set of requirements.
---

Title: Model interoperability for performance engineering: survey of milestones and evolution

Section 1: Introduction
Description 1: Provide an overview of Software Performance Engineering (SPE) and its evolution. Discuss the challenges and emphasize the need for model interoperability.

Section 2: Version 1 Model Interchange Formats
Description 2: Explain the concept of Model Interchange Formats (MIFs) and their significance. Discuss the early versions and their impact on performance modeling tools interoperability.

Section 3: Version 2 PMIF
Description 3: Describe advancements in MIFs with the introduction of XML and Version 2 of the Performance Model Interchange Format (PMIF). Highlight specific changes and implementation examples.

Section 4: Flurry of Related Work
Description 4: Summarize various studies and developments that built upon initial work in performance model interchange formats.

Section 5: Design Models to Performance Models
Description 5: Explore methods and frameworks that connect software design models to performance models, emphasizing tools and studies that facilitate these transformations.

Section 6: MIF Extensions
Description 6: Discuss extensions to MIFs, like Core Scenario Model (CSM) and KLAPER. Highlight their contributions to improving the applicability and robustness of performance modeling.

Section 7: MIF Tools
Description 7: Review tools and technologies developed to support MIFs and improve model interoperability. Mention specific implementations and their functionalities.

Section 8: Automation of Experiments and Results
Description 8: Present methodologies for automating performance experiments and analyzing the results, detailing steps and schemas such as Ex-SE and Output-SE.

Section 9: Experimentation
Description 9: Explain the frameworks and tools that facilitate experimentation in performance engineering, focusing on general approaches and tool-specific features.

Section 10: Model Output
Description 10: Describe how model outputs are handled, including schema extensions for output and tools for processing and visualizing results.

Section 11: Experiment Results
Description 11: Detail the processes and tools used to obtain and present experiment results, focusing on common output formats and use cases.

Section 12: Multiple Domains
Description 12: Discuss the application of MIFs and extensions across various domains and modeling paradigms, including Petri nets and layered queueing networks.

Section 13: Real-time and Component-Based Systems
Description 13: Address performance analysis for real-time and component-based systems, including specific models and the extensions made to support these analyses.

Section 14: Conclusions
Description 14: Summarize the key milestones, current state, and future directions of model interoperability in performance engineering. Highlight the potential impact and areas for further research.