The Improved Earliest Deadline First with Virtual Deadlines Mixed-Criticality Scheduling Algorithm

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.

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.

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.

Formal analysis of feature degradation in fault-tolerant automotive systems

Task automata: Schedulability, decidability and undecidability

In the real-time task scheduling of Cyber Physical System (CPS), the existing scheduling algorithms can’t effectively differentiate the importance level of random tasks, resulting in poor real-time scheduling of important random tasks and insufficient submission rate. This paper comprehensively considers the factors of recent available time, criticality and execution time, and then proposes a fuzzy scheduling algorithm of high priority random tasks (FSA-HPRT) for CPS. The algorithm first obtains the applicable time slice by maximizing delayed the execution time of the periodic task, and calculates the difference between the end time of the periodic task and the deadline time as the error time slice. Then use the fuzzy set to process the latest available time, criticality and execution time of the random task to decide the random task priority. Finally, the task-scheduling queue is established for the system to perform scheduling according to the priority of the random task by using the applicable time slice and the error time slice. The simulation results show that compared with the ISS algorithm, the proposed algorithm can significantly improve the submission rate of important random tasks. At the same time, high-priority random tasks can get responses preferentially.

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.

Considering the execution order restriction of control tasks and message tasks in asynchronous networked control system (NCS), this paper proposes a hybrid scheduling scheme based on earliest deadline first (EDF) algorithm and genetic algorithm (GA). GA is used to allocate control tasks on multiprocessors in order to achieve load balance. For the purpose of meeting message deadlines and maximizing network utilization, non-preemptive EDF is used for the transmission of messages on networks. Finally, a tasks and messages scheduling paradigm is constructed within a least common multiple (LCM) which contains information about execution time and resource allocation of messages and tasks. Simulation results show that execution order restriction and timing constraints can be satisfied and a considerable high resource utilization rate can be achieved through our scheduling scheme.

Future critical computer systems will be capable of controlling many different instruments, and therefore will perform many different tasks simultaneously. The author proposes a critical computer that executes independent tasks in a preemptive multitasking environment. This computer uses N-Version programming to tolerate faults, it consists of three processors to execute three different versions, and a fourth processor to execute the voter of each task. A simulation tool called NVP was developed to simulate the execution of tasks by this computer. The tool simulates execution of up to one thousand independent programs consisting of three versions and a voter. In the computer system there exist a number of techniques for increasing performance and reducing power consumption. Experiments were performed to investigate the effect of these techniques on the execution time of independent tasks. The paper presents results from two of these experiments. In the first experiment sequential execution of tasks is compared with preemptive multitasking execution. Experiment results showed that preemptive multi-tasking was more suitable for executing a large number of independent tasks. The purpose of the second experiment is to determine the effect of varying slice time on task execution time. Results from the experiment show that if the slice time is short then tasks take longer to execute, whereas if slice time is too long then execution time of tasks varies depending on how long the processors spend performing other tasks.

Average-case performance analysis of scheduling random parallel tasks with precedence constraints on mesh connected multicomputer systems

In the past few years, with the rapid development of heterogeneous computing systems (HCS), the issue of energy consumption has attracted a great deal of attention. How to reduce energy consumption is currently a critical issue in designing HCS. In response to this challenge, many energy-aware scheduling algorithms have been developed primarily using the dynamic voltage-frequency scaling (DVFS) capability which has been incorporated into recent commodity processors. However, these techniques are unsatisfactory in minimizing both schedule length and energy consumption. Furthermore, most algorithms schedule tasks according to their average-case execution times and do not consider task execution times with probability distributions in the real-world. In realizing this, we study the problem of scheduling a bag-of-tasks (BoT) application, made of a collection of independent stochastic tasks with normal distributions of task execution times, on a heterogeneous platform with deadline and energy consumption budget constraints. We build execution time and energy consumption models for stochastic tasks on a single processor. We derive the expected value and variance of schedule length on HCS by Clark's equations. We formulate our stochastic task scheduling problem as a linear programming problem, in which we maximize the weighted probability of combined schedule length and energy consumption metric under deadline and energy consumption budget constraints. We propose a heuristic energy-aware stochastic task scheduling algorithm called ESTS to solve this problem. Our algorithm can achieve high scheduling performance for BoT applications with low time complexity $O(n(M+\log n))$ , where $n$ is the number of tasks and $M$ is the total number of processor frequencies. Our extensive simulations for performance evaluation based on randomly generated stochastic applications and real-world applications clearly demonstrate that our proposed heuristic algorithm can improve the weighted probability that both the deadline and the energy consumption budget constraints can be met, and has the capability of balancing between schedule length and energy consumption.

