As automation increases qualitatively and quantitatively in safety-critical human cyber-physical systems, it is becoming more and more challenging to increase the probability or ensure that human operators still perceive key artifacts and comprehend their roles in the system. In the companion paper, we proposed an abstract reference architecture capable of expressing all classes of system-level interactions in human cyber-physical systems. Here we demonstrate how this reference architecture supports the analysis of levels of communication between agents and helps to identify the potential for misunderstandings and misconceptions. We then develop a metamodel for safe human machine interaction. Therefore, we ask what type of information exchange must be supported on what level so that humans and systems can cooperate as a team, what is the criticality of exchanged information, what are timing requirements for such interactions, and how can we communicate highly critical information in a limited time frame in spite of the many sources of a distorted perception. We highlight shared stumbling blocks and illustrate shared design principles, which rest on established ontologies specific to particular application classes. In order to overcome the partial opacity of internal states of agents, we anticipate a key role of virtual twins of both human and technical cooperation partners for designing a suitable communication.

The design and analysis of multi-agent human cyber-physical systems in safety-critical or industry-critical domains calls for an adequate semantic foundation capable of exhaustively and rigorously describing all emergent effects in the joint dynamic behavior of the agents that are relevant to their safety and well-behavior. We present such a semantic foundation. This framework extends beyond previous approaches by extending the agent-local dynamic state beyond state components under direct control of the agent and belief about other agents (as previously suggested for understanding cooperative as well as rational behavior) to agent-local evidence and belief about the overall cooperative, competitive, or coopetitive game structure. We argue that this extension is necessary for rigorously analyzing systems of human cyber-physical systems because humans are known to employ cognitive replacement models of system dynamics that are both non-stationary and potentially incongruent. These replacement models induce visible and potentially harmful effects on their joint emergent behavior and the interaction with cyber-physical system components.

We propose a reference architecture of safety-critical or industry-critical human cyber-physical systems (CPSs) capable of expressing essential classes of system-level interactions between CPS and humans relevant for the societal acceptance of such systems. To reach this quality gate, the expressivity of the model must go beyond classical viewpoints such as operational, functional, and architectural views and views used for safety and security analysis. The model does so by incorporating elements of such systems for mutual introspections in situational awareness, capabilities, and intentions to enable a synergetic, trusted relation in the interaction of humans and CPSs, which we see as a prerequisite for their societal acceptance. The reference architecture is represented as a metamodel incorporating conceptual and behavioral semantic aspects. We illustrate the key concepts of the metamodel with examples from cooperative autonomous driving, the operating room of the future, cockpit-tower interaction, and crisis management.

This paper presents our preliminary results developing an incremental query and transformation engine for our modeling framework. Our prior framework combined WebGME, a cloud-based collaborative modeling tool, with FORMULA, a language and tool for specifying and analyzing domain-specific modeling languages. While this arrangement has been successful for defining non-trivial languages in domains like CPS, one ongoing challenge is the scalability of executing model queries and transformations on large models. The inherent incremental nature of the modeling process exacerbates this scalability issue: model queries and transformations are repeatedly performed on incrementally updated models. To address this issue, we are developing an incremental version of FORMULA that can perform efficient model queries and transformations in the face of continual model updates. This paper describes our experiences designing this incremental version, including the challenges we faced and design decisions. We also report encouraging benchmark results.

Cyber-Physical Systems (CPS) are establishing heterogeneous engineering domains leading to engineering processes that span multiple design disciplines with separate modeling approaches, design flows and supporting tool suites. One of the challenges of design automation in CPS is the deep integration of models, tools and design flows such that design trade-offs across traditionally isolated design disciplines is facilitated. In this paper we overview experience and results gained along the implementation of an experimental design automation tool suite, OpenMETA, created for a complex CPS design challenge in the ground vehicle domain. The focus of the paper is domain agnostic methods and tools providing infrastructure for the model- and tool- integration platforms in OpenMETA. We present the arguments leading to the creation of the integration platforms instead of pursuing ad-hoc integration of heterogeneous tools and provide details on facilitating semantic integration.

