Showing papers presented at "International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing in 2020"

Multi-Level Preemption in TSN: Feasibility and Requirements Analysis

Abstract: To overcome the limitation of strictly non-preemptive frame transmission in Ethernet networks, the IEEE 802.1Qbu standard was introduced. This standard specifies a one-level frame preemption paradigm wherein, depending on their priority levels, frames are grouped into two categories: namely, the “express frames” and the “preemptable frames”. These two categories are given with the interpretation that (1) only express frames can preempt preemptable frames; and (2) two frames belonging to the same category cannot preempt each other. While this approach partially solves the problem, some preemptable frames can still suffer long blocking periods, irrespective of their individual priority levels. Indeed, there are frames that do not fall into the express frames category, but nevertheless have firm timing requirements that can only be met if they can benefit from preempting lower priority frames. To ameliorate the condition of such frames, we propose a multi-level preemption paradigm. Specifically, we expose the limitations of the one-level preemption approach experimentally; and we present the feasibility and implementation requirements of the multi-level preemption scheme in details.

A Cross-Layer Review of Deep Learning Frameworks to Ease Their Optimization and Reuse

Abstract: Machine learning and especially Deep Learning (DL) approaches are at the heart of many domains, from computer vision and speech processing to predicting trajectories in autonomous driving and data science. Those approaches mainly build upon Neural Networks (NNs), which are compute-intensive in nature. A plethora of frameworks, libraries and platforms have been deployed for the implementation of those NNs, but end users often lack guidance on what frameworks, platforms and libraries to use to obtain the best implementation for their particular needs. This paper analyzes the DL ecosystem providing a structured view of some of the main frameworks, platforms and libraries for DL implementation. We show how those DL applications build ultimately on some form of linear algebra operations such as matrix multiplication, vector addition, dot product and the like. This analysis allows understanding how optimizations of specific linear algebra functions for specific platforms can be effectively leveraged to maximize specific targets (e.g. performance or power-efficiency) at application level reusing components across frameworks and domains.

Heuristic partitioning of real-time tasks on multi-processors

Abstract: This paper tackles the problem of admitting real-time tasks onto a symmetric multi-processor platform, where a partitioned EDF-based scheduler is used. We propose to combine a well-known utilization-based test for the first-fit partitioning strategy, with a simple heuristic based on the number of tasks and exact knowledge of the utilization of the first few biggest tasks. This results in an effective and efficient test improving on the state of the art in terms of admitted tasks, as shown by extensive tests performed on task sets generated using the widely adopted randfixedsum algorithm.

Heterogeneous Task Co-location in Containerized Cloud Computing Environments

Abstract: Although cloud computing became a mainstream industrial computing paradigm, low resource utilization remains a common problem that most warehouse-scale datacenters suffer from. This leads to a significant waste of hardware resources, infrastructure investment, and energy consumption. As the diversity in application workloads grows into an essential characteristic in modern datacenters, task co-location of different workloads to the same compute cluster has gained immense popularity as a heuristic solution for resource utilization optimization. Although the existing co-location methodologies manage to improve resource efficiency to a certain degree, application QoS is usually sacrificed as a trade-off when dealing with resource interference between different applications. This paper proposes a containerized task co-location (CTCL) scheduler to improve resource utilization and minimize task eviction rate. Our CTCL scheduler (1) applies an elastic task co-location strategy to improve resource utilization; and (2) supports a dynamic task rescheduling mechanism to prevent severe QoS degradation from frequent task evictions. We evaluate our approach in terms of resource efficiency and rescheduling cost through the ContainerCloudSim simulator. Our experiments with the Alibaba 2018 workload traces demonstrate that CTCL could improve overall resource efficiency and reduce rescheduling rate by 38% and 99% respectively.

Fast Failover in Ethernet-Based Automotive Networks

Abstract: Application of Ethernet-based networks in the autonomous and automated vehicles requires fail-operational behavior. The network components must not only detect failures, but also reduce their effects on the system’s safety, as it may not be possible to bring the driver back into the control loop. In this work we present a mechanism which, through protocol-based synchronization and fine-grained re-configuration of network components, allows achieving traffic isolation, fault recovery and controlled degradation of network performance. This enables the maintenance of (degraded) network operation in case of a malfunction, a safe stopping of a vehicle or its safe operation until the driver takes control. We offer a detailed evaluation of our approach in a demonstrator setup as well as a simulation and comparison with state-of-the-art approaches.

