Mapping mixed-criticality applications on multi-core architectures

Safety-critical cyber-physical systems like autonomous cars require not only different levels of assurance, but also close interactions with dynamically-changing physical environments. While the former has been studied extensively by exploiting the notion of mixed-criticality (MC) systems, the latter has not, especially in conjunction with MC systems. To fill this important gap, we conduct an in-depth case study, demonstrating the importance of capturing current physical states, and introduce the problem of achieving efficient utilization of computing resources under varying physical states in MC systems. To solve this problem, we first develop a physical-state-aware MC task model, which is a generalization of the existing basic MC task model. We then propose new slack concepts tailored to the new task model, which enable efficient utilization of computing resources for MC systems. Finally, we develop a physical-state-aware dynamic slack management framework and demonstrate how to utilize the new MC task model and slack concepts towards efficient system utilization. We show, via a case study and in-depth evaluation, that the proposed framework makes 20x less low-criticality jobs dropped over a popular MC scheduling algorithm without compromising the MC-schedulability requirements.

Mixed criticality systems are one of the relatively new directions of development for the classical real-time systems. As the real-time embedded systems become more and more complex, incorporating different tasks with different criticality levels, the continuous development of mixed criticality systems is only natural. These systems have practically entered every field where embedded systems are present: avionics, automotive, medical systems, wearable devices, home automation, industry and even the Internet of Things. While scheduling techniques have already been proposed in the literature for different types of mixed criticality systems, the number of papers addressing multiprocessor platforms running in a time-triggered mixed criticality environment is relatively low. These algorithms are easier to certify due to their complete determinism and isolation between components of different criticalities. Our research has centered on the problem of real-time scheduling on multiprocessor platforms for periodic tasks in a time-triggered mixed criticality environment. A partitioned, non-preemptive, table-driven scheduling algorithm was proposed, called Partitioned Time-Triggered Own Criticality Based Priority, based on a uniprocessor mixed criticality method. Furthermore, an analysis of the scheduling algorithm is provided in terms of success ratio by comparing it against an event-driven and a time-triggered method.

In the field of real-time systems, component-based models for mixed criticality systems (MCS) on multicore platform are gaining significant attention of the researchers from the recent past. The concept of mixed-criticality is firstly applied on single core systems but after gaining attention, it evolved to multicore platform. Initially, the tasks of MCS executes in low mode however if a task having high criticality does not its scheduling requirements complete its low mode, then the system switch to high mode. In high mode, only high critical tasks executes its high mode scheduling requirements, while all low tasks are discarded from further execution. In the realm of MCS, the component-based model have high importance and has been used in large and complex real-time systems. In component-based model, the component of a system is splatted into multiple components. In this study, a new component-based scheduling approach is proposed for multicore MCS. In the multicore mixed-criticality compositional framework, special emphasis is given on deriving the supply bound function, which represents available core supply, and the demand bound function, which indicates the requirements of resources for scheduling. A mixed-criticality multicore compositional framework (MMCF) is introduced for component-based MCS having tightened deadline. For the proposed strategy, a schedulability analysis is conducted, ensuring that the system can be scheduled only if the supply bound function is equal to or less than the demand bound function. On a 4-core platform, the scheduleability for the three scheduling strategies i.e. MMCF, MC-Partition, and Global are shown at different utilization levels of resource. 100% schedulability is shown by the proposed MMCF, MC-Partition, and global techniques for target utilizations of 0.7, 0.5, and 0.4, respectively. For a given utilization U=0.6, the proposed MMCF approach shows 100 % schedulability, while the MC-partition and global approaches show 90% and 20% schedulabilities respectively. It shows that the proposed MMCF approach schedules 10% and 80% more task sets than the MC-partition and global approaches respectively. The experimental results reveal that the proposed MMCF approach offers better schedulability than the other two approaches.