Cyber-Physical Systems (CPS) are used in many applications where they must perform complex tasks with a high degree of autonomy in uncertain environments. Traditional design flows based on domain knowledge and analytical models are often impractical for tasks such as perception, planning in uncertain environments, control with ill-defined objectives, etc. Machine learning based techniques have demonstrated good performance for such difficult tasks, leading to the introduction of Learning-Enabled Components (LEC) in CPS. Model based design techniques have been successful in the development of traditional CPS, and toolchains which apply these techniques to CPS with LECs are being actively developed. As LECs are critically dependent on training and data, one of the key challenges is to build design automation for them. In this paper, we examine the development of an autonomous Unmanned Underwater Vehicle (UUV) using the Assurance-based Learning-enabled Cyber-physical systems (ALC) Toolchain. Each stage of the development cycle is described including architectural modeling, data collection, LEC training, LEC evaluation and verification, and system-level assurance.

The exponential growth of information and communication technologies have caused a profound shift in the way humans engineer systems leading to the emergence of closed-loop systems involving strong integration and coordination of physical and cyber components, often referred to as cyber-physical systems (CPSs). Because of these disruptive changes, physical systems can now be attacked through cyberspace and cyberspace can be attacked through physical means. The paper considers security and resilience as system properties emerging from the intersection of system dynamics and the computing architecture. A modeling and simulation integration platform for experimentation and evaluation of resilient CPSs is presented using smart transportation systems as the application domain. Evaluation of resilience is based on attacker-defender games using simulations of sufficient fidelity. The platform integrates 1) realistic models of cyber and physical components and their interactions; 2) cyber attack models that focus on the impact of attacks to CPS behavior and operation; and 3) operational scenarios that can be used for evaluation of cybersecurity risks. Three case studies are presented to demonstrate the advantages of the platform: 1) vulnerability analysis of transportation networks to traffic signal tampering; 2) resilient sensor selection for forecasting traffic flow; and 3) resilient traffic signal control in the presence of denial-of-service attacks.

Design methods and tools evolved to support the principle of "separation of concerns" in order to manage engineering complexity. Accordingly, most engineering tool suites are vertically integrated but have limited support for integration across disciplinary boundaries. Cyber–physical systems (CPSs) challenge these established boundaries between disciplines, and thus, the status quo on the tools market. The question is how to create the foundations and technologies for semantically precise model and tool integration that enable reuse of existing commercial and open source tools in domain-specific design flows. In this paper, we describe the lessons learned in the design and implementation of an experimental design automation tool suite, OpenMETA, for complex CPS in the vehicle domain. The conceptual foundation for the integration approach is platform-based design: OpenMETA is architected by introducing two key platforms: the model integration platform and the tool integration platform. The model integration platform includes methods and tools for the precise representation of semantic interfaces among modeling domains. The key new components of the model integration platform are model integration languages and the mathematical framework and tool for the compositional specification of their semantics. The tool integration platform is designed for executing highly automated design-space exploration. Key components of the platform are tools for constructing design spaces and model composers for analytics workflows. The paper concludes with describing experience and lessons learned by using OpenMETA in drivetrain design and by adapting OpenMETA to substantially different CPS application domains.

Design automation tools evolved to support the principle of "separation of concerns" to manage engineering complexity. Accordingly, we find tool suites that are vertically integrated with limited support (even intention) for horizontal integratability (i.e. integration across disciplinary boundaries). CPS challenges these established boundaries and with this - market conditions. The question is how to facilitate reorganization and create the foundation and technologies for composable CPS design tool chains that enables reuse of existing commercial and open source tools? In this paper we describe some of the lessons learned in the design and implementation of a design automation tool suite for complex cyber-physical systems (CPS) in the vehicle domain. The tool suite followed a model- and component-based design approach to match the significant increase in design productivity experienced in several narrowly focused homogeneous domains, such as signal processing, control and aspects of electronic design. The primary challenge in the undertaking was the tremendous heterogeneity of complex cyber-physical systems (CPS), where such as vehicles has not yet been achieved. This paper describes some of the challenges addressed and solution approaches to building a comprehensive design tool suite for complex CPS.

