As Artificial Intelligence makes its way to edge devices, it becomes necessary to understand how Learning Enabled Components (LECs) will perform in resource-limited environments. A two-part evaluation procedure is developed here using a combination of testing data to evaluate the LECs' performance, including but not limited to time-domain performance, independent of the target system, for assessing the LEC within the context of system it will be deployed. The target system for this evaluation is a BlueROV2 device simulated in Gazebo using the UUV Simulator package that has been configured to function as an autonomous underwater vehicle (AUV) for infrastructure inspection. The task of the vehicle was to detect and track an underwater pipeline using a side-scan sonar. Nine LEC architectures were constructed in Tensorflow, trained, quantized, and deployed on a Google Edge Tensor Processing Unit (TPU) LEC accelerator for evaluation using generated data and deployed as a hardware-in-the-loop simulation using the BlueROV2 model. It was found that the Mean IoU metric in the evaluations that used sonar data from (simulated) pipes that were smaller than the ones used in the training set had the strongest correlation with the LECs ability to continue to track an underwater pipe during the mission simulations. The size of the model did not increase the time required to load a sonar image on the edge device and interpret the sonar images suggesting that neither model size, nor inference time affected the results of the evaluation. The architecture of a given LEC does not guarantee its performance within the context of an AUV executing a pipe inspection task and, therefore, must be evaluated within the context of the full system to properly characterize its performance.

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.

System design typically involves the specification of requirements and evaluation of the design with respect to those requirements. The requirements describe and quantify the desired physical and software properties of the system. Evaluating requirements often involves performing domain-specific analysis. Domain-specific analyses are spread across a wide range of domains and tools, e.g., geometric properties vs. dynamics behavior of the system. Different analysis types require different tools, where each tool targets a narrow range of domains or a single domain. For large system designs, the requirements could be too complex to be evaluated by a single analysis tool. In such cases, the coupling of multiple domains and analysis tools is inevitable, and managing these interactions can prove to be difficult, often leading to wasted efforts. In this paper we present an analysis-driven rapid design process for Cyber-Physical Systems that spans multiple domain models and various analysis tools from a wide range of domains, and helps to reduce the design time through the following: (1) revealing and tracking instances of cross-domain coupling, thereby reducing design time; (2) disqualifying non-viable design configurations; and (3) using analysis templates for continuous design evolution with respect to the requirements; minor adjustments to requirements can be done seamlessly, without a complete redesign of the existing reusable analysis templates. Furthermore, we present a case study for an automotive driveline design to demonstrate an implementation of this process.

The paper presents a smartphone-based shooter localization system. As muzzle blasts are difficult to detect at longer distances and consequently present higher false detection rates, the system relies on shockwaves only. Each sensor uses four microphones to detect the Angle of Arrival and the length of the shockwave. This information, along with the sensor's own GPS coordinates, are shared among nearby smartphones. Assuming a known weapon type, it then proceeds to estimate the two possible projectile trajectory candidates for each sensor that are consistent with the observations in the horizontal plane of the sensors. A simple clustering algorithm identifies the correct projectile trajectory relying on as few as two sensors. The trajectory is then used to estimate the bearing to the shooter relative to each sensor. The paper presents the overall system architecture, the design of the sensor node that interfaces with the smartphone, the trajectory and bearing estimation algorithms, and the evaluation of the system based on a field experiment.

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.

Large scientific computing clusters require a distributed dependability subsystem that can provide fault isolation and recovery and is capable of learning and predicting failures, to improve the reliability of scientific workflows. In this paper, we outline the key ideas in the design of a Scientific Computing Autonomic Reliability Framework (SCARF) for large computing clusters used in the Lattice Quantum Chromo Dynamics project at Fermi Lab.

Abstract In model‐driven engineering, it is often desirable to evaluate different design alternatives as they relate to scalability issues of the modeled system. A typical approach to address scalability is model replication, which starts by creating base models that capture the key entities as model elements and their relationships as model connections. A collection of base models can be adorned with necessary information to characterize a specific scalability concern as it relates to how the base modeling elements are replicated and connected together. In current modeling practice, such a model replication is usually accomplished by scaling the base model manually. This is a time‐consuming process that represents a source of error, especially when there are deep interactions between model components. As an alternative to the manual process, this paper presents the idea of automated model replication through a model transformation process that expands the number of elements from the base model and makes the correct connections among the generated modeling elements. The paper motivates the need for model replication through case studies taken from models supporting different domains. Copyright © 2008 John Wiley & Sons, Ltd.

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.

