ARMADA Middleware and Communication Services

Real-time embedded systems have evolved during the past several decades from small custom-designed digital hardware to large distributed processing systems. As these systems become more complex, their interoperability, evolvability and cost-effectiveness requirements motivate the use of commercial-off-the-shelf components. This raises the challenge of constructing dependable and predictable real-time services for application developers on top of the inexpensive hardware and software components which has minimal support for timeliness and dependability guarantees. We are addressing this challenge in the ARMADA project.ARMADA is set of communication and middleware services that provide support for fault-tolerance and end-to-end guarantees for embedded real-time distributed applications. Since real-time performance of such applications depends heavily on the communication subsystem, the first thrust of the project is to develop a predictable communication service and architecture to ensure QoS-sensitive message delivery. Fault-tolerance is of paramount importance to embedded safety-critical systems. In its second thrust, ARMADA aims to offload the complexity of developing fault-tolerant applications from the application programmer by focusing on a collection of modular, composable middleware for fault-tolerant group communication and replication under timing constraints. Finally, we develop tools for testing and validating the behavior of our services. We give an overview of the ARMADA project, describing the architecture and presenting its implementation status.     

A language-independent approach to black-box testing using Erlang as test specification language

Integration of reused, well-designed components and subsystems is a common practice in software development. Hence, testing integration interfaces is a key activity, and a whole range of technical challenges arise from the complexity and versatility of such components.     

Hardware/software codesign and rapid prototyping of embeddedsystems

The complexity and the short time to market of embedded systems require the use of automated techniques during the specification, implementation, and testing phases of such systems. Due to the cost requirements and the timing constraints of such systems, application-specific hardware solutions are often needed, making the codesign of hardware and software a major topic for the design automation of embedded systems. This article describes tools for the analysis, synthesis, and rapid prototyping of distributed embedded real-time systems and presents a complete design flow from specification to implementation     

Time-budgeting: a component based development methodology for real-time embedded systems

The design of a complex embedded control system involves integration of large number of components. These components need to interact in a timely fashion to achieve the system level end-to-end requirements. In practice, the component level timing specification consists of design attributes like component task mapping, task period and schedule definition but often lack details on their real-time (functional) requirements. As we observe, there is no systematic methodology in place for decomposing the feature level timing requirements into component level timing requirements. This paper proposes an early stage time-budgeting methodology to bridge the above gap. A salient proposal of this methodology is to consider parameterized component timing-requirements. A key step in the methodology involves computing a set of constraints by relating component requirements with feature requirements. This enables the separation of timing constraints from functionality decomposition, and facilitates early optimization of the component time-budget for a complex component based embedded system. This paper formalizes the proposed methodology by using Parametric Temporal Logic. A case study involving two advanced features from the automotive domain, namely Adaptive Cruise Control and Collision Mitigation is given to demonstrate the methodology.     

Sensitivity analysis of complex embedded real-time systems

The robustness of an architecture to changes is a major concern in the design of efficient and reliable state-of-the-art embedded real-time systems. Robustness is important during design process to identify if and in how far a system can accommodate later changes or updates, or whether it can be reused in a next generation product. In the product life-cycle, robustness helps the designer to perform changes as a result of product updates, integration of new components and subsystems, or modifications of the environment. In this paper we determine robustness as a performance reserve, the slack in performance before a system fails to meet timing requirements. This is measured as design sensitivity. Due to complex component interactions, resource sharing and functional dependencies, one-dimensional sensitivity analysis might not cover all effects that modifications of one system property may have on system performance. One reason is that the variation of one property can also affect the values of other system properties requiring new approaches to keep track of simultaneous parameter changes. In this paper we present a framework for one-dimensional and multi-dimensional sensitivity analysis of real-time systems. The framework is based on compositional analysis that is scalable to large systems. The one-dimensional sensitivity analysis combines a binary search technique with a set of formal equations derived from the real-time scheduling theory. The multi-dimensional sensitivity analysis engine consists of an exact algorithm that extends the one-dimensional approach, and a stochastic algorithm based on evolutionary search techniques.     