Embedded systems are highly constrained, and modern constraint solvers can be used to synthesize architectures satisfying constraints. However, solvers may enumerate solutions with bias yielding a skewed view of the solution space. In this paper we formalize enumerators, enumeration bias, and build empirically diverse enumerators. An ideal diverse enumerator uniformly draws equivalence classes of solutions. We develop an algorithm, called symmetry-directed randomized partitioning, for constructing empirically diverse enumerators from modern unmodified constraint solvers. We show that our diverse enumerator is significantly closer to the ideal compared to baseline and randomized solvers.

Probability of successful delivery under deadline constraints is one of the most important performance measures in a wireless real-time multihop control and sensor network. In this paper we approach the problem of determining the probability of successful packet delivery by calculating the per-link outage probability for different fading channel models. We provide easily computable results for the end-to-end reliability for two different physical layer designs. Furthermore, we show that incorporating physical layer information into routing and scheduling decisions can result in significant performance improvements when strict deadlines are imposed on the system.

This paper presents the Networked Control Systems Windtunnel (NCSWT), an integrated modeling and simulation tool for the evaluation of networked control systems (NCS). NCSWT integrates Matlab/Simulink and ns-2 using the High Level Architecture (HLA). Our implementation of the NCSWT based on HLA guarantees accurate time synchronization and data communication in heterogenous simulations. NCSWT uses the Model Integrated Computing (MIC) techniques to define HLA-based model constructs such as federates representing the simulators and interactions between the simulators. NCSWT also uses MIC techniques to define models representing the control system and network dynamics for the rapid synthesis of simulations.

System integration is the elephant in the china store of large-scale cyber-physical system (CPS) design. It would be hard to find any other technology that is more undervalued scientifically and at the same time has bigger impact on the presence and future of engineered systems. The unique challenges in CPS integration emerge from the heterogeneity of components and interactions. This heterogeneity drives the need for modeling and analyzing cross-domain interactions among physical and computational/networking domains and demands deep understanding of the effects of heterogeneous abstraction layers in the design flow. To address the challenges of CPS integration, significant progress needs to be made toward a new science and technology foundation that is model based, precise, and predictable. This paper presents a theory of composition for heterogeneous systems focusing on stability. Specifically, the paper presents a passivity-based design approach that decouples stability from timing uncertainties caused by networking and computation. In addition, the paper describes cross-domain abstractions that provide effective solution for model-based fully automated software synthesis and high-fidelity performance analysis. The design objectives demonstrated using the techniques presented in the paper are group coordination for networked unmanned air vehicles (UAVs) and high-confidence embedded control software design for a quadrotor UAV. Open problems in the area are also discussed, including the extension of the theory of compositional design to guarantee properties beyond stability, such as safety and performance.

The integration of physical systems through computing and networking has become pervasive, a trend now known as cyber-physical systems (CPS). Functionality in CPS emerges from the interaction of networked computational and physical objects. System design and integration are particularly challenging because fundamentally different physical and computational design concerns intersect. The impact of these interactions is the loss of compositionality which creates tremendous challenges. The key idea in this article is to use passivity for decoupling the control design of networked systems from uncertainties such as time delays and packet loss, thus providing a fundamental simplification strategy that limits the complexity of interactions. The main contribution is the application of the approach to an experimental case study of a networked multi-robot system. We present a networked control architecture that ensures the overall system remains stable in spite of implementation uncertainties such as network delays and data dropouts, focusing on the technical details required for the implementation. We describe a prototype domain-specific modeling language and automated code generation tools for the design of networked control systems on top of passivity that facilitate effective system configuration, deployment, and testing. Finally, we present experimental evaluation results that show decoupling of interlayer interactions.

