Integrating digital twin technology in Cyber-Physical Systems and Internet of Things can boost their intelligence. Given the current maturity of digital twin technology (yet in progress), improving the models that these systems use is typically achieved off-line, requiring the system to stop and reconfigure to run each new model version. In fact, most works use cloud back-ends to run heavy machine learning algorithms, imposing strict requirements on the data exchange between the physical system and the cloud. We address the online improvement of digital twin models in cyber–physical systems by supporting model refinement without disrupting nor stopping the normal operation of the system. This improves the dynamicity of the system that may turn into a major competitive advantage in a number of industrial scenarios. Precisely, we exploit the collaborative expectation of next generation cyber–physical systems based on highly-connected cells enabled by 5G and 6G networking; and on top of these, we design a shared space properly managed to deliver the needed temporal behaviour required by cyber–physical systems. For this, we present the design of CoTwin framework as a middleware that allows cells to collectively improve digital twin models seamlessly. CoTwin manages the interaction of cells with a blockchain-based collaborative space offering a built-in trusted storage model. We integrate neural network algorithms as they provide fast execution that meet the time-sensitivity requirements of cyber–physical systems. Our contribution is validated by means of its implementation and deployment on an actual blockchain network, and an exhaustive set of experiments to analyse the resulting overhead and temporal behaviour. Results show that CoTwin achieves stable execution times accross all its functional pieces; and it exhibits stable service time for large sets of cells.

Non-functional requirements related to safety, security, and timeliness have made cyber–physical systems (CPS) initially reluctant to their integration with blockchain technology. Despite the multiple advantages of blockchain like improved data security and traceability, the main reasons that have slowed down its adoption in CPS still remain. Examples of these are the inherent overhead of accessing the distributed ledger and the security incidents that a number of blockchain networks have suffered since its inception. This paper presents VelogCPS, a novel middleware that guarantees that logic and data managed by blockchain networks of cyber–physical systems is verified and generated by a legitimate source. Thus, VelogCPS avoids a kind of security incidents that impact the authenticity and integrity of the logic and data managed in blockchain networks. By authenticity we refer to provenance authenticity of the involved smart contracts, i.e., the perfect matching between the source-code and a corresponding advertised smart-contract logic. This middleware ensures that the entities that participate to a CPS use solely authentic logic. For this, our approach leverages block verification services and enforces them through the operation workflow. As a result, the middleware guarantees that the CPS participants use and share authentic logic. Our approach is validated by providing an implementation on a real blockchain network, employing actual smart contract verifier logic, and analysing the temporal behavior of the overall system operations; this ensures its utility for CPS and IoT.

Integrating full-duplex low-latency communication middleware inside an HTTP based client-server interaction enables the development of powerful and highly-interactive web applications. Among the existing client-server communication protocols, there is WebSockets that allows the browser and the server backend to open a lively session interaction independent from the main HTTP application communication. There are different implementations of this full-duplex protocol, though per se, they do not offer the security protections required in cyber-physical systems (CPS). As a result, low-latency comes at the price of explicitly adding the needed security hooks to protect the application. This paper contributes an analysis of WebSockets technology from the point of view of its architecture and vulnerabilities and its applicability to CPS. We present the some selected implementations of the protocol that have become de-facto standard implementations given their broad usage; and we describe the vulnerabilities that they integrate -given their architecture- and how to overcome them. The paper provides an exemplification of a step by step communication between server and client on a full duplex WebSocket communication and shows how the associated vulnerabilities are exploited in a real use case scenario.

Verification of smart contracts improves the sentiment of trust in blockchain as it guarantees their authenticity. However, verification has a cost that can affect the lifecycle flow in time-sensitive systems; as these may require shorter times in code development and smart contract deployment. This paper contributes a strategy to automate the execution of verification tests over smart contracts to extract the meaningful characteristics about the source code authenticity.