基于构件的嵌入式实时软件建模与分析

嵌入式实时软件具有严格的时间要求,任何时间错误都可能造成重大的经济损失甚至导致灾难性的后果。因此,在软件开发早期,对其时间需求进行形式化的分析和验证是非常重要的。本文提出一种基于构件的嵌入式实时软件建模与分析方法,该方法不仅可以检测出需求模型中的时间冲突,有助于保证嵌入式实时软件时间约束的正确性,而且也也使得分析结果具有可复用、可扩展的优点。     

An interface test model for hardware-dependent software and embedded OS API of the embedded system

An embedded system has a hierarchical structure including hardware-dependent software layer, operating system layer, and applications layer. Since the system has interfaces between the different layers that are tightly coupled and inter-dependent to each other, these interfaces are the focal area to be tested.This paper proposes an Embedded System's Interface Test Model (EmITM) to test hardware interfaces and OS interfaces. The EmITM provides a set of test items based on the interfaces when testing embedded software. We apply our model to embedded software test and analyze the test results.     

Principles of Built-In-Test for Run-Time-Testability in Component-Based Software Systems

This paper examines the motivations and expectations of Built-In-Test (BIT) techniques for Run-Time-Testability (RTT) in component-based software systems. The difficulties associated with testing and integrating fully encapsulated components lead to a requirement for testing interfaces. The format of these interfaces is explored at a high level of abstraction, and some possibilities for Built-In-Test (BIT) are described. BIT is concerned with the detection of error conditions arising internally to a component, or arising from erroneous component interactions, and the propagation of these error conditions to a system component having responsibility for error handling and/or recovery. The implications for testability, reliability and maintainability are discussed, and it is concluded that BIT offers potential for improved product quality. Whilst the proposed approach is considered appropriate for a wide range of software systems, issues related to real-time systems, such as deadlock and timing constraints are of particular interest.     

A formal method to real-time protocol interoperability testing

Interoperability testing is an important technique to ensure the quality of implementations of network communication protocol. In the next generation Internet protocol, real-time applications should be supported effectively. However, time constraints were not considered in the related studies of protocol interoperability testing, so existing interoperability testing methods are difficult to be applied in real-time protocol interoperability testing. In this paper, a formal method to real-time protocol interoperability testing is proposed. Firstly, a formal model CMpTIOA （communicating multi-port timed input output automata） is defined to specify the system under test （SUT） in real-time protocol interoperability testing; based on this model, timed interoperability relation is then defined. In order to check this relation, a test generation method is presented to generate a parameterized test behavior tree from SUT model; a mechanism of executability pre-determination is also integrated in the test generation method to alleviate state space explosion problem to some extent. The proposed theory and method are then applied in interoperability testing of IPv6 neighbor discovery protocol to show the feasibility of this method.     

嵌入式环境中CORBA对象资源定位研究与实现

传统CORBA对象资源定位(Corbaloc)实现在资源有限性、实时性、时间确定性和可裁剪性等方面不能完全满足嵌入式系统应用要求。提出一种模块化Corbaloc服务实现方法,力图解决实时性与时间确定性局限,实现嵌入式异构环境中的互操作。首先以Orbacus为例分析了传统实现的局限,其次设计并实现了模块化Corbaloc服务,最后在VxWorks上对两者进行了性能对比测试。     

工业以太网及OPC在智能建筑中的应用