Our previous work has explored the use of compositional stabilization techniques for embedded flight control software[9] based on passivity properties of controller components and systems. Zames[21] presented a compositional behavior-bounding technique for evaluating stability of nonlinear systems based on real intervals representing cones (sectors) that bound possible component behaviors. Many innovations in control theory have developed from his insights. We present a novel use of his sector bound theory to validate the stability of embedded control implementations online. The sector analysis can be implemented as a computationally efficient check of stability for different parts of a control design. The advantage of the online application of this technique is that it takes into account software platform effects that impact stability, such as time delays, quantization, and data integrity.

In this article, we describe a distributed, peer-to-peer gesture recognition system along with a software architecture modeling technique and authority control protocol for ubiquitous cameras. This system performs gesture recognition in real time by combining imagery from multiple cameras without using a central server. We propose a system architecture that uses a network of inexpensive cameras to perform in-network video processing. A methodology for transforming well-designed single-node algorithm to distributed system is also proposed. Applications for ubiquitous cameras can be modeled as the composition of a finite-state machine of the system, functional services, and middleware. A service-oriented software architecture is proposed to dynamically reconfigure services when system state changes. By exchanging data and control messages between neighboring sensors, each node can maintain broader view of the environment with integrated video-processing results. Our prototype system is built on Windows machines, and uses standard video cameras as sensors and local network as a communication channel.

Time-triggered architectures (TTA) provide replica determinism in safety-critical distributed embedded software designs. TTA has become a crucial part of many high-confidence embedded paradigms, as it decouples functional concerns from platform timing concerns in system designs. Complex embedded software development workflows for safety-critical applications are increasingly managed by model-based design tools, in order to support automated verification and reconcile conflicts between functional and non-functional concerns in designs. We present a prototype scheduling tool (ESched) which calculates cyclic schedules for time-triggered networks. ESched supports the model-based workflow of the ESMoL modeling language and tool suite. Using ESMoL, designers can rapidly iterate through simulating a control design, capturing platform effects in models, generating a schedule (if feasible), and re-simulating the control design subject to the platform model and the computed schedule. ESched specifications include a number of useful platform parameters, and it supports troubleshooting of infeasible schedules by allowing the user to specify partial platform models to solve.

Real-life cyber-physical systems, such as automotive vehicles, building automation systems, and groups of unmanned vehicles are monitored and controlled by networked control systems. The overall system dynamics emerges from the interaction among physical dynamics, computational dynamics, and communication networks. Network uncertainties such as time-varying delay and packet loss cause significant challenges. This paper proposes a passive control architecture for designing wireless networked control systems that are insensitive to network uncertainties. We describe the architecture for a system consisting of a robotic manipulator controlled by a digital controller over a wireless network and we show that the system is stable even in the presence of time-varying delays. We present simulation results that demonstrate the advantages of the architecture with respect to stability and performance and show that the system is insensitive to network uncertainties.

An emerging common trend in model-based design of embedded software and systems is the adoption of domain-specific modeling languages (DSMLs). While abstract syntax metamodeling enables the rapid and inexpensive development of DSMLs, the specification of DSML semantics is still a hard problem. In previous work, we have developed methods and tools for the semantic anchoring of DSMLs. Semantic anchoring introduces a set of reusable "semantic units" that provide reference semantics for basic behavioral categories using the abstract state machine (ASM) framework. In this paper, we extend the semantic anchoring framework to heterogeneous behaviors by developing a method for the composition of semantic units. Semantic unit composition reduces the required effort from DSML designers and improves the quality of the specification. The proposed method is demonstrated through a case study