Mixing tasks of different criticality levels on the same processor has become common in modern embedded systems. Scheduling these complex systems on multicore processors is difficult, especially when targeting high utilization. The overload in mixed criticality systems is one of the important problems that faces system designers and may force them to lower the cores utilization to avoid this risky problem. If a fully utilized system is overloaded and no solution is applied, many of coming jobs will miss their deadlines and the system may stay overloaded all the time and never return back to its normal behavior. So, the overload must be transient and the system should guarantee that it can return back its normal behavior shortly after overload happens. In this paper, we present a kernel-based solution for the overload in mixed criticality systems using virtual time. A virtual timer delays the release time and deadlines of tasks in an overload state for a short time to guarantee that it can return back as quickly as possible to its normal behavior. The proposed solution avoids using any user space invocation, as it detects the overload and recovers from it completely inside the kernel space. Our experiments show that the time to recover from overload once it happens is decreased using our proposed technique.

The cluster-based technique is gaining focus for scheduling tasks of mixed-criticality (MC) real-time multicore systems. In this technique, the cores of the MC system are distributed in groups known as clusters. When all cores are distributed in clusters, the tasks are partitioned into clusters, which are scheduled on the cores within each cluster using a global approach. In this study, a cluster-based technique is adopted for scheduling tasks of real-time mixed-criticality systems (MCS). The Decreasing Criticality Decreasing Utilization with the worst-fit (DCDU-WF) technique is used for partitioning of tasks to clusters, whereas a novel mixed-criticality cluster-based boundary fair (MC-Bfair) scheduling approach is used for scheduling tasks on cores within clusters. The MC-Bfair scheduling algorithm reduces the number context switches and migration of tasks, which minimizes the overhead of mixed-criticality tasks. The migration and context switch overhead time is added at the time of each migration and context switch respectively for a task. In low critical mode, the low mode context switch and migration overhead time is added to task execution time, while the high mode overhead time of migration and context switch is added to the execution time of a task in high critical mode. The results obtained from experiments show the better schedulablity performance of proposed cluster-based technique as compared to cluster-based fixed priority (CB-FP), MC-EKG-VD-1, global and partitioned scheduling techniques e.g., for target utilization U=0.6, the proposed technique schedule 66.7% task sets while MC-EKG-VD-1, CB-FP, partitioned and global techniques schedule 50%, 33.3%, 16.7% and 0% task sets respectively.

Multi-core architectures have grown to be a popular choice for deploying Mixed Criticality Systems (MCS). The focus of research in MCS has been to provide timing assurances for jobs with different criticality levels. Due to their significant processing demands and energy-aware/constrained nature, energy conservation in these systems is becoming mandatory. This article presents, mcDVFS, an energy management technique based on Dynamic-Voltage-and-Frequency-Scaling for multi-core MCS. mcDVFS achieves significant energy reduction while maintaining timing guarantees. It also prioritizes quality of service whenever feasible. Extensive experimental simulations show energy savings of ≈ 52% and 34% when compared to EDF-VD and EDF-VD with QoS.

In Mixed-Criticality (MC) systems, multiple functions with different levels of criticality are integrated into a common platform in order to meet the intended space, cost, and timing requirements in all criticality levels. To guarantee the correct, and on-time execution of higher criticality tasks in emergency modes, various design-time scheduling policies have been recently presented. These techniques are mostly pessimistic, as the occurrence of worst-case scenario at run-time is a rare event. Nevertheless, they lead to an under-utilized system due to frequent drops of Low-Criticality (LC) tasks, and creation of unused slack times due to the quick execution of high-criticality tasks. Accordingly, this paper proposes a novel optimistic scheme, that introduces a learning-based drop-aware task scheduling mechanism, which carefully monitors the alterations in the behaviour of the MC system at run-time, to exploit the generated dynamic slacks for reducing the LC tasks penalty and preventing frequent drops of LC tasks in the future. Based on an extensive set of experiments, our observations have shown that the proposed approach exploits accumulated dynamic slack generated at run-time, by 9.84% more on average compared to existing works, and is able to reduce the deadline miss rate by up to 51.78%, and 33.27% on average, compared to state-of-the-art works.