If last decade viewed computational services as a utility then surely this decade has transformed computation into a commodity . Computation is now progressively integrated into the physical networks in a seamless way that enables cyber-physical systems (CPS) and the Internet of Things (IoT) meet their latency requirements. Similar to the concept of “platform as a service” or “software as a service”, both cloudlets and fog computing have found their own use cases. Edge devices (that we call end or user devices for disambiguation) play the role of personal computers , dedicated to a user and to a set of correlated applications. In this new scenario, the boundaries between the network node, the sensor, and the actuator are blurring, driven primarily by the computation power of IoT nodes like single board computers and the smartphones. The bigger data generated in this type of networks needs clever, scalable, and possibly decentralized computing solutions that can scale independently as required. Any node can be seen as part of a graph, with the capacity to serve as a computing or network router node, or both. Complex applications can possibly be distributed over this graph or network of nodes to improve the overall performance like the amount of data processed over time. In this paper, we identify this new computing paradigm that we call Social Dispersed Computing , analyzing key themes in it that includes a new outlook on its relation to agent based applications. We architect this new paradigm by providing supportive application examples that include next generation electrical energy distribution networks, next generation mobility services for transportation, and applications for distributed analysis and identification of non-recurring traffic congestion in cities. The paper analyzes the existing computing paradigms (e.g., cloud, fog, edge, mobile edge, social, etc.), solving the ambiguity of their definitions; and analyzes and discusses the relevant foundational software technologies, the remaining challenges, and research opportunities.

Abstract Cyber‐physical systems (CPS) are highly dynamic and large scale systems integrated with the physical environment that they monitor and actuate on. CPS have to adapt online to the changing nature of the physical environment; this may require the online modification of their system model, but any change should preserve correct operation. Correctness by construction relies on using formal tools, which suffer from a considerable computational overhead. As the current system model of a CPS may adapt to the environment, the new system model must be verified before its execution to ensure that the properties are preserved. However, CPS development has mainly concentrated on the design‐time aspects, existing only few contributions that address their online adaptation. We research on the pros and cons of formal tools to support dynamic changes at runtime. We formalize the semantics of the adaptation logic of an autonomic manager (OLIVE) that performs online verification for a specific application, a dynamic virtualized server system. We explore the use of formal tools based on CLTLoc to express functional and nonfunctional properties of the system. We provide empirical results showing the temporal costs of our approach.

There is a trend in developing computer systems for remote patient monitoring both at their own homes and also at specilized medical centers such as hospitals. This saves costs in patient care and also allows a closer monitorization of the vital signals under the supervision of a reduced number of medical staff. Medical systems have to comply with strict safety regulations and standards, to meet such requirements, the involved actors currently gather around ICE (Integrated Clinical Environment) specification. ICE is a promising solution to integrate heterogeneous sensors, devices, and processing computers into safe medical systems. It supports the interoperability of systems, safe data transmission from the patient's location to the clinician site to provide the appropriate treatment in a timely way. The paper presents a component model that aims at being ICE compliant, to support the design and development of distributed ICE-based systems for MD (Medical Devices) integration. It better supports understanding ICE requirements on monitoring applications from several points of view: the inherent distributed nature, high acuity, criticality, device heterogeneity, and timing requirements. The proposed work does not only focuses on the software architecture at component level, but it vertically validates it, we exemplify the component model through a prototype implementation of a patient monitoring system. The achieved design is modular, flexible, reflects the temporal requirements of medical applications, and can be easily integrated with external systems.

Distributed systems are continuously growing in scale, and so is the processing capacity requested from the servers in such systems. In an IoT context, such a variation in the requested processing capacity often comes from the also dynamic number of client nodes (possibly mobile and autonomous) that operate asynchronously. This results in servers that have to support a broad range of load conditions over time. In a real-time domain, over provisioning the server is the mainstream approach to guarantee service time to clients. However, as the average load is typically much lower than the worst case load, over dimensioning the server resources for the worst case threatens a cost-effective design. To avoid under utilization of server resources, this work introduces an approach to improve the cost-effective design of servers. There is an external coodinator that has global knowledge of the load conditions throughout the system, so that it controls the resources in the servers accordingly, a resource agent at a server is guided by the external coordinator node to adjust the server's thread pool size in order to support varying numbers of clients. An additional layer is designed to enable the interaction between the external coordination entity and the server. At the server side, this layer must exhibit acceptable temporal costs in order not to interfere with the server operation and its processing on behalf of client requests. This layer is validated for a specific implementation over a C++ environment based on Ice middleware and its remote method invocation model, the actual overhead introduced at network level is also analysed to validate the approach.