High-energy physics experiments require an extraordinary amount of real-time computation, and the computers implementing the online data processing must be very reliable because of the large cost associated with operating the facilities and the potential for loss of irreplaceable data. Conventional redundancy-based fault tolerance and adaptive approaches are not appropriate because of the tremendous system cost (fault tolerance is limited to a maximum of 10% overhead). In this work, we developed a framework for building robust embedded systems, which utilizes an autonomic reflex-healing approach to achieve fault tolerance. Components of the framework implement user-defined failure adaptation strategies within the context of a large-scale embedded environment. The tools embrace a model-based approach combining design specification and code-generation for both simulation and system implementation. In this paper we present the concepts and entities of the reflex and healing framework

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.

Visual modeling languages are often used today in engineering domains, Mathworks' Simulink/Stateflow for simulation, signal processing and controls being the prime example. However, they are also becoming suitable for implementing other computational tasks, like model transformations. In this paper we briefly introduce GReAT: a visual language with simple, yet powerful semantics for implementing transformations on attributed, typed hypergraphs with the help of explicitly sequenced graph transformation rules. The main contribution of the paper is a Simulink/Stateflow code generator that generates executable code (running on a distributed platform) from the visual input models. The paper provides an overview of the algorithms used and their realization in GReAT.

This paper presents an approach for dynamic software reconfiguration in sensor networks. Our approach utilizes explicit models of the design space of the embedded application. The design space is captured by formally modeling all the software components, their interfaces, and their composition. System requirements are expressed as formal constraints on QoS parameters that are measured at runtime. Reconfiguration is performed by transitioning from one point of the operation space to another based on the constraints. We demonstrate our approach using simulation results for a simple sensor network that performs one-dimensional tracking.

Dependable computer systems hosting critical commerce, transportation, and military applications, among others, must satisfy stringent quality-of-service (QoS) requirements. However, as these systems become increasingly complex, maintaining the desired QoS by manually tuning the numerous performance-related parameters are very difficult. This paper develops a generic online control framework to design self-managing computer systems. The proposed approach explores a limited region of the system state-space at each time step and decides the best control action accordingly. We present two case studies to demonstrate the practicality of the proposed control framework.

In this paper we present a model-based approach for designing quality of service adaptive applications. We have developed a prototype distributed QoS modeling environment (DQME) that captures important elements of dynamic QoS adaptation at the model level. This modeling environment is designed independent of and can be integrated with, specific application domains to capture their QoS features and adaptation strategies. It combines the domain-specific modeling capability of the generic modeling environment with the QoS adaptation mechanisms of the quality objects middleware framework. DQME captures both the QoS and the functional concerns of distributed real-time embedded systems, and provides clear separation of these two. Integrated code-synthesis tools facilitate code generation and model refinement. We present a signal analyzer case study to demonstrate the use of the DQME modeling tool in real world applications.

In this paper, we present an approach for QoS management that can be applied to a general class of real-time distributed computation systems. In the proposed approach, a switching hybrid system model is used to represent the system. In this setting, the QoS specifications are transformed into set-point specifications and a limited-horizon online supervisory controller is used to move the system to the optimal operation point.

In this paper we present an approach for QoS management that can be applied for a general class of real-time distributed computation systems. In this paper, the QoS adaptation problem is formulated based on a utility function that measures the relative performance of the system. A limited-horizon online supervisory controller is used for this purpose. The online controller explores a limited region of the state-space of the system at each time step and decides the best action accordingly. The feasibility and accuracy of the online algorithm can be assessed at design time.

No abstract available.

The design of modern high-performance embedded systems is challenging. Power and size constraints limit hardware size, while performance requirements demand algorithm-specific architectures. A model-integrated approach can be used in the design capture and synthesis of these systems. A domain-specific graphical system design environment allows the capture of system requirements, design information and alternatives, and of available processing resources in the form of models. A model interpretation process generates architecture specifications and compilable code. A typical first step in designing complex systems is to develop a simulation-based prototype. After functional verification of the prototype, system components are implemented, each tailored to a particular target platform. Only after all components are implemented can system integration be addressed, often uncovering inconsistencies between components and forcing costly redesign. This paper describes an extension of a model-integrated design environment and runtime system. Simulation-based components are included in system models. A simulation engine is interfaced to a runtime environment, allowing simulation components to run in the loop with nonsimulation based components. The extended environment allows prototype synthesis from system models and automates the integration of implemented components into the system. Further, the extended environment provides the designer with a powerful visualization and debugging tool.