In previous work we have discussed a semantic anchoring framework that enables the semantic specification of Domain-Specific Modeling languages by specifying semantic anchoring rules to predefined semantic units. This framework is further extended to support heterogeneous systems by developing a method for the composition of semantic units. In this paper, we explain the semantic unit composition through a case study.

Sensor Webs are heterogeneous collections of sensor devices that collect information and interact with the environment. They consist of wireless sensor networks that are ensembles of small, smart, and cheap sensing and computing devices that permeate the environment as well as high-bandwidth rich sensors such as satellite imaging systems, meteorological stations, air quality stations, and security cameras. Emergency response, homeland security, and many other applications have a very real need to interconnect such diverse networks and access information in real-time. While Internet protocols and Web standards provide well-developed mechanisms for accessing this information, linking such mechanisms with resource-constrained sensor networks is very challenging because of the volatility of the communication links. This paper presents a service-oriented programming model for sensor networks which permits discovery and access of Web services. Sensor network applications are realized as graphs of modular and autonomous services with well-defined interfaces that allow them to be described, published, discovered, and invoked over the network providing a convenient way for integrating services from heterogeneous sensor systems. Our approach provides dynamic discovery, composition, and binding of services based on an efficient localized constraint satisfaction algorithm that can be used for developing ambient-aware applications that adapt to changes in the environment. A tracking application that employs many inexpensive sensor nodes, as well as a Web service, is used to illustrate the approach. Our results demonstrate the feasibility of ambient-aware applications that interconnect wireless sensor networks and Web services.

Embedded system design is inherently domain specific and typically model driven. As a result, design methodologies like OMG’s model driven architecture (MDA) and model integrated computing (MIC) evolved to support domain specific modeling languages (DSMLs). The success of the DSML approach has encouraged work on the heterogeneous composition of DSMLs, model transformations between DSMLs, approximations of formal properties within DSMLs, and reuse of DSML semantics. However, in the effort to produce a mature design approach that can handle both the structural and behavioral semantics of embedded system design, many foundational issues concerning DSMLs have been overlooked. In this paper we present a formal foundation for DSMLs and for their construction within metamodeling frameworks. This foundation allows us to algorithmically decide if two DSMLs or metamodels are equivalent, if model transformations preserve properties, and if metamodeling frameworks have meta-metamodels. These results are key to building correct embedded systems with DSMLs.

Metamodeling facilitates the rapid, inexpensive development of domain-specific modeling languages (DSML-s). However, there are still challenges hindering the wide-scale industrial application of model-based design. One of these unsolved problems is the lack of a practical, effective method for the formal specification of DSML semantics. This problem has negative impact on reusability of DSML-s and analysis tools in domain specific tool chains. To address these issues, we propose a formal well founded methodology with supporting tools to anchor the semantics of DSML-s to precisely defined and validated "semantic units". In our methodology, each of the syntactic and semantic DSML components is defined precisely and completely. The main contribution of our approach is that it moves toward an infrastructure for DSML design that integrates formal methods with practical engineering tools. In this paper we use a mathematical model, Abstract State Machines, a common semantic framework to define the semantic domains of DSML-s.

Embedded systems are commonly abstracted as collections of interacting components. This perspective has lead to the insight that component behaviors can be defined separately from admissible component interactions. We show that this separation of concerns does not imply that component behaviors can be defined in isolation from their envisioned interaction models. We argue that a type of behavior/interaction co-design must be employed to successfully leverage the separation of these concerns. We present formal techniques for accomplishing this co-design and describe tools that implement these formalisms.