The AMPERE Project: : A Model-driven development framework for highly Parallel and EneRgy-Efficient computation supporting multi-criteria optimization

Abstract: The high-performance requirements needed to implement the most advanced functionalities of current and future Cyber-Physical Systems (CPSs) are challenging the development processes of CPSs. On one side, CPSs rely on model-driven engineering (MDE) to satisfy the non-functional constraints and to ensure a smooth and safe integration of new features. On the other side, the use of complex parallel and heterogeneous embedded processor architectures becomes mandatory to cope with the performance requirements. In this regard, parallel programming models, such as OpenMP or CUDA, are a fundamental brick to fully exploit the performance capabilities of these architectures. However, parallel programming models are not compatible with current MDE approaches, creating a gap between the MDE used to develop CPSs and the parallel programming models supported by novel and future embedded platforms.The AMPERE project will bridge this gap by implementing a novel software architecture for the development of advanced CPSs. To do so, the proposed software architecture will be capable of capturing the definition of the components and communications described in the MDE framework, together with the non-functional properties, and transform it into key parallel constructs present in current parallel models, which may require extensions. These features will allow for making an efficient use of underlying parallel and heterogeneous architectures, while ensuring compliance with non-functional requirements, including those on real-time performance of the system.

Internet of Things based Cyber-Physical System framework for Real-Time Operations

Abstract: The paper presents an intelligent cyber-physical system (CPS) framework using object detection for real-time operations in an Internet-of-Things (IoT) connected physical environment. To facilitate real-time object detection, we used a variant of Convolutional Neural Network (CNN) known as Faster R-CNN (R stands for the region proposals). The control action related to the detected object is exchanged with the actuation system using Real-Time Data Exchange (RTDE) protocol. We demonstrate the proposed framework to perform pick-and-place operations as it is a widely performed operation on a production floor using a Universal Robot (UR5) as an actuation system.

Real-Time Dynamic Hardware Reconfiguration for Processors with Redundant Functional Units

Abstract: The tiny logic elements in modern integrated circuits increase the rate of transient failures significantly. Therefore, redundancy on various levels is necessary to retain reliability. However, for mixed-criticality scenarios, the typical processor designs offer either too little fault-tolerance or too much redundancy for one part of the applications. Amongst others, we specifically address redundant processor internal functional units (FU) to cope with transient errors and support wear leveling. A real-time operating system (RTOS) was extended to control our prototypical hardware platform and, since it can be configured deterministically within few clock cycles, we are able to reconFigure the FUs dynamically, at process switching time, according to the specified critically of the running processes. Our mechanisms were integrated into the Plasma processor and the Plasma-RTOS. With few changes to the original software code, it was, for example, possible to quickly change from fault-detecting to fault-correcting modes of the processor on demand.

A Real-Time Application with Fully Predictable Task Timing

Abstract: Real-time control systems must adequately react to changes in system state within a time limit determined by the dynamics of the controlled system, otherwise their stability might be compromised. It is therefore essential to determine the Worst-Case Execution Time (WCET) of the control algorithms to verify that they will always be able to satisfy that constraint. However, WCET analysis is a complex process, requiring manual intervention, and the computed bounds are often grossly overestimated. We avoid the difficulties of WCET estimation by making use of the single-path paradigm for the implementation of the control algorithm for a quadcopter. By using single-path code we do not only replace the cumbersome WCET analysis with a single measurement, we simultaneously avoid the detrimental effects of response-time variability. We show that single-path code can be applied to real-time controllers and that it is practical for dramatically simplifying WCET analysis as well as eliminating variability in the execution time. Our results show that despite its apparent inefficiency, the WCET of single-path code on a time-predictable soft microprocessor rivals that of a state-of-the-art superscalar processor.

Predictable Vision for Autonomous Systems