The inherent dynamic nature of Cyber Physical Systems (CPS) requires novel mechanisms to support their evolution over their operation life time. Though typically the development of CPS integrates the software (cyber) design with the physical domain, this contribution concentrates mainly on another essential integration plane: The software design level. This paper presents an approach to support the adaptation process of CPS required by their evolution. It is based on the run-time generation of verified system configurations and their analysis to guide the evolution of the system through correct configurations that meet the functional and timing requirements of the new situations. We show its feasibility by presenting and analyzing the results of the execution for a reduced-scale time-sensitive application that employs a complex verification technique to model functional and temporal aspects of the system.

The design of the embedded software for industrial systems progressively integrates more intelligent functions to ease the integration between the factory floor hardware and operator-friendly control front ends. New software development paradigms such as service oriented architecture (SOA) make it possible by embedding small footprint web servers inside small embedded devices that are connected to the actuators which they control. In general, the timing requirements of such distributed systems are not in the front plane and temporal guarantees provided by most solutions are typically best effort. iLAND is an example of a middleware that supports communication and reconfiguration of distributed services, ensuring temporal correctness. It includes the logic for adapting the architectural structure of a service-based application (i.e., number and connections of the software pieces/functions) to respond to operator requests in a time-deterministic way, focusing only on the temporal correctness. In this paper, we apply the principles of autonomic computing to the middleware design, and we provide a high-level description on how its verification process could be extended beyond the purely temporal properties using more comprehensive formal techniques. We exemplify these ideas with a modified on-line verification manager that suits the needs of a kind of systems with specific timing and functional constraints.

SUMMARY During the last decade, the number of distributed application domains with temporal requirements has significantly augmented, arising the necessity of exploring new concepts and paradigms that allow, on the one hand, the development of dynamic and flexible distributed applications and, on the other hand, the reusability of code. Service‐oriented paradigms have been successfully applied to distributed environments, increasing their flexibility and allowing the reusability of their components. Besides, distributed real‐time Java technologies have shown to be a good candidate to deploy real‐time distributed applications. This paper presents a model for service‐oriented applications on a time‐triggered distributed real‐time Java environment, focusing on the definition of the temporal model of an application and its schedulability, applying and evaluating this model in real‐time service‐oriented composition algorithms. Copyright © 2012 John Wiley & Sons, Ltd.

SUMMARY Timely run‐time software replacement techniques are a corner stone for reconciling real‐time systems development and dynamic behavior. Typical real‐time systems do not consider dynamic behavior because it deeply challenges predictability and timeliness. Current efforts are starting to merge the safe and predictable execution with a controllable level of dynamicity by imposing a set of bounds and limitations to the system dynamic behavior. One of the obstacles for this is how to time‐bound the different operations required to effectively implement component replacement. In this paper, the main challenges for this problem are identified, and a model to ensure that components can be replaced at run time preserving the temporal properties of the system is provided that also avoids failures in replacements. A real example and simulations of our replacement model are provided that validate the presented ideas. Copyright © 2013 John Wiley & Sons, Ltd.

There is a trend in industrial systems towards the use of common-off-the-shelf (COTS) components to develop applications that interact with open systems. This trend includes among others the use of high-level languages, such as Java, and Internet protocols (HTTP and Web Services). Although many industrial systems use these technologies at their business layers, they are far from offering a homogeneous programming platform in their most internal infrastructures. This paper extends the current practice by introducing a real-time Java-centric architecture for industrial systems. The architecture integrates existing and upcoming technology to define a Java-based approach. The empirical evidence, included in the paper, illustrates the performance of the core of the industrial layer of this architecture.