Embedded software and systems are at the intersection of electrical engineering, computer engineering, and computer science, with, increasing importance, in mechanical engineering. Despite the clear need for knowledge of systems modeling and analysis (covered in electrical and other engineering disciplines) and analysis of computational processes (covered in computer science), few academic programs have integrated the two disciplines into a cohesive program of study. This paper describes the efforts conducted at Vanderbilt University to establish a curriculum that addresses the needs of embedded software and systems. Given the compartmentalized nature of traditional engineering schools, where each discipline has an independent program of study, we have had to devise innovative ways to bring together the two disciplines. The paper also describes our current efforts in using learning technology to construct, manage, and deliver sophisticated computer-aided learning modules that can supplement the traditional course structure in the individual disciplines through out-of-class and in-class use.

The paper describes a model-integrated approach for embedded software development that is based on domain-specific, multiple-view models used in all phases of the development process. Models explicitly represent the embedded software and the environment it operates in, and capture the requirements and the design of the application, simultaneously. Models are descriptive , in the sense that they allow the formal analysis, verification, and validation of the embedded system at design time. Models are also generative, in the sense that they carry enough information for automatically generating embedded systems using the techniques of program generators. Because of the widely varying nature of embedded systems, a single modeling language may not be suitable for all domains; thus, modeling languages are often domain-specific. To decrease the cost of defining and integrating domain-specific modeling languages and corresponding analysis and synthesis tools, the model-integrated approach is applied in a metamodeling architecture, where formal models of domain-specific modeling languages-called metamodels-play a key role in customizing and connecting components of tool chains. This paper discusses the principles and techniques of model-integrated embedded software development in detail, as well as the capabilities of the tools supporting the process. Examples in terms of real systems will be given that illustrate how the model-integrated approach addresses the physical nature, the assurance issues, and the dynamic structure of embedded software.

Provides an overview of the technical articles and features presented in this issue.

Composition and component-based design are key tools of modern software engineering for managing complexity. The concept of component-based design is straightforward: systems are built by composing software components with precisely defined interfaces using standardized interconnection mechanisms. "Plug-and-play" construction is supported by some underlying composition framework, such as CORBA, which facilitates the component interactions by providing standard services such as request broker, interface repository and others. Unfortunately, this solution tends to work only for building systems with a giant component using small "plug-ins" or for very small systems with a few components.The success of building applications based on a giant component is the result of strong restrictions on plug-in-s and their interaction: the dominant component (such as databases or web browsers) preserves the overall design integrity. In case of small systems, the system designers can preserve design integrity without extensive tool support. The problems of software composition for embedded systems are even harder. Embedded computers are surrounded by physical processes: they receive their inputs from sensors and send their outputs to actuators. Embedded computing devices, viewed from their sensor and actuator interfaces, act like physical processes with dynamics, noise, fault, size, power and other physical characteristics.It is not surprising that using current software technology, logical/functional composability does not imply physical composability. In fact, physical properties are not composable, rather, they appear as cross-cutting constraints in the development process. .Our vision with Model-Integrated Computing (MIC) is to answer the composition challenges of embedded systems the following way:.Modeling: The software development paradigm is changing from the use of dominantly imperative programming languages to dominantly declarative, Domain-Specific Modeling Languages (DSML). Complexity is managed by the use of multiple-view modeling and model analysis techniques.Model-Based Generators: The tight relationship between the model-based design and the modeled system is ensured by the extensive use of model-based generators, which translate the synthesized and verified models into code and other artifacts that form the application.The MIC toolset of ISIS has significant progress in implementing this vision.

Many large software systems are tightly integrated with their physical environments and must be adapted when their environment changes. Typically, software development methodologies do not place a great emphasis on modeling the system's environment, and hence environmental changes may lead to significant and complicated changes in the software. We argue that (1) the modeling of the environment should be an integral part of the process, and (2) to support software evolution, wherever possible, the software should be automatically generated. We present a model-integrated development approach that is capable of supporting cost effective system evolution in accordance with changes in the system's environment. The approach is supported by a "meta-architecture" that provides a framework for building model-based systems. This framework has been successfully used in various projects. One of these projects, a site-production flow visualization system for a large manufacturing operation, is analyzed in detail.