Abstract: In this perspective cum case-study paper, we argue the need for designing timing-predictable vision processing algorithms for autonomous systems. Many core functions in systems like autonomous vehicles involve computer vision within a control loop. Designing such closed-loop controllers and guaranteeing their performance requires the vision processing to be predictable. But this is challenging given the multitude of choices when implementing vision processing algorithms, and the heterogeneity of the architectures (involving GPUs and FPGAs) on which such algorithms are implemented. Towards this, we report a tracing and measurement infrastructure we have been building and illustrate its potential utility using a case study.

Time-dependent Decentralized Routing using Federated Learning

Abstract: Recent advancements in cloud computing have driven rapid development in data-intensive smart city applications by providing near real time processing and storage scalability. This has resulted in efficient centralized route planning services such as Google Maps, upon which millions of users rely. Route planning algorithms have progressed in line with the cloud environments in which they run. Current state of the art solutions assume a shared memory model, hence deployment is limited to multiprocessing environments in data centers. By centralizing these services, latency has become the limiting parameter in the technologies of the future, such as autonomous cars. Additionally, these services require access to outside networks, raising availability concerns in disaster scenarios. Therefore, this paper provides a decentralized route planning approach for private fog networks. We leverage recent advances in federated learning to collaboratively learn shared prediction models online and investigate our approach with a simulated case study from a mid-size U.S. city.

A Generalized Approach for Non-intrusive Real-time Instrumentation of Standards-based Distributed Middleware

Abstract: This paper presents a generalized approach for non-intrusive, real-time instrumentation of standards-based distributed middleware for analytical purposes. The approach is implemented in a tool named the Standards-based Distributed Middleware Monitor (SDMM). SDMM uses dynamic binary instrumentation as the method to extract values and other data passed between endpoints. Using dynamic instrumentation allows SDMM to capture information without a priori knowledge of the distributed application under instrumentation. We applied SDMM to applications written in two standards-based middleware, the Data Distribution Service (DDS) and gRemote Procedure Call (gRPC). We show that the data collection process accounts for less than 1% of the performance overhead for both DDS and gRPC case studies.

ODRE Workshop: Probabilistic Dynamic Hard Real-Time Scheduling in HPC

Abstract: Industry 4.0 is changing fundamentally the way data is collected, stored and analyzed in industrial processes. While this change enables novel application such as flexible manufacturing of highly customized products, the real-time control of these processes, however, has not yet realized its full potential. We believe that modern virtualization techniques, specifically application containers, present a unique opportunity to decouple control functionality from associated hardware. Through it, we can fully realize the potential for highly distributed and transferable industrial processes even with real-time constraints arising from time-critical sub-processes. In this paper, we present a specifically developed orchestration tool to manage the challenges and opportunities of shifting industrial control software from dedicated hardware to bare-metal servers or (edge) cloud computing platforms. Using off-the-shelf technology, the proposed tool can manage the execution of containerized applications on shared resources without compromising hard real-time execution determinism. Through first experimental results, we confirm the viability and analyzed the behavior of resource shared systems with strict real-time requirements. We then describe experiments set out to deliver expected results and gather performance, application scope and limits of the presented approach.

Security in Mixed Time and Event Triggered Cyber-Physical Systems using Moving Target Defense

Abstract: Memory corruption attacks such as code injection, code reuse, and non-control data attacks have become widely popular for compromising safety-critical Cyber-Physical Systems (CPS). Moving target defense (MTD) techniques such as instruction set randomization (ISR), address space randomization (ASR), and data space randomization (DSR) can be used to protect systems against such attacks. CPS often use time-triggered architectures to guarantee predictable and reliable operation. MTD techniques can cause time delays with unpredictable behavior. To protect CPS against memory corruption attacks, MTD techniques can be implemented in a mixed time and event-triggered architecture that provides capabilities for maintaining safety and availability during an attack. This paper presents a mixed time and event-triggered MTD security approach based on the ARINC 653 architecture that provides predictable and reliable operation during normal operation and rapid detection and reconfiguration upon detection of attacks. We leverage a hardware-in-the-loop testbed and an advanced emergency braking system (AEBS) case study to show the effectiveness of our approach.

An Architecture for Declarative Real-Time Scheduling on Linux

