No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
A time-triggered data distribution service for FTT-CORBA
Abstract
FTT-CORBA is a middleware architecture aimed at synchronizing the task activations of a distributed system according to a plan that may be changed at runtime. In this architecture tasks are wrapped within CORBA methods that are activated by a central node, the Orchestrator, over a LAN. Previous versions of FTT-CORBA focused on CPU-bound applications in which the communication time was neglectable. However, in some cases, this assumption is not valid. This work presents an add-on service, integrated within the FTT-CORBA middleware, aimed at minimizing the interference among task activation and data distribution messages. By using this new service the Orchestrator will be capable of controlling the transmission of data distribution packages from the distributed nodes by dynamically allocating them in specific time slots.
... It provides architecture, to orchestrate the application of mission services in both near-real-time and real-time environments. A middleware architecture FTT-CORBA for synchronising the task of a distributed system is proposed by Noguero and Calvo (2012). Important examples of middleware currently in use are Java remote method invocation (RMI), Microsoft component object model (COM) and common object request broker architecture (CORBA). ...
Networked control system (NCS) consists of controlled distributed nodes while an orchestrator functions as a central coordinator for controlling the distributed tasks. The NCSs have challenges of coordination and right execution sequencing of operations. This paper proposes a framework named controlled orchestrator (COrch) for coordinating and sequencing the tasks of NCSs. An experiment was performed with three robotic vehicles that are considered as individual control system. Furthermore, the proposed orchestrator COrch decided the sequencing of operations of the robots while performing obstacle avoidance task for spatially distributed robots in parallel. COrch is used to control this task by utilising the concept of remote method invocation (RMI) and multithreading. RMI is used to prepare the software for controlling the robots at remote end while multithreading is used to perform parallel and synchronise execution of multiple robots. The remote end software generates signals for sequential, parallel and hybrid mode execution.
... Fig. 3 reproduces this new layer and its interaction with some of the OSI layers. In [29,30] the authors present the FTT-CORBA middleware architecture aimed at synchronizing the task activations of a distributed system according to a plan that may be changed at run-time; tasks are wrapped as CORBA methods activated by a central node, the Orchestrator, over a LAN. This architecture can be used at CPS. ...
Cyber-Physical Systems (CPS) integrate embedded computers that control physical processes. Application domains for CPS may be found in intelligent buildings, healthcare, transportation and factory automation, among many others. Typically, they are based on low profile computing elements, such as sensors and actuators that must communicate to carry out complex tasks. They must address certain issues such as managing available resources and service redundancy, as well as solving heterogeneity. In particular, managing communication issues can be relatively complex. In this scenario, middleware technologies can help developers in the design of state-of-the-art CPS. This work describes the design principles of CPS that require cooperation. More specifically, it presents a generic family of logical information exchange and cooperation topologies capable of adapting dynamically to changes in the environment. These topologies may be implemented on top of several middleware specifications as a means for managing distributed resources and service redundancy of CPS at run-time.
... As for FTT-CORBA, the authors have measured the performance of the middleware in terms of task activation jitter for periodic tasks and communication latencies. The results of the laboratory tests [10] demonstrated that FTT-CORBA introduced small jitter in the system (~600 μs) and that it succeeded in reducing the average latencies of high priority communication messages. ...
Cyber Physical Systems (CPS) are a special type of ubiquitous systems where control theory, communications and real-time computing are combined in embedded applications that interact with the physical world. The development of these applications becomes more complex when real-time and other non-functional requirements are to be satisfied. This paper presents a time-triggered middleware architecture that provides fault tolerance and dynamic reconfiguration at run-time taking into account the available resources of the underlying infrastructure, i.e. devices and communication networks. This architecture aims at easing the development of ubiquitous applications based on CPS. The paper provides an overview of the design of the architecture and discusses some implementation issues.
... In [12] and [24] the authors present a middleware architecture, the so called FTT-CORBA, aimed at synchronizing the task activations of a distributed system according to a plan that may be changed at run-time. In this architecture tasks are wrapped as CORBA methods that are activated by a central node, the Orchestrator, over a LAN. ...
Cyber-Physical Systems (CPS) are integrations of computation and physical processes. This kind of systems is being increasingly used in different domains such as healthcare, transportation, process control, manufacturing or electric power grids. CPS interact with the physical world and must operate dependably, safely, securely, efficiently and, frequently, in real-time. Consequently, they require new computing and networking technologies capable of supporting them adequately in environments qualitatively different from those found in general purpose computing. This paper analyzes the applicability of different middleware technologies as data distribution means for CPS.
... As for FTT-CORBA, the authors have measured the performance of the middleware in terms of task activation jitter for periodic tasks and communication latencies. The results of the laboratory tests [10] demonstrated that FTT-CORBA introduced small jitter in the system (~600 μs) and that it succeeded in reducing the average latencies of high priority communication messages. ...
There is an increasing number of Ambient Intelligence (AmI) systems that are time-sensitive and resource-aware. From healthcare to building and even home/office automation, it is now common to find systems combining interactive and sensing multimedia traffic with relatively simple sensors and actuators (door locks, presence detectors, RFIDs, HVAC, information panels, etc.). Many of these are today known as Cyber-Physical Systems (CPS). Quite frequently, these systems must be capable of (1) prioritizing different traffic flows (process data, alarms, non-critical data, etc.), (2) synchronizing actions in several distributed devices and, to certain degree, (3) easing resource management (e.g., detecting faulty nodes, managing battery levels, handling overloads, etc.). This work presents FTT-MA, a high-level middleware architecture aimed at easing the design, deployment and operation of such AmI systems. FTT-MA ensures that both functional and non-functional aspects of the applications are met even during reconfiguration stages. The paper also proposes a methodology, together with a design tool, to create this kind of systems. Finally, a sample case study is presented that illustrates the use of the middleware and the methodology proposed in the paper.
Video traffic is increasingly used in modern factory automation applications in order to improve the quality of the processes. However, since they require high bandwidth it may be difficult for critical applications to adapt dynamically to bandwidth requirements that may change in time, without affecting the performance of the overall applications, especially when they are time-sensitive. In this scenario, the use of high-level middleware architectures may ease this task by providing mechanisms to reconfigure the systems at run-time. This work shows how the so-called FTT-MA (Flexible Time-Triggered Middleware Architecture) may be used in a sample application in order to manage the bandwidth of a laboratory application in which several video cameras are involved. FTT-MA hides the complexity of modifying the bandwidth requirements of the application at runtime according to the needs of the application.
Virtualization technology reduces the costs for server installation, operation, and maintenance and it can simplify development of distributed systems. Currently, there are various virtualization technologies such as Xen, KVM, VMware, and etc, and all these technologies support various virtualization functions individually on the heterogeneous platforms. Therefore, it is important to be able to integrate and manage these heterogeneous virtualized resources in order to develop distributed systems based on the current virtualization techniques. This paper presents an integrated management system that is able to provide information for the usage of heterogeneous virtual resources and also to control them. The main focus of the system is to abstract various virtual resources and to reconfigure them flexibly. For this, an integrated management system has been developed and implemented based on a libvirt-based virtualization API and data distribution service (DDS).
Virtualization technology reduces the costs for server installation, operation, and maintenance and it can simplify the building of distributed systems. Currently, there are various types of virtualization technologies such as Xen, KVM, VMware, etc, and these technologies support various virtualization functions individually on heterogeneous platforms. Therefore, it is required to integrate and manage these heterogeneous virtualized resources in order to build a distributed system supporting current virtualization techniques. In this paper, we propose an integrated management system for managing heterogenous virtual resources. The proposed system is developed based on the following two techniques: a libvirt-based virtualization API and Data Distribution Service (DDS). Libvirt-based virtualization API is to extract information of heterogeneous virtual resources and to control them. DDS is to transmit in real-time the state information and control commands of virtualized resources.
It is well known that modern factory automation applications must be able to adapt to changes in the production requirements. Since most manufacturing applications are distributed, it may be necessary to reconfigure several devices simultaneously. Unfortunately, dealing with reconfiguration is a complex issue for the developers of the applications, especially when applications are time-sensitive or resources are scarce. In this scenario, the use of high-level middleware architectures may provide solutions to these problems in order to avoid reinventing the wheel. This work illustrates how the FTT-MA (Flexible Time-Triggered Middleware Architecture) could be used to reconfigure manufacturing applications by means of a laboratory application.
Composition of Web services helps to lower the time-to-market of service-based applications by reusing the functionality provided by ser-vices that are already deployed at geographically distributed locations. Due to the diversity of services, the client acceptance of new applica-tions is determined more and more by non-functional aspects, such as Quality of Service, or cost. The throughput, response time, and commu-nication cost of composite services depend on the characteristics of each component service involved, as well as on the manner these components are tied together. Research has shown that distributed data-flow models can offer better performance and lower communication costs in service composition than centralized models. However, an impediment towards data-flow distribution in Web services composition is that the compo-nent services cannot exchange data directly without central mediation. We propose therefore a non-intrusive approach for achieving data distri-bution among Web services that are engaged in composition, bringing minimal extensions to the underlying middleware and not tightening the coupling between them.
The Real-Time CORBA and minimum CORBA specifications are important
steps towards defining standard-based middleware which can satisfy
real-time requirements in an embedded system. This real-time middleware
must be based on a real-time operating system (RTOS) and a real-time
network. This article presents a new time-triggered Ethernet protocol
that has been implemented under RTLinux. Furthermore it describes a
Real-Time CORBA implementation called ROFES, which is based on this new
real-time network
Through several giant evolutionary steps, Ethernet has become an almost ubiquitous technology for communication. Being versatile enough to be employed in new and various fields of application, it is now making inroads in factories. However, automated systems are different from many other applications of Ethernet,first and foremost because they require the network technology to deliver real-time performance. In the present study, a number of critical aspects of Ethernet, usually referred to as an Industrial Ethernet, are examined. More specifically, there is a focus on the application-to-application delay and jitter characteristics of such networks, when using Internet protocols such as UDP and TCP. It is demonstrated how important it is to take control of the latency in the station nodes, since the main communication delays occur inside the nodes, and different solutions are presented for controlling these delays. In particular, a priority-based protocol stack is assessed. The results show that real-time, Ethernet-based IP communication is now adequate even for demanding automated applications. In this paper, substation automation (power distribution) is used as an example of a demanding automation system.
Ethernet was not originally developed to meet the requirements of real-time industrial automation systems and it was commonly considered unsuited for applications at the field level. Hence, several techniques were developed to make this protocol exhibit real-time behavior, some of them requiring specialized hardware, others providing soft-real-time guarantees only, or others achieving hard real-time guarantees with different levels of bandwidth efficiency. More recently, there has been an effort to support quality-of-service (QoS) negotiation and enforcement but there is not yet an Ethernet-based data link protocol capable of providing dynamic QoS management to further exploit the variable requirements of dynamic applications. This paper presents the FTT-Ethernet protocol, which efficiently supports hard-real-time operation in a flexible way, seamlessly over shared or switched Ethernet. The FTT-Ethernet protocol employs an efficient master/multislave transmission control technique and combines online scheduling with online admission control, to guarantee continued real-time operation under dynamic communication requirements, together with data structures and mechanisms that are tailored to support dynamic QoS management. The paper includes a sample application, aiming at the management of video streams, which highlights the protocol's ability to support dynamic QoS management with real-time guarantees.
This paper outlines opportunities and challenges in the development of next-generation embedded devices, applications, and services, resulting from their increasing intelligence - it plots envisioned future directions for intelligent device networking based on service-oriented high-level protocols, in particular as regards the industrial automation sector - and outlines the approach adopted by the Service Infrastructure for Real-Time Embedded Networked Applications project, as well as the business advantages this approach is expected to provide.
The CORBA Event Service provides a flexible model for asynchronous communication among objects. However, the standard CORBA Event Service specification lacks important features required by real-time applications. For instance, operational flight programs for fighter aircraft have complex realtime processing requirements. This paper describes the design and performance of an object-oriented, real-time implementation of the CORBA Event Service that is designed to meet these requirements. This paper makes three contributions to the design and performance measurement of object-oriented real-time systems. First, it illustrates how to extend the CORBA Event Service so that it is suitable for real-time systems. These extensions support periodic rate-based event processing and efficient event filtering and correlation. Second, it describes how to develop object-oriented event dispatching and scheduling mechanisms that can provide real-time guarantees. Finally, the paper presents benchmarks that demonstrate the performance tradeoffs of alternative concurrent dispatching mechanisms for real-time Event Services. 1
FTT-CORBA is a middleware architecture aimed at synchronizing the task activations of a distributed system according to a plan that may be changed in run-time. In this architecture tasks are wrapped as CORBA methods that are activated by a central node, the Orchestrator. FTT-CORBA allows loading and managing distributed applications in run-time by means of an open interface. It also allows monitoring the status of the distributed system. This paper presents FTT-Modeler, a support tool that allows the user to model and implement distributed applications, simulate FTT-CORBA systems and manage an FTT-CORBA distributed system in runtime.
This paper shows the early experiences transferring architectural knowledge from Academic to Industry within an R + D + I project. This is done through the design and development of an Intelligent Transportation System (ITS) Architecture following SOA and RM-ODP principles, to facilitate openness, reusability, scalability and interoperability. Rationale selection of standards, technologies and platforms, considering system's requirements (real time, cost ellipsis) has been done. An iterative agile development process, with incremental stages from design to final prototype, has been used. Early outcomes are centered in two services; multimedia flow management and notification. They have been developed using CORBA and are embedded in system's devices.
Today's distributed real-time systems require flexibility to adapt to evolving functional and non-functional requirements in run-time. The authors have presented in previous works a middleware architecture based on the Flexible Time-Triggered (FTT) paradigm that allows creating flexible real-time distributed applications over CORBA. This paper focuses on the design of the central node of the architecture, the Orchestrator, which implements services for dynamic application composition, real-time scheduling and synchronization, and system monitoring.
Modern distributed real-time systems (DRTS) are typically formed by several heterogeneous networked devices. Sometimes these devices must adapt to dynamic environments in which devices may join or leave the network and must respond in run-time to changing requirements ensuring certain levels of QoS. These characteristics yield to systems that are intrinsically complex to develop, test and maintain. In this scenario middleware platforms, and particularly Service-Oriented Architectures (SOA), are becoming increasingly popular because they ease the creation of complex distributed applications and reduce the time-to-market. In this paper we show how the recently developed Flexible Time-Triggered CORBA (FTT-CORBA) can be used to support real-time Service-Oriented Architectures that are deterministically and dynamically reconfigurable.
The Common Project Request Broker Architecture (CORBA) is a middle-ware specification for the development of interoperable, distributed object systems. Object technology is of extreme importance in complex control system development besides its progressive use in other types of real-time systems. This paper tries to provide a general overview of the topics in distributed object systems, focusing on CORBA aspects that are critical for control systems engineering. Some sample applications are presented.
In recent years, several technical architectural paradigms have been proposed to support the development of distributed and concurrent systems. Object-oriented, component-based, service-oriented approaches are among the most recent paradigms for the implementation of heterogeneous software products that require complex interprocess communications and event synchronization. Despite the sharing of common objectives with distributed systems research, the robotics community is still late in applying these research results in the development of its architectures, often relying only on the most basic concepts. In this paper, we shortly illustrate these paradigms, their characteristics, and the successful stories about their application within the robotic domain. We discuss benefits and tradeoffs of the different solutions with the goal of deriving some practical principles and strategies to be exploited in robotics practice. Understanding the characteristics, features, advantages, and drawbacks of the different paradigms is, indeed, crucial for the successful design, implementation, and use of robotic architectures.
Many distributed applications require a scalable event-driven communication model that decouples suppliers from consumers and simultaneously supports advanced quality of service (QoS) properties and event filtering mechanisms. The CORBA Notification Service provides a publish/subscribe mechanism that is designed to support scalable event-driven communication by routing events efficiently between many suppliers and consumers, enforcing various QoS properties (such as reliability, priority, ordering, and timeliness), and filtering events at multiple points in a distributed system.This paper provides several contributions to research on scalable notification services. First, we present the CORBA Notification Service architecture and illustrate how it addresses limitations with the earlier CORBA Event Service. Second, we explain how we addressed key design challenges faced when implementing the Notification Service in TAO, which is our high-performance, real-time ORB. We discuss the optimizations used to improve the scalability of TAO's Notification Service. Finally, we present empirical results of the performance of our implementation.
Enterprise distributed real-time and embedded (DRE) publish/subscribe (pub/sub) systems manage resources and data that are vital to users. Cloud computing—where computing resources are provisioned elastically and leased as a service—is an increasingly popular deployment paradigm. Enterprise DRE pub/sub systems can leverage cloud computing provisioning services to execute needed functionality when on-site computing resources are not available. Although cloud computing provides flexible on-demand computing and networking resources, enterprise DRE pub/sub systems often cannot accurately characterize their behavior a priori for the variety of resource configurations cloud computing supplies (e.g., CPU and network bandwidth), which makes it hard for DRE systems to leverage conventional cloud computing platforms.
This paper provides two contributions to the study of how autonomic configuration of DRE pub/sub middleware can provision and use on-demand cloud resources effectively. We first describe how supervised machine learning can configure DRE pub/sub middleware services and transport protocols autonomically to support end-to-end quality-of-service (QoS) requirements based on cloud computing resources. We then present results that empirically validate how computing and networking resources affect enterprise DRE pub/sub system QoS. These results show how supervised machine learning can configure DRE pub/sub middleware adaptively in < 10 μsec with bounded time complexity to support key QoS reliability and latency requirements.
Although distributed real-time (RT) systems are intrinsically complex to develop and maintain, the use of certain object-oriented (OO) technologies such as CORBA and CORBA-RT facilitates those tasks. This is the main reason why these technologies are becoming increasingly popular. Moreover, CORBA is complemented with additional services that solve specific requirements for some applications, so developers may concentrate on the application functionality. Following this approach, this paper presents a new service that allows the synchronous scheduling of different activities in a distributed RT system in a simple and flexible way. This paper also explains how this service can be used for optimizing that access to shared resources in a distributed system and presents several experimental data that show the service performance
The event service is the earliest CORBA solution to the message queue model of communication in distributed systems. Typical implementations, however, suffer from the lack of event delivery guarantees. The loss of messages is aggravated by the presence of burstiness in the input to the event service, and occurrences of isolated bursts of traffic could also have serious effects. In this paper, we develop stochastic reward net (SRN) models that can aid in the study and configuration of the event service to conform to design specifications. To capture burstiness in the input, a Markov-modulated Poisson process (MMPP) is used as the input source. Erlang distributed event consumption times are used in the models to accommodate more general distributions and a wider range of variances. The models also take into consideration the FIFO discard policy adopted in many event service implementations. The SRN models are solved using the tool SPNP (Stochastic Petri Net Package). The applicability of the models to the CORBA notification service is also briefly discussed
Extending the CORBA programming and execution environments to
support real-time distributed applications is a subject of growing
interest to both research and industry. The time-triggered message
triggered object (TMO) programming scheme has been established to remove
the severe limitations of conventional object structuring techniques in
developing real-time distributed applications. To facilitate the
construction of TMO-structured real-time distributed applications
consisting of CORBA-compliant components, a middleware named TMO
Execution Support (TMOES) has been created. TMOES instantiations
residing in cooperating computing nodes also communicate among
themselves only via ORBs conforming to the standard specifications.
TMOES instantiations cooperate among themselves to support timely
execution of TMO methods and interactions among remote TMOs. This paper
presents the architecture and an implementation model of TMOES
Ice is a new object-oriented middleware platform that allows developers to build distributed client-server applications with minimal effort. While similar in concept to Corba, Ice breaks new ground by providing an object model that is both simpler and more powerful, by getting rid of inefficiencies that plagued middleware in the past, and by providing new features such as user datagram protocol (UDP) support, asynchronous method dispatch, built-in security, automatic object persistence, and interface aggregation. We discuss design decisions, contrasts the Corba and Ice approaches, and outlines the advantages that result from a better design.
Increasingly complex requirements, coupled with tighter economic and organizational constraints, are making it hard to build complex distributed real-time embedded (DRE) systems entirely from scratch. Therefore, the proportion of DRE systems made up of commercial-off-the-shelf (COTS) hardware and software is increasing significantly. There are relatively few systematic empirical studies, however, that illustrate how suitable COTS-based hardware and software have become for mission-critical DRE systems. This paper provides the following contributions to the study of real-time quality-of-service (QoS) assurance and performance in COTS-based DRE systems: it presents evidence that flexible configuration of COTS middleware mechanisms, and the operating system (OS) settings they use, allows DRE systems to meet critical QoS requirements over a wider range of load and jitter conditions than statically configured systems; it shows that in addition to making critical QoS assurances, noncritical QoS performance can be improved through flexible support for alternative scheduling strategies; and it presents an empirical study of three canonical scheduling strategies; specifically the conditions that predict success of a strategy for a production-quality DRE avionics mission computing system. Our results show that applying a flexible scheduling framework to COTS hardware, OSs, and middleware improves real-time QoS assurance and performance for mission-critical DRE systems.
z<z<XF:XIts| z<>z_>VI@:IP<<>wa@hFF_}> 0Hz<>z_>0Ya@s:s|aIK>Y|hF K>DK:Ft PKzDw_NI>H< PKYs:>tzs>8<I@:s zzPIjtFtY_ > VtDFtzXF>FFgwXFDzK0t.Dd-U sz dKsz_>FtYztV>Y_sFPg@ I8KF<@DzK HsPz#sF NI_K8>:>F 0H\\_ Kszz>FV>:zzsFFzy_@XF_ K@zKF0>KYs| _Ft K>DK:FtVFYt>V@zs58><_>H>NxtDFFz_F5XK:t > V@ _aF_ zz8dN<_><_zY>xaFta>zz#@ NFK}@>dwXFta FFzsDwz |h:zz1>tz Y_sFetFFVsDK>z DU_VFtKVt#tKsw s@hsz d<>z_>tF<Y_<FFdz FtYzt$>xtH_XIYzHI_ : _#ss IFKtF z0__>z_>j_5D1KF XF >z_>j_5D1KF I<n#K<|w>:>ssIFKtK 21580-36300 8660-37340 ts<KDFg|hFFzzsDsz Ksz_>NF<Y_<1zHd Hztz>Hah:wDFzFt0><<gIIsw}zz#d-UPz<@:K :t|zz^@sz_>D#:tI_zgNx> sw}zz#d-UP _zI5a sz dKsz_>1NF<Y_ z 8dNVFFFdFgNz<_Ks:IFK:wzgV :nDFzt>t0><0V: g|hFF_sz_N 1.
Common Object Request Broker Architecture: Core Specification
- Object Omg
- Management
OMG, Object Management Group, " Common Object Request Broker Architecture: Core Specification ", Version, 3.0.3, March 2004.
Icestorm manual " , version 3.4.2. Available online at
- Zeroc Inc
ZeroC Inc. " Icestorm manual ", version 3.4.2. Available online at: http://doc.zeroc.com/display/Ice/IceStorm
Data Distribution Service for Real-time Systems, Version 1.2
- Object Management Group
Icestorm manual", version 3.4.2. Available online at: http://doc.zeroc.com/display
- Zeroc Inc
Common Object Request Broker Architecture: Core Specification, Version, 3.0.3
- Object Management Group
Icestorm Manual, Version 3.4.2
- Zeroc Inc