More and more industrial infrastructures consider the use of industrial wireless sensor network (IWSN) technology to perform control activities in industry. The benefits stemmed from IWSNs include flexible access (no wires are required) to elements that may interact with the factory floor. However, this support introduces new challenges: muling the almost permanent connectivity given by wired infrastructures is no longer available in IWSNs. To address this challenge, this paper explores data muling as the ability of transferring data between different elements within an industrial infrastructure. The proposed data-muling protocol uses a dual discovery and update (D&U) strategy. The prototype evaluation carried out on 6LowPan over IEEE 802.15.4 motes provides some insights on the performance that this type of infrastructure may offer within an industrial context. This paper also offers an extensive benchmark that may be used to test bounds and limitations of the proposed D&U protocol on the industrial use-cases.

Current approaches towards distributed real-time Java are mainly based on the idea of having user-defined remote objects, allocated in servers that may be invoked from clients. This article extends this support included in real-time Java with an extension called Remote Memory Areas (RMAs). RMAs offer a method that allows running user-defined code in a generic server that may be reused by several applications (i.e., it does not require defining one type of remote sever per application). The paper describes the abstraction, which is backward compatible with main approaches in distributed real-time Java, and provides empirical evidence on its performance on a use-case application.

As new technology becomes available, systems increase in complexity, which in turn, raises the expectations of users for new applications that may presumably be more complex. This spiral process requires the usage of appropriate techniques to control complexity such as decoupled design and development paradigms, and communications middleware that facilitate the development of distributed applications. The highest exponent of them is, currently, DDS middleware (Data Distribution System for Distributed Real-Time Systems) that is specifically designed for applications that have timing requirements. Also, virtualization techniques follow the principle of complexity reduction, and they allow to customize the offered computational platforms and to achieve server consolidation in different domains ranging from industrial control systems, distributed surveillance, or enterprise resource planning applications. This paper describes some considerations for merging real-time middleware, such as DDS, and virtualization technology with the aim of suiting the cyber physical domain. This virtual integration tries to bypass the typical bottlenecks of performance. Performance results track the differences between the executions of DDS middleware in the bare machine compared to a virtualized environment.

SUMMARY OSGi was designed with embedded systems in mind, its current support is insufficient for coping with one main characteristic of many embedded systems: real‐time performance. This article analyzes different key issues in providing OSGi with real‐time Java performance covering motivational issues, and different integration ways and challenges stemming from the integration. It also contributes a general framework for introducing real‐time performance in OSGi, which is called the real‐time for OSGi framework. The framework uses real‐time Java virtual machines and the real‐time specification for Java. The adoption of this framework allows cyber‐physical systems to experience real‐time Java performance in their applications. The framework introduces several integration levels for OSGi and real‐time specification for Java, and specific real‐time OSGi services. An empirical implementation was carried out using standard software, which was extended with the new defined services. Copyright © 2012 John Wiley & Sons, Ltd.

Communication middleware technologies are powerful instruments to develop and deploy remote laboratories for students to practice the control of real application cases. Middleware allows the rapid development and deployment of actual distributed settings since it abstracts the specifics of the different hardware platforms and communication media involved in the access of students to the lab material. This paper describes the practical settings carried out in the a case of a successful laboratory experience that allows students to simulate the on-line monitoring and control of remote systems, i.e., the train traffic in a simulated metro system. The innovative contribution of this experiment is the usage of data-centric middleware based on the publish/subscribe paradigm that has real-time properties. Up to our knowledge, such deployment with this particular middleware type has not been done, and it has given rise to a flexible setting that grows with the contributions of students. We have validated the idea by gathering the feedback of students with respect to the operation of the assignment, showing that this motivates the students' learning and enrollment in the assignment.

Future networked embedded systems will be complex deployments deeply integrated in the environment that they monitor. They will have to react to both user and environmental events, and this may require modifying their structure to handle the changing situations. In a number of domains including industrial environments, this modification of the system structure will need to take place in real time. This is a hard problem that will require novel and paradigmatic solutions involving cross-domain knowledge to build a middleware for enabling real-time interaction between nodes allowing time-bounded reconfiguration. For supporting real-time, this middleware must be vertically architected in a modular way from the network and operating system levels up to the application software and the real-time policies for achieving time-bounded behavior. This paper presents a middleware that addresses these characteristics supporting timely reconfiguration in distributed real-time systems based on services. Experimental results are shown to validate the middleware in an actual small-scale video prototype.