随着全球信息化的高度发展,智能建筑的集成程度也越来越高。现在主要制约因素是智能建筑中各个集成子系统之间互联性和互操作性差,这些系统包括设备及软硬件系统。介绍了工业以太网、OPC及OPC DX技术在智能建筑中的应用。工业以太网已经成功应用在工业控制领域,它良好的开放性及在工业控制网络和信息网络整合方面的优势使智能建筑的信息集成度大大提高。OPC这种软件数据交换标准接口和规程,消除了使用数据的应用程序与为数据服务的应用程序之间的隔阂,使不同系统可以在异构计算机环境下无缝连接,同时实现远程实时控制访问。它们的应用极大提高了智能建筑的集成化程度。     

Model driven middleware: A new paradigm for developing distributed real-time and embedded systems

Distributed real-time and embedded (DRE) systems have become critical in domains such as avionics (e.g., flight mission computers), telecommunications (e.g., wireless phone services), tele-medicine (e.g., robotic surgery), and defense applications (e.g., total ship computing environments). These types of system are increasingly interconnected via wireless and wireline networks to form systems of systems. A challenging requirement for these DRE systems involves supporting a diverse set of quality of service (QoS) properties, such as predictable latency/jitter, throughput guarantees, scalability, 24x7 availability, dependability, and security that must be satisfied simultaneously in real-time. Although increasing portions of DRE systems are based on QoS-enabled commercial-off-the-shelf (COTS) hardware and software components, the complexity of managing long lifecycles (often ∼15-30 years) remains a key challenge for DRE developers and system integrators. For example, substantial time and effort is spent retrofitting DRE applications when the underlying COTS technology infrastructure changes.This paper provides two contributions that help improve the development, validation, and integration of DRE systems throughout their lifecycles. First, we illustrate the challenges in creating and deploying QoS-enabled component middleware-based DRE applications and describe our approach to resolving these challenges based on a new software paradigm called Model Driven Middleware (MDM), which combines model-based software development techniques with QoS-enabled component middleware to address key challenges faced by developers of DRE systems — particularly composition, integration, and assured QoS for end-to-end operations. Second, we describe the structure and functionality of CoSMIC (Component Synthesis using Model Integrated Computing), which is an MDM toolsuite that addresses key DRE application and middleware lifecycle challenges, including partitioning the components to use distributed resources effectively, validating software configurations, assuring multiple simultaneous QoS properties in real-time, and safeguarding against rapidly changing technology.     

Specifying safety-critical systems with a decidable duration logic

Punctual timing constraints are important in formal modelling of safety-critical real-time systems. But they are very expensive to express in dense time. In most cases, punctuality and dense-time lead to undecidability. Efforts have been successful to obtain decidability; but the results are either non-primitive recursive or nonelementary. In this paper we propose a duration logic which can express quantitative temporal constraints and punctuality timing constraints over continuous intervals and has a reasonable complexity. Our logic allows most specifications that are interesting in practice, and retains punctuality. It can capture the semantics of both events and states, and incorporates the notions duration and accumulation. We call this logic ESDL (the acronym stands for Event- and State-based Duration Logic). We show that the satisfiability problem is decidable, and the complexity of the satisfiability problem is NEXPTIME. ESDL is one of a few decidable interval temporal logics with metric operators. Through some case studies, we also show that ESDL can specify many safety-critical real-time system properties which were previously specified by undecidable interval logics or their decidable reductions based on some abstractions.     

Software architectures to integrate workflow engines in science gateways

Science gateways often rely on workflow engines to execute applications on distributed infrastructures. We investigate six software architectures commonly used to integrate workflow engines into science gateways. In tight integration, the workflow engine shares software components with the science gateway. In service invocation, the engine is isolated and invoked through a specific software interface. In task encapsulation, the engine is wrapped as a computing task executed on the infrastructure. In the pool model, the engine is bundled in an agent that connects to a central pool to fetch and execute workflows. In nested workflows, the engine is integrated as a child process of another engine. In workflow conversion, the engine is integrated through workflow language conversion. We describe and evaluate these architectures with metrics for assessment of integration complexity, robustness, extensibility, scalability and functionality. Tight integration and task encapsulation are the easiest to integrate and the most robust. Extensibility is equivalent in most architectures. The pool model is the most scalable one and meta-workflows are only available in nested workflows and workflow conversion. These results provide insights for science gateway architects and developers.     