In a mixed-criticality system, multiple tasks with different levels of criticality may coexist on the same hardware platform. The scheduling algorithm EDF-VD (Earliest Deadline First with Virtual Deadlines) has been proposed for mixed-criticality systems, which assumes tasks do not share any common resources. We present MC-SRP (Mixed-Criticality Stack Resource Policy), a resource synchronization protocol for EDF-VD, which allows resource sharing among tasks at the same criticality level and guarantees that each task is blocked at most once in each criticality mode. In addition, we present MC-SRPT (MC-SRP with Thresholds) for reducing the application stack size requirement in resource-constrained embedded systems.

Mixed-criticality (MC) system has attracted a lot of research attention in the past few years for its resource efficiency. Recent work attempted to provide a new MC model, the so-called Flexible Mixed-Criticality (FMC) task model, to relax the pessimistic assumptions in classic MC scheduling. However, in FMC, the behavior of MC tasks is still analyzed in offline stage. The run-time behavior such as dynamic slack has not yet been studied in FMC scheduling framework. In this paper, we present a utilization-based slack scheduling framework for FMC tasks. In particular, we monitor task execution on run time and collect dynamic slacks generated by task early completion. And these slacks can then be used either by high-criticality tasks to reduce mode-switches, or by low-criticality tasks so that less suspensions are triggered with more execution time, and thus quality of service is improved. We evaluate our approach with extensive simulations, and experiment results demonstrate the effectiveness of the proposed approaches.

Mixed Criticality Systems (MCS) have gained increasing interest in the past few years due to their industrial relevance. When mixed-criticality systems are implemented on multicore architectures, several challenges arise such as the efficient partitioning of these systems. In this paper, we address this issue by presenting a novel mixed-criticality partitioning algorithm, the Dual-Partitioned Mixed-Criticality (DPM) algorithm, that allows limited migration of LO-criticality tasks to enhance the efficiency of the partitioning while maintaining many of the advantages of partitioned systems. Experimental results show that DPM consistently outperforms existing mixed-criticality partitioning algorithms, for example, at utilizations of 0.8 or higher, DPM is able to schedule 17% more systems.

Traditional fixed-priority scheduling analysis for periodic/sporadic task sets is based on the assumption that all tasks are equally critical to the correct operation of the system. Therefore, every task has to be schedulable under the scheduling policy, and estimates of tasks' worst case execution times must be conservative in case a task runs longer than is usual. To address the significant under-utilization of a system's resources under normal operating conditions that can arise from these assumptions, several mixed-criticality scheduling approaches have been proposed. However, to date there has been no quantitative comparison of system schedulability or run-time overhead for the different approaches. In this dissertation, we present what is to our knowledge the first side-by-side implementation and evaluation of those approaches, for periodic and sporadic mixed-criticality tasks on uniprocessor or distributed systems, under a mixed-criticality scheduling model that is common to all these approaches. To make a fair evaluation of mixed-criticality scheduling, we also address some previously open issues and propose modifications to improve schedulability and correctness of particular approaches. To facilitate the development and evaluation of mixed-criticality applications, we have designed and developed a distributed real-time middleware, called MCFlow, for mixed-criticality end-to-end tasks running on multi-core platforms. The research presented in this dissertation provides the following contributions to the state of the art in real-time middleware: (1) an efficient component model through which dependent subtask graphs can be configured flexibly for execution within a single core, across cores of a common host, or spanning multiple hosts; (2) support for optimizations to inter-component communication to reduce data copying without sacrificing the ability to execute subtasks in parallel; (3) a strict separation of timing and functional concerns so that they can be configured independently; (4) an event dispatching architecture that uses lock free algorithms where possible to reduce memory contention, CPU context switching, and priority inversion; and (5) empirical evaluations of MCFlow itself and of different mixed criticality scheduling approaches both with a single host and end-to-end across multiple hosts. The results of our evaluation show that in terms of basic distributed real-time behavior MCFlow performs comparably to the state of the art TAO real-time object request broker when only one core is used and outperforms TAO when multiple cores are involved. We also identify and categorize different use cases under which different mixed criticality scheduling approaches are preferable.