Abstract The current RTSJ (Real‐Time Specification for Java) threading model is dualized: a programmer has to decide between the high predictability offered by the region‐based model and the flexibility offered by the garbage collection. So far, there is no unique type of thread which offers both the high predictability of a non‐heap thread and the flexibility of a real‐time thread in a single entity. Furthermore, this lack has a serious impact on the programmer who has to deal with new and sometimes non‐trivial to use mechanisms, such as specific queues of objects or new types of threads, in order to avoid the priority inversion caused by the garbage collector. In order to tackle the concern properly and provide an improved and more generalized programming model, the authors propose a simple extension to the current threading model namedRealtimeThread++, in an attempt to introduce more flexibility in the RTSJ concurrency model. The paper describes the extension from several points of view: (i) the programmer, identifying scenarios that may benefit from it significantly; (ii) the real‐time Java technology perspective, identifying changes required in the current real‐time virtual machine to support it; and (iii) the accumulated experience, relating empirical results obtained from a software prototype that supports the extension. Copyright © 2010 John Wiley & Sons, Ltd.

Abstract The proliferation of a new generation of distributed real‐time embedded systems (DRE) characterized by special restrictions on its storage capacities, its available computation time, and the messages they can send through the network suggests a comprehensive redesign of the current distribution infrastructure in order to tune its performance. In this changing panorama, the paper concerns one of the protocols, Java's Remote Method Protocol (JRMP), used nowadays to interconnect different nodes of a distributed Java system, and explores the cost of integrating an improved protocol‐level multiplexing strategy in the context of an end‐to‐end remote invocation. The new multiplexing strategy helps middleware manage more efficiently unscheduled invocations that appear at runtime generated from a certain client node, especially in cases where preallocation of resources or dimensioning for the worst‐case are techniques not plausible. To this end, the paper examines an alternative based on the definition of a new subprotocol, called ConnectionLess, which offers built‐in multiplexing facilities for distributed Java applications. The performance of the new subprotocol is compared against the three already defined by JRMP (namely SingleOp, Stream, and Multiplex), taking into consideration parameters such as memory consumed in the Java's virtual machine and end‐to‐end response times. Copyright © 2011 John Wiley & Sons, Ltd.

Abstract Service‐based approach has been successfully applied to distributed environments, modelling them as pieces of functionality that exchange information by means of messages in order to achieve a common goal. The advantages of this approach can be also be applied to distributed real‐time systems, increasing their flexibility and allowing the creation of new brand applications from existing services in the system. If this is an online process, then time‐bounded composition algorithms are needed to not jeopardize the performance of the whole system. Different composition algorithms are studied and proposed, two of them optimal and another two based on heuristics. This paper presents an analytical solution that selects, depending on the structure of the application and on the load of the whole system, the most suitable composition algorithm to be executed in order to obtain a composed application in bounded time. Copyright © 2011 John Wiley & Sons, Ltd.

SUMMARY Many real‐time systems use preemptive priority‐based scheduling in their internals to guarantee certain real‐time performance. This includes technologies that range from The Real‐Time Specification for Java (RTSJ) to middleware like Real‐Time Common Object Request Broker Architecture (RT‐CORBA), which offers additional models and policies that blend client and server information. This decision eases the integration of real‐time admission tests and dispatching policies in these types of infrastructures. In this paper, we analyze different trade‐offs that emerge from the definition of different propagation models for distributed real‐time Java. The paper covers technological integration aspects as impact on interfaces and other practical issues mainly related to the performance that this model offers to a real‐time application and non‐functional overhead. The contribution described in the paper may help in the development of The Distributed Specification for Java (DRTSJ). Copyright © 2011 John Wiley & Sons, Ltd.