嵌入式软件与硬件的集成测试过程研究

嵌入式软件自身软硬件结合的复杂性及其质量的重要性,造成其软件测试的特殊性,就是在执行正常软件测试的单元测试、集成测试、系统测试的过程中,还要考虑到软件与硬件的兼容问题,即需要进行软硬件集成测试。本文首先介绍了嵌入式软件与硬件集成测试的相关概念,然后归纳提出了软硬件集成测试过程,结合当前软件测试理论前沿知识,把该测试过程进行重组和改进,并给出了测试模型。     

A software stack for next-generation automotive systems on many-core heterogeneous platforms

The next-generation of partially and fully autonomous cars will be powered by embedded many-core platforms. Technologies for Advanced Driver Assistance Systems (ADAS) need to process an unprecedented amount of data within tight power budgets, making those platform the ideal candidate architecture. Integrating tens-to-hundreds of computing elements that run at lower frequencies allows obtaining impressive performance capabilities at a reduced power consumption, that meets the size, weight and power (SWaP) budget of automotive systems. Unfortunately, the inherent architectural complexity of many-core platforms makes it almost impossible to derive real-time guarantees using “traditional” state-of-the-art techniques, ultimately preventing their adoption in real industrial settings. Having impressive average performances with no guaranteed bounds on the response times of the critical computing activities is of little if no use in safety-critical applications. Project Hercules will address this issue, and provide the required technological infrastructure to exploit the tremendous potential of embedded many-cores for the next generation of automotive systems. This work gives an overview of the integrated Hercules software framework, which allows achieving an order-of-magnitude of predictable performance on top of cutting-edge Commercial-Off-The-Shelf components (COTS). The proposed software stack will let both real-time and non real-time application coexist on next-generation, power-efficient embedded platforms, with preserved timing guarantees.     

基于嵌入式实时操作系统的驱动框架

嵌入式设备随着应用领域的扩展呈现出多样性以及复杂性，而嵌入式实时系统普遍不具有良好的设备驱动体系结构，造成驱动开发困难、可移植性差。该文给出了一种嵌入式实时操作系统下的驱动框架，支持各种设备及总线接口，设计了一种快速的设备中断机制，符合嵌入式实时系统的强实时、高可靠的特点，能够满足开发各种嵌入式系统。     

信息安全风险管理系统的设计与实现

嵌入式设备随着应用领域的扩展呈现出多样性以及复杂性,而嵌入式实时系统普遍不具有良好的设备驱动体系结构,造成驱动开发困难、可移植性差.该文给出了一种嵌入式实时操作系统下的驱动框架,支持各种设备及总线接口,设计了一种快速的设备中断机制,符合嵌入式实时系统的强实时、高可靠的特点,能够满足开发各种嵌入式系统.     

A Modular Approach to Programming Distributed Real-Time Systems

Conventional real-time programs associate real-time requirements with individual commands in a program. This approach has three weaknesses. First, it intermixes two different design concerns: functional correctness and temporal correctness. Second, by mixing real-time requirements with program statements it makes it harder, and in some cases infeasible, to specify constraints between objects. Third, it limits the ability to independently modify either the timing constraints or the representations of objects. We describe a new approach that separates real-time constraints from functional aspects of an application; real-time constraints are described by synchronization code between the interfaces of objects. Objects in our system are defined using a real-time variant of the Actor model. We define a high-level programming language construct calledRTsynchronizer, which specifies a collection of temporal constraints between actors. Thus, our approach separates what an object does from when it does it. Such separation also facilitates the ability to dynamically modify real-time constraints. We illustrate the use of RTsynchronizers by a number of examples and then describe a meta-architecture that can be used to implement RTsynchronizers.