Cluster-based multicore real-time mixed-criticality scheduling

This paper studies the effects of overheads in massively parallel processing. The execution times for tasks on individual processors are modeled as independent and identically but arbitrarily distributed random variables. The time to execute a process fork is assumed to be distributed exponentially. The main result bounds (in expectation) the overhead time in forking a large number of tasks across n machines and then waiting for the join event. The model used is appropriate for massive parallelism (when n is large): in fact, the bound serves as a heavy traffic limit approached as n→ ∞ and for task times that are large in comparison to the time to execute a fork. In this model, the expected total time to reach the final join consists of a forking overhead that grows linearly with the number of processors n, a time for parallel execution of tasks that decreases in n, and finally a synchronization delay that is a concave sublinear function of ρ = EX/EA, which is the ratio of expected task time to the expected time needed to fork a new process. This overhead function is typically no worse than o(ρ). An interesting aspect of the analysis is that the original problem reduces to a previously studied problem in queueing theory: estimating total end-to-end delay in an infinite-server resequencing system. The new results thus provide new bounds and heavy-traffic approximations (in distribution and in expectation) for the theory of M/GI/∞ resequencing queues. INFORMS Journal on Computing, ISSN 1091-9856, was published as ORSA Journal on Computing from 1989 to 1995 under ISSN 0899-1499.

In hard real-time task systems where periodic and aperiodic tasks coexist, the object of task scheduling is to reduce the response time of the aperiodic tasks while meeting the deadline of periodic tasks. Total bandwidth server (TBS) and advanced TBS (ATBS) are used in dynamic priority systems. However, these methods are not optimal solutions because they use the worst-case execution time (WCET) or the estimation value of the actual execution time of the aperiodic tasks. This paper presents an online slack-stealing algorithm called SSML that can make significant response time reducing by modification of look-ahead earliest deadline first (laEDF) algorithm as the slack computation method. While the conventional slack-stealing method has a disadvantage that the slack amount of each frame must be calculated in advance, SSML calculates the slack when aperiodic tasks arrive. Our simulation results show that SSML outperforms the existing TBS based algorithms when the periodic task utilization is higher than 60%. Compared to ATBS with virtual release advancing (VRA), the proposed algorithm can reduce the response time up to about 75%. The performance advantage becomes much larger as the utilization increases. Moreover, it shows a small performance variation of response time for various task environments.

Different from a general-purpose system, a real-time system requires stringent timing guarantees. While existing offline analysis techniques can provide timing guarantees using the worst-case execution time (WCET) of individual tasks, a variation of actual execution time makes it difficult to build covert timing channel. In this paper, we first present a novel covert timing channel, which considers actual execution time distribution of tasks and controls execution time to leak data between conspirators; we demonstrate that it is possible to leak data in real-time systems. Second, we suggest two enhancing techniques called S-R LCM (sender-receiver least common multiple) and noise area to reduce noise in communication. Through simulations, we demonstrate that our covert timing channel can serve trade-off between transmission speed and accuracy; that is, it shows average 50.2%, 54.6% and 51.3% accuracy for 100 test cases with thresholds 0, 1.4 and 2.8. Average 58.4% accuracy is accomplished with best threshold values for 100 test cases, and the maximum accuracy for a single test case is recorded 100.0%.