More-and-more, the use of Java as a programming language for real-time applications is becoming of interest in industrial middleware. This is mainly because it offers advantages for the programmer as reduced deployment times, increased portability, and a number of APIs that may be integrated in large distributed applications. This paper contributes a dual communication model for distributed real-time Java applications. Current efforts in distributed real-time Java [e.g., The Distributed Real Time Specification for Java (DRTSJ)] are mainly focused on remote invocations (R.I.) and set aside other valuable approaches such as distributed events. The proposed model offers two choices for developing distributed real-time Java applications (one based on R.I., and another on distributed events), which may be used to develop applications. Both models include an additional support for asynchronism in communications, a feature that may speed up their communication performance. This paper includes a description for the two models, the changes that are required in the current API to accommodate them, and an empirical evaluation of their performance on a reference implementation.

Today's trend in real-time systems reveals the necessity of new technologies to easy their development and maintenance. Among others, some interesting alternatives are found in high-level real-time programming languages, better development models, or simple architectures and models. From the perspective of real-time Java, a recent real-time programming language, this paper offers an architecture (and its corresponding Java interfaces) to help the development of an upcoming distributed real-time technology for Java (named DRTSJ). To that end it describes a neutral architecture based on Java's Remote Method Invocation (RMI) and The Real-time Specification for Java (RTSJ). The empirical evidences included in the paper offer also interesting clues on the performance this technology may deliver.

The increasing complexity of networked embedded systems (NES) brings in the vision of large-scale systems made of subparts with decoupled interaction. In highly decoupled environments, it is required to introduce software paradigms that adjust well to this degree of independence among subsystems. In modern NES, real-time properties and reconfiguration facilities are not only an added value but an unavoidable trend that research is currently focusing at. Service-oriented architectures (SOA) are an easy-to-understand natural means to provide such decoupled model of operation; service-based applications are made of a set of self-contained pieces of functionality (services) that cooperate by exchanging messages to provide the application's common goal. This paper presents a middleware architecture that includes real-time support for service-oriented NES. The architecture includes the fundamental set of functions to support timely service-based composition and execution. The architecture is the core part of the iLAND project that aims at supporting deterministic service-based composition and reconfiguration in service-based NES. The architecture can be built on top standard communication middleware cores (as DDS or RT-CORBA), since it supports synchronous and asynchronous communication models. An experimental set up for real-time video transmission has been developed to validate it.

Many real-time systems use preemptive priorities in their internals to guarantee certain real-time performance. This includes technologies that range from RTSJ (The Real-Time Specification for Java) to middleware like Real-Time CORBA (Common Object Request Broker Architecture) which offers additional models and policies that blend client and server information. This decision makes easier the integration of real-time acceptance tests and dispatching policies in these kinds of infrastructures. In this paper, we analyze different tradeoffs that emerge from the definition of different propagation models for distributed real-time Java. The paper covers technological integration aspects, impact on interfaces, and other practical issues more related to the performance that this model offers to a real-time application

This article presents an approach to providing real-time support for Java's Remote Method Invocation (RMI) and its integration with the RTSJ memory model in order to leave out garbage collection. A new construct for remote objects, called No-heap Remote object ( NhRo ), is introduced. The use of a NhRo guarantees that memory required to perform a remote invocation (at the server side) does not use heap memory. Thus, the aim is to avoid garbage collection in the remote invocation process, improving predictability and memory isolation of distributed Java-based real-time applications. The article presents the bare model and the main programming patterns that are associated with the NhRo model. Sun RMI implementation has been modified to integrate the NhRo model in both static and dynamic environments.

Current trends in real-time systems identify Java as a new alternative to develop both centralized and distributed real-time systems. Many efforts have been devoted to develop the Real-Time Specification for Java (RTSJ), and there is substantial ongoing activity to produce a straightforward and valuable Distributed Real-Time Specification for Java (DRTSJ). The current paper provides a contribution to this latter activity defining, from different angles, a synchronous scheduling service aligned with principles of some popular real-time architectures. This service orchestrates the system in such a way that it provides end-to-end guarantees in the distributed transactions, guaranteeing their timely execution across the network and nodes. The service is described from two points of view: the system one, characterizing a portable model; and the programmer one, defining a distributed object-oriented implementation of a model based on Real-Time Remote Method Invocation (RTRMI). Finally, it also presents results of an implementation carried out to judge the efficiency of the service, offering a preliminary predictability and performance assessment of a distributed real-time Java technology.

