Model-based implementation of real-time applications

Correct and efficient implementation of general real-time applications remains by far an open problem. A key issue is meeting timing constraints whose satisfaction depends on features of the execution platform, in particular its speed. Existing rigorous implementation techniques are applicable to specific classes of systems e.g. with periodic tasks, time deterministic systems. We present a general model-based implementation method for real-time systems based on the use of two models. &bull An abstract model representing the behavior of real-time software as a timed automaton. The latter describes user-defined platform-independent timing constraints. Its transitions are timeless and correspond to the execution of statements of the real-time software. &bull A physical model representing the behavior of the real-time software running on a given platform. It is obtained by assigning execution times to the transitions of the abstract model. A necessary condition for implementability is time-safety, that is, any (timed) execution sequence of the physical model is also an execution sequence of the abstract model. Time-safety simply means that the platform is fast enough to meet the timing requirements. As execution times of actions are not known exactly, time-safety is checked for worst-case execution times of actions by making an assumption of time-robustness: time-safety is preserved when speed of the execution platform increases. We show that as a rule, physical models are not time-robust and show that time-determinism is a sufficient condition for time-robustness. For given real-time software and execution platform corresponding to a time-robust model, we define an Execution Engine that coordinates the execution of the application software so as to meet its timing constraints. Furthermore, in case of non-robustness, the Execution Engine can detect violations of time-safety and stop execution

Analytical/ML Mixed Approach for Concurrency Regulation in Software Transactional Memory

In this article we exploit a combination of analytical and Machine Learning (ML) techniques in order to build a performance model allowing to dynamically tune the level of concurrency of applications based on Software Transactional Memory (STM). Our mixed approach has the advantage of reducing the training time of pure machine learning methods, and avoiding approximation errors typically affecting pure analytical approaches. Hence it allows very fast construction of highly reliable performance models, which can be promptly and effectively exploited for optimizing actual application runs. We also present a real implementation of a concurrency regulation architecture, based on the mixed modeling approach, which has been integrated with the open source Tiny STM package, together with experimental data related to runs of applications taken from the STAMP benchmark suite demonstrating the effectiveness of our proposal. © 2014 IEEE

The Design and Implementation of Real-time Event-based Applications with RTSJ

International audienceThis paper presents a framework to design real-time event-based applications using Java. The Real-Time Specification for Java (RTSJ) is well designed for hard periodic real-time systems. Though it also proposes classes to model asynchronous events and deal with sporadic or aperiodic tasks, it remains insufficient. The literature proposes the use of periodic servers called task servers to handle nonperiodic traffics in real-time systems. Unfortunately, there is no support for task servers in RTSJ. In order to fix this lack, we propose an RTSJ extension model. To validate our design, we adapt and implement two policies: the polling server and the deferrable server policies. To show how effi- cient these policies are, we compare implementation results and results obtained with a discrete-event-based simulato

Asynchronous real-time ethernet

The Industrial Ethernet has become a way to build distributed systems in industrial networks which must provide predictable performance and maintainability. Industrial applications require time-critical processing, which can be guaranteed within soft or hard real-time environments, Where applications' responses require deterministic processing time, the hard real-time environment is requested. The Fieldbus protocols are the standard way to connect instruments on the Ethernet-based communication. Fieldbuses require synchronisation and dedicated application-specific integrated circuits, what leaves space for alternate, more common solutions. This thesis presents design, implementation, and evaluation of the novel Real-Time Driver Model asynchronous communication stack called 61850CS API. 61850CS stack is implemented in an intelligent electronic device to enable real-time IEC 61850 GOOSE Ethernet communications in electrical substations. The presented 61850CS implementation enables simultaneous flow of real-time and non-real-time Ethernet traffic over the same physical network interface controller. The same technology supports running arbitrary real-time Ethernet traffic and non real-time Ethernet traffic simultaneously and its implementation is general enough to enable an API use on different architectures and to comply with different industrial Ethernet requirements. And more, since 61850CS doesn't affect CSMA/CD mechanism, it doesn't need any master nodes, which increases the system availability. The presented solution was implemented as an application programming interface for feeder protection and control (FPC 680) intelligent electronic device relay. Hardware platform for 61850CS was PPC440EPx microcontroller with implemented Linux Real-Time application interface RTOS. The FPC 680 is an IED commercial product by Iskra d.d. which is implemented worldwide in several substations

A component-based model and language for wireless sensor network applications

Wireless sensor networks are often used by experts in many different fields to gather data pertinent to their work. Although their expertise may not include software engineering, these users are expected to produce low-level software for a concurrent, real-time and resource-constrained computing environment. In this paper, we introduce a component-based model for wireless sensor network applications and a language, Insense, for supporting the model. An application is modelled as a composition of interacting components and the application model is preserved in the Insense implementation where active components communicate via typed channels. The primary design criteria for Insense include: to abstract over low-level concerns for ease of programming; to permit worst-case space and time usage of programs to be determinable; to support the fractal composition of components whilst eliminating implicit dependencies between them; and, to facilitate the construction of low footprint programs suitable for resource-constrained devices. This paper presents an overview of the component model and Insense, and demonstrates how they meet the above criteria.Preprin

Pre-Trusted Peers Probability Influence on Eigen Trust and Reputation Model Over Peer to Peer Distributed Networks

This paper investigates the impact of peer pre-trusted probability on the performance of Eigen's trust and reputation model in distributed wireless networks. Design and develop models for rigorous Eigen Trust assessment and reputation models. In addition, we evaluate our model from performance-based factors namely: accuracy, resource utilization and energy consumption. Finally, the results obtained from our investigation are suggestive of implementation for real-time distributed wireless applications. our proposal