Abstract: This paper proposes a novel framework and programming model for real-time applications supporting a declarative access to real-time CPU scheduling features that are available on an operating system. The core idea is to let applications declare their temporal characteristics and/or requirements on the CPU allocation, where, for example, some of them may require real-time POSIX priorities, whilst others might need resource reservations through SCHED_DEADLINE. The framework can properly handle such a set of heterogeneous requirements configuring an underlying multi-core platform so to exploit the various scheduling disciplines that are available in the kernel, matching applications requirements. The framework is realized as a modular architecture in which different plugins handle independently certain real-time scheduling features within the underlying kernel, easing the customization of its behavior to support other schedulers or operating systems by adding further plugins.

EXPPO: EXecution Performance Profiling and Optimization for CPS Co-simulation-as-a-Service

Abstract: A co-simulation may comprise several heterogeneous federates with diverse spatial and temporal execution characteristics. In an iterative time-stepped simulation, a federation exhibits the Bulk Synchronous Parallel (BSP) computation paradigm in which all federates perform local operations and synchronize with their peers before proceeding to the next round of computation. In this context, the lowest performing (i.e., slowest) federate dictates the progression of the federation logical time. One challenge in co-simulation is performance profiling for individual federates and entire federations. The computational resource assignment to the federates can have a large impact on federation performance. Furthermore, a federation may comprise federates located on different physical machines as is the case for cloud and edge computing environments. As such, distributed profiling and resource assignment to the federation is a major challenge for operationalizing the co-simulation execution at scale. This paper presents the Execution Performance Profiling and Optimization (EXPPO) methodology, which addresses these challenges by using execution performance profiling at each simulation execution step and for every federate in a federation. EXPPO uses profiling to learn performance models for each federate, and uses these models in its federation resource recommendation tool to solve an optimization problem that improves the execution performance of the co-simulation. Using an experimental testbed, the efficacy of EXPPO is validated to show the benefits of performance profiling and resource assignment in improving the execution runtimes of co-simulations while also minimizing the execution cost.

Context-based learning for autonomous vehicles

Abstract: This research seeks to prove that Deep Recurrent Q-Network (DRQN) approaches are great options for the control of autonomous vehicles. DRQN algorithms are widely used in video game competitions, but not many studies are available for their use in autonomous vehicles. In this paper, we present a context-based learning approach using DRQN for driverless vehicles. Our experiments demonstrate the effectiveness of using the DRQN algorithm over others.

Real-Time Event-Based Dynamic Multi-Facility Vehicle Rerouting

Abstract: This paper presents a system architecture for real-time information transmission between the dispatcher and service vehicles allowing the logistic system the possibility of reacting to dynamic events such as new service requests and dropouts in the Internet of Things (IoT) paradigm. This paper focuses on a variant of the vehicle routing problem (VRP) called the capacitated multi-depot vehicle routing problem and takes into consideration the dynamic nature of the system. To obtain real-time solutions to the routing problem, a new two-stage algorithm is detailed that makes use of various heuristics and local search metaheuristics to generate high-quality solutions to facilitate real-time decision-making. The proposed methodology creates an initial route plan for the predetermined requests and then modifies the original route as new events (customer requests) are available over time. The performance of proposed rerouting algorithms demonstrated in a simulated framework with two depots and four vehicles.

Evaluation and Complexity Analysis of Task Dependencies in an Artificial Hormone System

Abstract: We study an extension of the Artifical Hormone System (AHS). The AHS is a decentralized task allocation system which has self-organizing properties. We extend the AHS by negator hormones where a task sending such a negator suppresses the execution of other tasks. We can realize conditional task structures in this way and use them to execute a task set on heterogeneous processors: If high-performance processors are available, high-performance tasks can be instantiated by the AHS. If the high-performance processors are failing, another task set running on general purpose processors is allocated (but with lower performance as before). We evaluate the negator approach by realizing two different control strategies for a self-balancing vehicle.The introduction of negators increases the complexity of deciding whether a communication path leading along several different tasks reaches its target eventually. We call this decision problem NEGATOR-PATH and prove its NP-completeness.

Towards Industrial Security Through Real-time Analytics

Abstract: Industrial control system (ICS) denotes a system consisting of actuators, control stations, and network that manages processes and functions in an industrial setting. The ICS community faces two major problems to keep pace with the broader trends of Industry 4.0: (1) a data rich, information poor (DRIP) syndrome, and (2) risk of financial and safety harms due to security breaches. In this paper, we propose a private cloud in the loop ICS architecture for real-time analytics that can bridge the gap between low data utilization and security hardening.