Consumer electronics platforms are progressively being introduced in most domains, from personal appliances to high-quality multimedia control infrastructures. They are high quality platforms that require that computation resources be used in a cost-effective way. Multimedia applications compete for resources in a greedy manner, which may threaten the safe system execution. Arbitration of application execution is needed to keep system stability, especially in the event of unexpected changes in the resource requirements demanded by applications. Changes may be caused by a modification in the nature of the incoming media or by the user action. Such changes should trigger an adaptation process to handle the new situation in a way that overall system quality is preserved. This paper describes the mechanisms that have been developed to handle situation where adaptation is needed in such a way that stability is preserved avoiding over reaction. An adaptation protocol based on the definition of a safety band for filtering peaks in resource demands is set for this purpose. The paper presents experimental results that show the appropriate filtering of these peaks, which validate the presented concepts.

More and more, the use of real-time distribution middlewares programmed with high-level languages like Java is becoming of interest for industrial systems because this type of infrastructures reduce development efforts required to both design and maintain complex networked applications. In that way towards having better development tools, this paper deals with the very specific issue of the asynchronism from the particular perspective of Java's distributed technologies. It proposes and evaluates an extension to the Java's remote method invocation (RMI) with additional support for asynchronous remote invocations. Such a mechanism makes the transmission of some messages, typically those that do not require any confirmation from the server, much more efficient than synchronous communications, and consequently they optimize and speed up the performance of many industrial networked applications. In more detail, this paper concerns with the model itself and the set of changes it requires within their middleware programming interfaces and inside communication protocols to accommodate the proposed model. The proposal is supported by empirical evidences from a prototype developed as partial proof-of-concept.

This paper presents a model for quality-of-service (QoS)-aware service composition in distributed systems with real-time and fault-tolerance requirements. This model can be applied in application domains like, for example, remote monitoring, control and surveillance. Classic approaches to real-time systems do not provide the flexibility and fault-tolerance required in new emerging environments that need to combine a high degree of dynamism with temporal predictability. Our approach addresses these new challenges by combining concepts from the service oriented paradigm and distributed real-time systems. We propose a concrete system model based on a holistic time-triggered-based approach for design and configuration. Based on this model, we propose two algorithms for the composition of QoS-aware service-based applications with temporal requirements: an exhaustive algorithm that computes the optimal service combination in terms of a figure of merit, suitable for offline composition; and an improved algorithm based on heuristics and partial figures of merit, suitable for online composition. Experimental results show that the latter reduces dramatically the number of combinations explored with a minimal degradation in the quality of the solution, making it feasible for online execution in dynamic environments.

Current RTSJ (The Real-Time Specification for Java) threading model is dualized: programmers have to decide between the high predictability offered by its region-based model and the flexibility offered by its garbage-collected model. Up to now, there is not a unique type of thread that offers, in a single entity, the highest predictability, and flexibility together. This lack has serious consequences on the programmer who has to deal with new and sometimes non-trivial mechanisms, such as queues of objects or the No-heap Real-Time Threads, to avoid the priority inversion caused by the garbage collector. In order to tackle these issues and provide an improved and more generalized programming model, the authors propose an extension to the current threading model that unifies the RTSJ threading model: the RealtimeThread++ extension.

Recently, the application domains where the development of systems with temporal guarantees is needed have increased. The majority of such domains are dynamic environments where the classical design approach is no longer applicable since it is too pessimistic. Thus, new challenges arise to adapt the current methodologies used in different architectural levels to these new environments. New directions and paradigms are needed to allow combining functional flexibility and dynamism with temporal predictability. The current work addresses these new challenges through the exploration of the applicability of concepts from the service oriented paradigm to distributed real-time systems. We propose a concrete system model based on a holistic time-triggered-based approach for design and configuration. Based on this model, we analyse the architectural entities required for two different architectural design approaches: static, when no reconfigurations at run-time are admitted, and dynamic, when these reconfigurations are possible. An exhaustive composition algorithm is also proposed.