Deploying safety-critical systems into constrained embedded platforms is a challenge for developers who must arbitrate between two conflicting objectives: software has to be safe and resources need to be used efficiently. Mixed-criticality (MC) has been proposed to meet a trade-off between these two aspects. Nonetheless, most task models considered in the literature of MC scheduling, do not take into account precedence constraints among tasks. In this paper, we propose a multi-core scheduling approach for a model presenting MC tasks and their dependencies as a Directed Acyclic Graph (DAG). We also introduce an evaluation framework for this model, released as an open source software. Evaluation of our scheduling algorithm provides evidence of the difficulty to find correct scheduling for DAGs of MC tasks. Besides, experimentation results provided in this paper show that our scheduling algorithm outperforms existing algorithms for scheduling DAGs of MC tasks.

Heterogeneous multicore platforms are becoming an attractive choice to deploy mixed criticality systems demanding diverse computational requirements. One of the major challenges is to efficiently harness the computational power of these multicore platforms while deploying mixed criticality applications with timeliness properties. Energy efficiency is also one of the desired requirements in the design phase, and therefore it is often difficult for the system designer to simultaneously satisfy those sometimes contradictory requirements. In this paper, we propose a novel partitioning algorithm for unrelated heterogeneous multicore platforms to map mixed criticality applications. The algorithm not only ensures the timeliness in different modes of execution but also tries to allocate the applications to their energy-wise favourite cores. We considered a realistic power model that further increases the relevance of the proposed approach. We have performed an extensive set of experiments to evaluate the performance of the proposed approach, and we show that in the best-case, we achieve a 23.8% gain in the average power dissipation over the state-of-the-art partitioned algorithm. Our proposed algorithm also has a better weighted schedulability when compared to the existing partitioned algorithms.

This paper presents a design and implementation of a Mixed-Criticality System (MCS) extended fromμC/OS III. It is based on a MCS model that uses an adaptive reservation mechanism to cope with the uncertainties in task execution times and to increase the resource utilization in MCS. The implementation takes advantage of the tasks’ recent execution records to predict their required computational resource in the near future and adjusts their reserved budget according to their criticality levels. The designed system focuses on soft real-time tasks. An overrun tolerance algorithm is used to limit the deadline miss ratios between a rise to the task’s actual consumption and the change to the amount of reservation. More than two criticality levels can be handled without introducing obvious additional overhead at each added level. The case study evaluation demonstrates that the reserved resource for each task is always close to its actual consumption; the tasks’ deadline misses are bounded by the different requirements specified by the criticality levels; during overload conditions, high-criticality tasks are guaranteed to have sufficient resource reservation. Although there is still room for improvement if it comes to processing overhead, this research brings some inspirations in both modelling and implementation aspects of MCS.

Embedded systems are pervasively used in many fields nowadays. In mixed-criticality environments (automotive, industry 4.0, drones, etc.) they need to run real-time applications with certain time and safety constraints alongside a rich operating system (OS). This is usually possible thanks to virtualization techniques, that leverage on hardware virtualization extensions on the machine. However, these hardware extensions might not cope with the security and safety requirements of the specific use case, and additionally, they might not always be available. A notable example is the emerging RISC-V architecture, that is today gaining a lot of traction in the mixed criticality field, but that does not offer today hardware virtualization extensions. In this paper VOSySmonitoRV is proposed as a mixed-criticality solution for RISC-V systems. VOSySmonitoRV allows the co-execution of two or more operating systems in a secure and isolated manner by running in the highest privileged machine level. A specific benchmark, measuring the interrupt latency and context switch time is done to assess the system performance in mixed criticality systems.