An Integrated Cyber-Physical Fault Management Approach

Abstract: Fault-tolerance in distributed cyber-physical systems involves a close interplay between the physical system: the ’plant’ to be controlled and the distributed computing layer that controls it. In this paper, a systematic approach for designing resilient decentralized control applications is presented that considers both the cyber and physical faults and how they affect each other (if at all). It establishes a formal methodology for system design and then illustrates its use in an example application related to the power grid.

The Efficient Multiprocessor Implementation of Synchronous Reactive Components

Abstract: Model-based design methodologies based on the synchrony assumption are widely used in many safety-critical application domains. The synchrony assumption asserts that actions (such as the execution of code) occur instantaneously; however, physical platforms obviously do not possess this property. This paper considers a scheduling problem that arises when one seeks to implement programs that are written under the synchrony assumption upon actual multiprocessor platforms, and shows that existing results from scheduling theory can be adapted to solve this scheduling problem.Synchronous programming, Multiprocessor scheduling, Deadlines, Makespan minimization, Processor speedup factor.

Using Multi-core Architectures to Improve the Performance of Real-time Dynamic Binary Instrumentation

Abstract: This paper presents a novel technique and framework for decreasing instrumentation overhead in software systems that utilize dynamic binary instrumentation. First, we introduce a lightweight networking framework combined with an easily extensible BSON implementation as a heavy analysis routine replacement. Secondly, we bind instrumentation and analysis threads to non-overlapping cpu cores—allowing analysis threads to execute faster. Lastly, we utilize a lock-free buffering system to bridge the gap between instrumentation and analysis threads, and minimize the overhead to the instrumentation threads. Using this combination, we managed to write a dynamic binary instrumentation tool (DBI) in Pin using Pin++ that is 1000% faster than its counterpart DBI tool with no buffering.

Towards Dual-Issue Single-Path Code

Abstract: The Patmos instruction-set architecture is designed for real-time systems. As such, it has features that increase the predictability of code running on it. One important feature is its dual-issue pipeline: instructions may be organized in bundles of two that are issued and executed in parallel. This increases the throughput of the processor in a predictable manner, but only if the compiler makes use of it.Single-path code is a code-generation technique that produces predictable executions by always following the same trace of instructions. The Patmos compiler can already produce single-path code, but it does not use the second issue slot available in the processor. This is less than ideal because the single-path transformation results in code that has a high degree of instruction-level parallelism.In this paper, we present a single-path code generator that can produce bundled instructions. It includes generic support for bundling algorithms, such that implementing them is simple and does not require changing other parts of the compiler.We also present one such bundling algorithm plugged into the single-path code generator. With it, we show that we can produce dual-issue instructions to improve performance.

Harmonizing ARINC 653 and Realtime POSIX for Conformance to the FACE Technical Standard

Abstract: The avionics industry is converging toward the next generation of software standards produced by The Open Group via the Future Airborne Capability Environment (FACE) consortium and related FACE Technical Standard. The standard combines ARINC 653, a previous avionics standard, with subsets of POSIX 1003.1 that are closely aligned with the POSIX realtime profiles PSE52, PSE53, and PSE54. In this paper, we describe our approach to design, implement, and certify a system with FACE Conformance to the FACE Operating System Segment Safety Base profile. Our approach integrates the ARINC 653-compliant Deos with RTEMS, an open-source real-time operating system (RTOS). Our goal in combining Deos/RTEMS was to achieve certification of FACE Conformance in a low-cost manner by relying on existing, mature software that already provides the majority of the functionality required by the FACE Technical Standard. We reached our goal with under 10,000 source lines of code (SLOC) written to integrate RTEMS into Deos and implement any additional POSIX application programming interfaces (APIs) and tests needed for certification.

A Model-driven Middleware Integration Approach for Performance-Sensitive Distributed Simulations

