Abstract The design of cyber-physical systems (CPS) is challenging due to the heterogeneity of software and hardware components that operate in uncertain environments (e.g., fluctuating workloads), hence they are prone to performance issues. Software performance antipatterns could be a key means to tackle this challenge since they recognize design problems that may lead to unacceptable system performance. This manuscript focuses on modeling and analyzing a variegate set of software performance antipatterns with the goal of quantifying their performance impact on CPS. Starting from the specification of eight software performance antipatterns, we build a baseline queuing network performance model that is properly extended to account for the corresponding bad practices. The approach is applied to a CPS consisting of a network of sensors and experimental results show that performance degradation can be traced back to software performance antipatterns. Sensitivity analysis investigates the peculiar characteristics of antipatterns, such as the frequency of checking the status of resources, that provides quantitative information to software designers to help them identify potential performance problems and their root causes. Quantifying the performance impact of antipatterns on CPS paves the way for future work enabling the automated refactoring of systems to remove these bad practices.

Identifying performance problems in modern software systems is nontrivial, even more so when looking at specific application domains, such as cyber-physical systems. The heterogeneity of software and hardware components makes the process of performance evaluation more challenging, and traditional software performance engineering techniques may fail while dealing with interacting and heterogeneous components. The goal of this paper is to introduce a model-based approach to understand software performance problems in cyber-physical systems. In our previous work, we listed some common bad practices, namely software performance antipatterns, that may occur. Here we are interested in shedding light on these antipatterns by means of performance models, i.e., queuing network models, that provide evidence of how antipatterns may affect the overall system performance. Starting from the specification of three software performance antipatterns tailored for cyber-physical systems, we provide the queuing network models capturing the corresponding bad practices. The analysis of these models demonstrates their usefulness in recognizing performance problems early in the software development process. This way, performance engineers are supported in the task of detecting and fixing the performance criticalities.

Software performance antipatterns (SPAs) document common performance problems in software architecture and design and how to fix them. They differ from software antipatterns in their focus on the performance of the software. This paper addresses performance antipatterns that are common in today's Cyber-Physical Systems (CPS). We describe the characteristics of today's CPS that cause performance problems that have been uncommon in real-time embedded systems of the past. Three new performance antipatterns are defined and their impact on CPS is described. Six previously defined performance antipatterns are described that are particularly relevant to today's CPS. The paper concludes with observations on how this work is useful in the design, implementation, and operation of CPS.

Performance model interchange formats provide a mechanism for automatically moving performance models among modelling tools. The Experiment Schema Extension (Ex-SE) specifies performance studies to be run on the model and the XML performance metrics desired. Moreover, the Results Schema Extension (Results-SE) specifies how to automatically transform the output metrics into useful results. This paper presents the tool FORGE (Friendly Output to Results Generator Engine), a GUI based transformation tool from output to results which simplifies the specification of common tables for the output files the user provides. A case study demonstrates the use of the tool.

XML-based interchange formats for performance models provide a mechanism whereby performance model information may be transferred among modeling tools. Formats have been defined for the interchange of queueing network models (QNM), layered queueing networks, UML, Petri nets (PNs) 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; to collect model output; and to present it in a useful, readable format for analysis and presentation. 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 present the output specifications, the requirements for the types of results to be supported, the issues in the output-to-results transformation, the results specifications and several prototype implementations that demonstrate the viability of the approach. We apply the approach to two distinct modeling paradigms: QNM and PN models. Several proof of concept experiments demonstrate the framework.

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.

Software Performance Engineering (SPE) is a method for constructing software systems that meet performance goals. SPE includes techniques for gathering data, coping with uncertainty, constructing and evaluating performance models, evaluating alternatives, and verifying models and validating results. It also includes strategies for the effective use of these techniques. This presentation addresses the architectural stage performance evaluation the SPE process continues throughout development at more detailed levels to manage the performance of the evolving system.

Software performance engineering (SPE) provides an approach to constructing systems to meet performance objectives. The authors illustrate the application of SPE to an example with some real-time properties and demonstrate how to compare performance characteristics of design alternatives. They show how SPE can be integrated with design methods and demonstrate that performance requirements can be achieved without sacrificing other desirable design qualities such as understandability, maintainability, and reusability.>

The general principles for formulating software requirements and designs that meet response-time goals are reviewed. The principles are related to the system performance parameters that they improve, and thus their application may not be obvious to those whose speciality is system architecture and design. The author addresses the designer's perspective and illustrates how these principles apply to typical design problems. The examples illustrate requirements and design of: communication, user interfaces, information storage, retrieval and update, information hiding, and data availability. Strategies for effective use of the principles are described.>

Recent research on the explicit transfer of technology used in computer-aided design (CAD) tools and design methodologies is reported. First, several examples are given of applications of these technologies to software engineering. Then, three research projects are described which focused on applying software engineering principles to the VLSI design process. They are: a methodology, language, and assessment tool for multilevel mixed-mode VLSI designs; a research project that explored the potential for transfer of software design methodologies for managing VLSI design complexity; and a specification technique for "modules" in a VLSI design that localizes the impact of changes to the design. Next, a CAD tool and design methodology are described which consider the design of software and hardware together, and apply common techniques to both. Finally, some observations are made on the appropriateness of technology transfer between VLSI design and software engineering.

Three general principles are presented that can be applied in early software life cycle stages for the definition of software requirements and designs with acceptable performance. They are genuine high-level considerations for meeting responsiveness goals without sacrificing understandability and maintainability, and without increasing development time and cost. The principles are derived from the interrelationships of two performance models: a queueing network based on computer system model and an execution graph software model. The performance effect of each of the principles is quantified using the models. Examples are given that illustrate how they can be applied to software systems.

Codesign of hardware and software for high performance signal processing systems is important if the potential benefits of VLSI are to be realized. This article describes a CAD system developed to support the codesign of hardware and software architectures for high performance digital signal processors which is based on a directed graph methodology. A comprehensive example is developed to demonstrate the use of the system, the fundamentals of the modeling and analysis methodology are discussed, and an overview of the tools in the system is presented along with a discussion of the enhancements currently being developed.