Ted Bapty

Model-integrated development of embedded software

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.

Handling crosscutting constraints in domain-specific modeling

An Aspect-Oriented (AO) approach can be beneficial at different stages of the software lifecycle and at various levels of abstraction. Whenever the description of a software artifact exhibits crosscutting structure, the principles of modularity espoused by AO offer a powerful technology for supporting separation of concerns. We have found this to be true especially in the area of domain-specific modeling [3].

MULTIGRAPH: an architecture for model-integrated computing

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.

Self-adaptive software for signal processing

Digital signal processing (DSP) systems are widely used in communication, medical, sonar, radar, equipment health monitoring and many other applications. Frequently, the signal processing system has to meet real-time requirements and provide very large throughput. For example, modern automatic target recognition systems operate with a processing throughput in excess of 10 Gflop per second. In real-time vibration analysis used for turbine engine testing [1], the aggregate sustained computation rate is also in the Gflop range. The high performance requires the use of computing platforms that include the combination of dedicated hardware processors, and general-purpose computers forming a hybrid, parallel/distributed configuration. Complexity, heterogeneity of the computing environment, and real-time operation make the software development for digital signal processing difficult and expensive.

An approach for supporting aspect-oriented domain modeling

This paper describes a technique for improving separation of concerns at the level of domain modeling. A contribution of this new approach is the construction of support tools that facilitate the elevation of crosscutting modeling concerns to first-class constructs in a type-system. The key idea is the application of a variant of the OMG Object Constraint Language to models that are stored persistently in XML. With this approach, weavers are generated from domain-specific descriptions to assist a modeler in exploring various alternative modeling scenarios. The paper examines several facets of Aspect-Oriented Domain Modeling (AODM), including: domain-specific model weavers, a language to support the concern separation, an overview of code generation issues within a meta-weaver framework, and a comparison between AODM and AOP. An example of the approach is provided, as well as a description of several future concepts for extending the flexibility within AODM.

Model-integrated Tools for the Design of Dynamically Reconfigurable Systems

Several classes of modern applications demand very high performance from systems with minimal resources. These applications must also be flexible to operate in a rapidly changing environment. Achieving high performance from limited resources demands application-specific architectures, while flexibility requires architectural adaptation capabilities. Reconfigurable computing devices promise to meet both needs. While these devices are currently available, the issue of how to design these systems is unresolved. This paper describes an environment for design capture, analysis and synthesis of dynamically adaptive computing applications. The representation methodology is captured in a Domain-Specific, Model-Integrated Computing framework. Formal analysis tools are integrated into the design flow to analyze the design space to produce a constrained set of solutions. HW/SW Co-simulations verify the function of the system prior to implementation. Finally, a set of hardware and software subsystems are synthesized to implement the multi-modal, dynamically adaptive application. The application executes under a runtime environment, which supports common execution semantics across software and hardware. An application example is presented.

Generators for Synthesis of QoS Adaptation in Distributed Real-Time Embedded Systems

This paper presents a model-driven approach for generating Quality-of-Service (QoS) adaptation in Distributed Real-Time Embedded (DRE) systems. The approach involves the creation of high-level graphical models representing the QoS adaptation policies. The models are constructed using a domain-specific modeling language - the Adaptive Quality Modeling Language. Multiple generators have been developed using the Model-Integrated Computing framework to create low-level artifacts for simulation and implementation of the adaptation policies that are captured in the models. A simulation generator tool synthesizes artifacts for Matlab Simulink/Stateflow® (a popular commercial tool), providing the ability to simulate and analyze the QoS adaptation policy. An implementation generator creates artifacts for Quality Objects, a QoS adaptation software infrastructure developed at BBN, for execution of QoS adaptation in DRE systems. A case study in applying this approach to an Unmanned Aerial Vehicle - Video Streaming application is presented. This approach has goals that are similar to those specified in the OMGs Model-Driven Architecture initiative.

Model-based software synthesis

The knowledge-representation and compilation techniques used in a model-based, automatic software synthesis environment are discussed. The environment was used to build Caddmus, a system with more than 250 cooperating processes. The real-time execution environment automatically generates a macro-dataflow computation from declarative models. Central to the approach is the Multigraph Architecture, which provides the framework for model-based synthesis in real-time, parallel-computing environments. Application of Caddmus to analysis of all data related to testing new and redesigned turbine engines is described.<<ETX>>

Uniform execution environment for dynamic reconfiguration

Modern high-performance embedded systems face many challenges. Systems must function in rapidly changing environments. Power/size constraints limit hardware size, while extreme performance requirements demand algorithm specific architectures. Hardware architectures must structurally adapt to achieve high performance with changing algorithms. Reconfigurable computing devices offer the promise of architectures that change in response to the changing environment. The primary difficulty in this approach lies in system design. A model-integrated approach is used in the design capture and synthesis of these systems. The target systems are built on a heterogeneous computing platform including configurable hardware, ASIC and general purpose processors and DSPs. This project is a DARPA Adaptive Computing Systems funded effort, involving close cooperation with US ARMY/AMICOM.

OpenMETA: A Model- and Component-Based Design Tool Chain for Cyber-Physical Systems

Model- and component-based design have yielded dramatic increase in design productivity in several narrowly focused homogeneous domains, such as signal processing, control and aspects of electronic design. However, significant impact on the design and manufacturing of complex cyber-physical systems (CPS) such as vehicles has not yet been achieved. This paper describes challenges of and solution approaches to building a comprehensive design tool suite for complex CPS. The primary driver for the OpenMETA tool chain was to push the boundaries of the “correct-by-construction” principle to decrease significantly the costly design-build-test-redesign cycles in design flows. In the discussions we will focus on the impact of heterogeneity in modeling CPS. This challenge is compounded by the need for rapidly evolving the design flow by changing/updating the selection of modeling languages, analysis and verification tools and synthesis methods. Based on our experience with the development of OpenMETA and with the evaluation of its performance in a complex CPS design challenge we argue that the current vertically integrated, discipline-specific tool chains for CPS design need to be complemented with horizontal integration layers that support model integration, tool integration and design process integration. This paper will examine the OpenMETA technical approach to construct the new integration layers, provides and overview of the technical framework we established for their implementation and summarize our experience with their application.