Abstract: Complex simulation systems often comprise multiple distributed simulators that need to interoperate and synchronize states and events. In many cases, the simulation logics which are developed by different teams with specific expertise, need to be integrated to build a complete simulation system. Thus, supporting composability and reusability of simulation functionalities with minimal integration and performance overhead is a challenging but required capability. Middleware for game engines are promising to realize both the modular and reusable development criteria as well as the high performance requirements, while data-centric publish/subscribe middleware can support seamless integration and synchronization of the distributed artifacts. However, differences in the level of abstraction at which these middleware operate and the semantic differences in their underlying ontologies make it hard and challenging for simulation application developers and system integrators to realize a complete, operational system. To that end this paper presents a model-driven approach to blending the two middleware, wherein the modeling capabilities provide intuitive and higher-level abstractions for developers to reason about the composition and validation of the complete system, and the generative capabilities address the inherent and accidental complexities incurred in reconciling the semantic differences between the gaming and pub/sub middleware. We present a concrete implementation of our approach and illustrate its use and performance results using simple use cases.

A Situation-Aware Adaptation Framework for Intelligent Transportation Systems

Abstract: A transportation system is usually well-defined and operates based on a specific model defined during system design. However, the system can interact with different objects from its environment at runtime and needs to guarantee its functional and timing behavior even in the presence of adverse or failure situations through self-adaptation. Traditionally, techniques such as design analysis and testing are performed during the system design and development stage. During the adaptation process, the transportation system needs to provide assurance such that it is safe and schedulable. We present an adaptation framework, which guarantees the functional and timing behavior of the system in different situations by creating a knowledge base from mining the video stream of the monitored environment. The knowledge base provides information on system interactions with external objects, constraints imposed on the system due to interactions, and characterizes the runtime behavior. We guarantee the timing behavior by evaluating the constraints and their effects on the performance of the system. The experimental analysis of our work demonstrates that the situation-aware adaptation framework can significantly improve system performance by reducing scheduling overload and response time.

The Price of Schedulability in Multi-Object Tracking: The History-vs.-Accuracy Trade-Off

Abstract: Autonomous vehicles often employ computer-vision (CV) algorithms that track the movements of pedestrians and other vehicles to maintain safe distances from them. These algorithms are usually expressed as real-time processing graphs that have cycles due to back edges that provide history information. If immediate back history is required, then such a cycle must execute sequentially. Due to this requirement, any graph that contains a cycle with utilization exceeding 1.0 is categorically unschedulable, i.e., bounded graph response times cannot be guaranteed. Unfortunately, such cycles can occur in practice, particularly if conservative execution-time assumptions are made, as befits a safety-critical system. This dilemma can be obviated by allowing older back history, which enables parallelism in cycle execution at the expense of possibly affecting the accuracy of tracking. However, the efficacy of this solution hinges on the resulting history-vs.-accuracy trade-off that it exposes. In this paper, this trade-off is explored in depth through an experimental study conducted using the open-source CARLA autonomous-driving simulator. Somewhat surprisingly, easing away from always requiring immediate back history proved to have only a marginal impact on accuracy in this study.

Failure Detection in TSN Startup Using Deep Learning

Abstract: Time triggered devices are increasingly deployed in safety-critical distributed applications. Failures that manifest during the startup process of the synchronisation service pose a challenge to diagnose. The difficulty stems from the fact that most implemented diagnostic services for time-triggered systems employ the prior knowledge of the schedule to provide diagnosis. However, at the beginning of the startup process, when the global time base is not yet established, these diagnostic services are not viable. This work proposes the use of a fault injection framework to generate data that resembles the behaviour of failed components during startup. The data generated can then be used for developing fault diagnostic mechanisms. Due to the large data set that can be provided by fault injection frameworks, deep learning is proposed as a strategy for failure identification. The data generated from a fault injection framework is used to train the neural network to distinguish between correct behaviour, corruption and omission failures during startup.

Probabilistic Schedulability Analysis for Real-time Tasks with Precedence Constraints on Partitioned Multi-core

Abstract: The design of embedded systems is facing the explosion of new functionalities requiring increased computation capacities and, thus, the introduction of multi-core processors. Moreover, some functionalities may impose precedence constraints between the programs implementing them. In this paper, we consider partitioned scheduling of tasks with precedence constraints defined by multiple Directed Acyclic Graphs (DAGs). The variability of execution and communication times is taken into account by describing them with probability distributions. Our probabilistic response time analysis is validated on random generated task sets and on a PX4 drone autopilot.