Recently, new trends in application development for distributed platforms, such as the composable services model, attempt to provide more flexibility in system design, deployment and execution. Such trends, and particularly the referred composable services model, can also be beneficial in real-time distributed embedded systems, also providing a means to support more adaptive behaviors, reacting to the execution environment or coping with system reconfiguration. This paper explores a relatively new direction, which is the extension of the service-based model to dynamic, i.e. at run-time, composition in real-time distributed environments, in order to support the level of flexibility and adaptibility referred above. The paper proposes an architecture to support such dynamic service composition that is based on the flexible time triggered communication paradigm (FTT).To achieve the desired goal, we also redefine the concepts of service and service-based application in the concept of the FTT paradigm. Finally, we show experimental results obtained with a prototype implementation of the proposed architecture that confirm its feasibility and good temporal behavior

This paper describes an approach towards the definition and implementation of a synchronization service on top of a remote object model offered by an unicast real-time remote object paradigm. Also an architecture model based on the RTSJ (real-time specification for Java) and the distribution middleware RMI (remote method invocation) specifications is proposed in order to give support to the model, defining a convergence layer that manages the underlying resources involved in a master-slave communication through a new API. Finally, preliminary results from an implementation prototype show the feasibility of the model and provide an initial estimation of jitters and the performance of the synchronization service

The Noosphere is a term borrowed by open-source advocate Eric Raymond to denote the virtual world of the Internet. Fitting a new driver into the Linux kernel requires a ‘noospheric’ strategy as well as an engineering strategy, because the code is part of the open-source development process, not its end. This article recounts the technology and the development process followed for a ‘fast and intelligent’ driver extension to the existing Linux software RAID subsystem. The development adapts the kernel RAID subsystem for use in the context of network-attached storage. Copyright © 2005 John Wiley & Sons, Ltd.

This paper presents a memory management solution for distributed real-time Java. The proposed model is targeted at distributed applications that require to keep their internal state and that consume a bounded memory size in their operation. The aim is to provide an alternative to the garbage collector for distributed real-time systems and to avoid the penalties it introduces. The approach is based on the usage of scoped memory defined in the real-time specification for Java (RTSJ). Our solution introduces constraints in the programming model and in the current distributed Java architecture. However, these are compensated by eliminating the dependency of the garbage collector in the end-to-end invocation and by achieving self-cleaning with respect to the memory consumed by remote invocations.

The design of embedded real-time systems requires skills from multiple specific disciplines, including, but not limited to, control, computer science, and electronics. This often involves experts from differing backgrounds, who do not recognize that they address similar, if not identical, issues from complementary angles. Design methodologies are lacking in rigor and discipline so that demonstrating correctness of an embedded design, if at all possible, is a very expensive proposition that may delay significantly the introduction of a critical product. While the economic importance of embedded systems is widely acknowledged, academia has not paid enough attention to the education of a community of high-quality embedded system designers, an obvious difficulty being the need of interdisciplinarity in a period where specialization has been the target of most education systems. This paper presents the reflections that took place in the European Network of Excellence Artist leading us to propose principles and structured contents for building curricula on embedded software and systems.

The analysis of systems executing a set of transactions composed by a number of tasks is required in some application domains, such as distributed systems or many audio/video streaming systems. The paper deals with the time response analysis of such systems, considering periodic uniprocessor transactions, and tasks, characterized by their fixed priority and execution time, connected in series through bounded buffers. The scheduling policy allows several transaction jobs to be active at a time, which is possible by putting intermediate task results in the buffers. When the output buffer of a task is full, the task becomes blocked and priority inversion arises. An analysis method is described that allows one to calculate the worst-case response time of the transactions in order to be compared with their end-to-end deadlines. The results of the method application show how task priorities or buffer sizes influence the transaction response times.