The building of custom monitoring, control, simulation and diagnostics applications for complex chemical plants necessitates the integration of models into the problem solving process. This paper describes a system and its practical applications that supports this activity. It is based on the Multigraph Architecture, which is a generic framework for building these model-based systems. The paper discusses the modeling paradigms used, how the applications are generated, and some practical, existing applications.

The design, implementation and deployment of computer applications tightly integrated with complex, changing environments is a difficult task. This paper presents the Multigraph Architecture (MGA) developed for building complex embedded systems. The MGA is a meta-level architecture which includes tools and methods to create domain specific model integrated program synthesis environments. These environments support the integrated modeling of systems independently from their implementation, include tools for model analysis and application specific model interpreters for the synthesis of executable programs.

We describe a programming environment which is being developed for the automatic generation of parallel image processing applications. Through the use of model-based software synthesis, we transparently create large grained data parallel applications which can be executed on arbitrary processor networks. The high-level abstractions provided by the modeling paradigm isolates the user from the complexity of the underlying implementation, allowing developers with little or no experience in parallel programming to rapidly create parallel applications. The data parallel modeling facilities perform the same tasks as the data alignment and distribution compiler directives of High Performance Fortran and the aggregate objects of pC++. However, we have found that by introducing the parallelism on the system level, instead of in the algorithm, we can use traditional compilers and leave the application specific code unchanged. This allows us to take advantage of existing well developed image processing code libraries. Here we describe a system which generates data parallel versions of applications created in Khoros, the popular image processing package developed by the University of New Mexico. This system retains the best qualities of Khoros: its interactive and experimental nature, and its visual interface, but adds the capability for automatically generating much higher performance parallel implementations when needed. This system demonstrate the suitability of the model-based approach for developing parallel imaging software.>

A real-time fault diagnostics system that is applicable for diagnosing large-scale plants is described. It uses a multiple aspect model of the plant including the hierarchical process model, the hierarchical component model, and the hierarchical fault model (HFM). HFM represents the spatial and temporal aspects of faulty behavior in the form of a hierarchical fault propagation digraph. The reasoning algorithm is based on the structural and temporal constraint enforcement, and is migrated to lower levels of HFM hierarchy. It is able to guarantee response times, perform nonmonotonic and temporal reasoning, operate continuously, accept asynchronous data, generate requests, perform time and diagnostic resolution tradeoffs, and diagnose single and most multiple fault cases.>

Structurally adaptive and dynamically reconfigurable systems are presented as important ingredients in the design and development of robust large-scale signal-processing systems for operation in complex nonstationary environments. The multigraph programming and execution environment (MPEE) is a complete, parallel, fully integrated programming and execution environment for structurally adaptive signal-processing systems. It provides a user-friendly environment for designing, programming, and executing such a signal-processing system. The MPEE is shown to have many advantages, due to graph-based processing, dynamic scheduling, multiprocessor programming capabilities, a hierarchical approach to system design, and graphic editors.>

A approach is proposed for the design and implementation of an intelligent monitoring and diagnostic system for a cogenerator plant. The approach is based on multiple-aspect modeling and model interpretation: sensory input signals from the plant are processed and interpreted in the context of various models of the cogenerator system. Experiences obtained during the development and the field test of the system have proved that the approach is viable even in real-time applications and results in considerable improvement in software technology.>

In a large class of intelligent machines, one of the tasks of the knowledge-based system components is to configure real-time signal processing systems. These systems implement low-level sensory or control algorithms according to the model of the system to be observed or controlled. If a change in the state of the model is detected, or the goal of the operation is modified, the real-time signal processing schemes have to be dynamically restructured. This article describes a system which has been developed for the knowledge-based generation and restructuring of real-time signal processing systems in parallel computing environments. the system is based on the integration of a hierarchical representation technique, the corresponding interpretation method, and an execution environment, which includes a graph model of computations.