Real-Time Reliable Middleware for Industrial Internet-of-Things

This dissertation contributes to the area of adaptive real-time and fault-tolerant systems research, applied to Industrial Internet-of-Things (IIoT) systems. Heterogeneous timing and reliability requirements arising from IIoT applications have posed challenges for IIoT services to efficiently differentiate and meet such requirements. Specifically, IIoT services must both differentiate processing according to applications\u27 timing requirements (including latency, event freshness, and relative consistency of each other) and enforce the needed levels of assurance for data delivery (even as far as ensuring zero data loss). It is nontrivial for an IIoT service to efficiently differentiate such heterogeneous IIoT timing/reliability requirements to fit each application, especially when facing increasingly large data traffic and when common fault-tolerant mechanisms tend to introduce latency and latency jitters. This dissertation presents a new adaptive real-time fault-tolerant framework for IIoT systems, along with efficient and adaptive strategies to meet each IIoT application\u27s timing/reliability requirements. The contributions of the framework are demonstrated by three new IIoT middleware services: (1) Cyber-Physical Event Processing (CPEP), which both differentiates application-specific latency requirements and enforces cyber-physical timing constraints, by prioritizing, sharing, and shedding event processing. (2) Fault-Tolerant Real-Time Messaging (FRAME), which integrates real-time capabilities with a primary-backup replication system, to fit each application\u27s unique timing and loss-tolerance requirements. (3) Adaptive Real-Time Reliable Edge Computing (ARREC), which leverages heterogeneous loss-tolerance requirements and their different temporal laxities, to perform selective and lazy (yet timely) data replication, thus allowing the system to meet needed levels of loss-tolerance while reducing both the latency and bandwidth penalties that are typical of fault-tolerant sub-systems

A framework for flexible scheduling in real-time middleware

The traditional vehicle for the deployment of a real-time system has been a real-time operating system (RTOS). In recent years another programming approach has increasingly found its way into the real-time systems domain: the use of middleware. Examples are the so called pervasive systems (embedded, interactive but not mobile), and ubiquitous systems (embedded, interactive and mobile), e.g. hand-held devices. These tend to be dynamic systems that often exhibit a need for flexible scheduling because of their operating requirement; or their execution environment. Thus, today there is a true need in many realtime applications for more flexible scheduling than what is currently the stateof- prac'tice. By flexible scheduling we mean the ability of the program execution platform to provide a range of scheduling policies, all the way from hard real-time to soft real-time policies, from which an application can choose one most suited to its needs. Furthermore, some applications may need to be scheduled by one policy while others may need a different policy, e.g. fi'Ced priority or earliest deadline first (EDF) for hard real-time tasks, least slack time first (LST) or shortest remaining time for soft real-time tasks. It would be difficult for the middleware to expect this functionality from the RTOS. This would require a fine balance to be struck in the RTOS between flexibility and usability, and many years will probably pass until such approaches become mainstream and usable. 'This thesis maintains that this flexibility can be introduced into the middleware. It presents a viable solution to introducing flexible scheduling in real-time program execution middleware in the form of a flexible scheduling framework. Such a framework allows use of the same program execution middleware for a variety of applications - soft, firm and hard. In particular, the framework allows different scheduling policies to co-exist in the system and their tasks to share common resources. The thesis describes tlle framework's protocol, examines the different types of scheduling policies that can be supported, tests its correctness through the use of a model checker and evaluates the proposed framework by measuring its execution cost overhead. The framework is deemed appropriate for the types of real-time applications that need the services of flexible scheduling