Hard Real-time Tasks Research Articles

A Hybrid Scheduling Framework for Mixed Real-Time Tasks in an Automotive System With Vehicular Network

As vehicles integrate more and more autonomous driving functionalities, it becomes more and more important to use vehicular networks to fully guarantee the safety and real-time performance of on-board computing tasks. Current studies on vehicular networks pay much attention to the performance improvement of network communication and resource allocation, while ignoring the fact that automotive on-board computing tasks play a significant role in vehicle safety and need to be elegantly handled in vehicular networks. In this paper, we propose a hybrid scheduling framework for meeting all hard real-time task deadlines while minimizing soft real-time task deadline misses. In particular, the proposed scheduler is composed of some local schedulers and a global scheduler, where the former guarantees the schedulability of all hard real-time tasks, and the latter decides the assignment of soft real-time jobs dynamically online. Depending on the remaining processing capability of a vehicular network, arrival jobs are either assigned for further processing or discarded. An approach combining the utilization-based schedulability test and demand-supply analysis is proposed to effectively assign tasks to processors offline. To meet as many soft real-time task deadlines as possible, tasks' demand and supply bounds are computed at runtime, such that online execution information can be used to compensate for the scheduling loss with the worst-case assumption made by the offline test. Experimental results demonstrate that, compared to a genetic algorithm, our proposed approach needs far less computation to assign more tasks offline. The online scheduling also saves many soft real-time jobs that were to be dropped by the offline algorithm.

Extensibility-aware Fog Computing Platform configuration for mixed-criticality applications

In this paper, we consider that critical control applications and Fog applications share a Fog Computing Platform (FCP). Critical control applications are implemented as periodic hard real-time tasks and messages and have stringent timing and safety requirements, and require safety certification. Fog applications are implemented as aperiodic tasks and messages and are not critical. Such applications need different approaches to guarantee their timing and dependability requirements. We formulate an optimization problem for the joint configuration of critical control and Fog applications, such that (i) the deadlines and Quality-of-Control (QoC) of control applications are guaranteed at design-time, (ii) the configuration is extensible and supports the addition of future new control applications without requiring costly re-certification, and (iii) the design-time configuration together with the runtime Fog resource management mechanisms, can successfully accommodate multiple dynamic responsive Fog applications. We evaluate our approach on several test cases assuming scenarios for hosting both Fog applications and future critical control applications. The results show that our approach generates extensible schedules which enables Fog nodes to handle Fog applications with a shorter response time and a larger number of future control applications.

A security-aware hardware scheduler for modern multi-core systems with hard real-time constraints

In this paper, we propose an online security-aware hardware scheduler, the so-called Secure And Fast hardware Scheduler (SAFAS), for real-time task scheduling in multi-core systems in the presence of schedule-based side-channel attacks. To avoid such attacks and ensure that all tasks meet their deadlines, SAFAS schedules critical tasks and their replicas using a hardware-based strict Least Slack Time first (LST) algorithm independently while it independently schedules the non-critical tasks using a hardware-based EDF algorithm. SAFAS enhances the system performance and reduces the chance of side-channel attacks due to the different processing cores allocated to each task in each scheduling interval. The hardware scheduler operates independently and in parallel with the multi-core system and hides the scheduling characteristics from adversaries. The software-based Earliest Deadline First (EDF) algorithm is also used for schedulability tests and feasibility analysis of hard real-time periodic tasks to maximize the number of tasks scheduled successfully in the multi-core system. SAFAS has been synthesized and simulated on a Xilinx Vivado 2018.2 and implemented on a Spartan-7 FPGA chip. Our experimental results indicate that SAFAS increases the performance of the system by 4.8 times as compared to previous state-of-the-art hardware schedulers while guaranteeing that all critical tasks and their replicas meet their deadlines.

Low-Power Task Scheduling Algorithm for the Multicore Processor System Based on the Genetic Algorithm

In order to solve the periodic hard real-time tasks with dependencies on multicore processors, the author proposes a low-power task scheduling algorithm for multicore processor systems based on the genetic algorithm. This method first uses the RDAG algorithm to separate the tasks and then takes the lowest power consumption as the principle; a genetic algorithm is used to determine the task mapping. Experimental results show that based on the power consumption model of Intel PXA270, several random task sets are used for simulation experiments, which shows that this method saves 20% to 30% of the energy consumption compared with the existing methods. This method effectively shortens the completion time of tasks, improves the utilization efficiency of multicore system resources, improves the parallel computing capability of multicore systems, reduces the average response time of tasks, and improves the throughput and resource utilization of multicore systems.

Improving the Schedulability of Real-Time Tasks Using Fog Computing

Due to the significant communication delay to user tasks, the cloud is not ideal for executing real-time tasks with stringent deadlines. Fog computing consists of low computation capability fog nodes, or cloudlets located in proximity to the source of the data generation: the users. These cloudlets are ideal for executing tasks that have early deadlines. In this paper, we propose algorithms that schedule a set of real-time tasks on such an embedded-fog-cloud architecture. We consider hard, firm and soft tasks. The execution framework consists of embedded, fog and cloud processors. Tasks are scheduled on appropriate processors based on their deadline requirements. In general, hard real-time tasks are executed on embedded processors, firm real-time tasks on fog processors, and soft real-time tasks on cloud processors. We also propose a sufficient schedulability condition. Simulation results from the CERIT trace as well as test-bed results show that the proposed algorithms offer superior performance as compared to algorithms that do not employ fog processors. Employing an <inline-formula><tex-math notation="LaTeX">$Embedded-fog-cloud$</tex-math></inline-formula> architecture offers an improvement of 62.37 percent for real-time Success Ratio (SR) and 35 percent for Average Response Time as compared to scheduling tasks on the <inline-formula><tex-math notation="LaTeX">$cloud$</tex-math></inline-formula> alone.

MSAR‐DefogNet: Lightweight cloud removal network for high resolution remote sensing images based on multi scale convolution

High resolution remote sensing image cloud removal can bring a lot of convenience for human activities. However, the existing cloud removal algorithms have a variety of disadvantages. First of all, they have the disadvantages of long computing time and large consumption of computing resources. Secondly, the effect of recovery needs to be improved. In order to improve the above two points, a near real-time effective algorithm is proposed, namely MSAR-Defognet (multiple scale attention residual network using for cloud remove), which consumes less computing power and space and has superior cloud removal effect. On the one hand, several different large-scale filters are chosen to extract the weak information effectively, while can save the computing power and shorten the image processing time. On the other hand, the fine-grained convolution residual block with channel attention mechanism is used to enhance the network's ability to extract cloud features. In addition, a data set which is closer to the real cloud shape and has higher richness to train the cloud removal network, so that the parameters obtained by training have stronger robustness and can adaptively remove clouds with different thickness. Experiments show that, compared with other advanced network models, the network not only has the advantage of fast processing speed, but also has better image restoration effect in high-resolution remote sensing image restoration. It can meet the requirements of many hard real-time tasks, so that remote sensing images can play a greater value for human activities.

Integrated Scheduling of Real-Time and Interactive Tasks for Configurable Industrial Systems

With the recent advances in Internet of Things and cyber-physical systems technologies, smart industrial systems support configurable processes consisting of human interactions as well as hard real-time functions. This implies that irregularly arriving interactive tasks and traditional hard real-time tasks coexist. As the characteristics of the tasks are heterogeneous, it is not an easy matter to schedule them all at once. To cope with this situation, this article presents a new task scheduling policy that uses the notion of “virtual real-time task” and two-phase scheduling. As hard real-time tasks must keep their deadlines, we perform offline scheduling based on genetic algorithms beforehand. This determines the processor's voltage level and memory location of each task and also reserves the virtual real-time tasks for interactive tasks. When interactive tasks arrive during the execution, online scheduling is performed on the time slot of the virtual real-time tasks. As interactive workloads evolve over time, we monitor them and periodically update the offline scheduling. Experimental results show that the proposed policy reduces the energy consumption by 66.8% on average without deadline misses and also supports the waiting time of less than 3 (s) for interactive tasks.

Toward Practical Weakly Hard Real-Time Systems: A Job-Class-Level Scheduling Approach

Recent applications of the Internet of Things and cyber–physical systems require the integration of many sensing and control tasks into resource-constrained embedded devices. Such tasks can often tolerate a bounded number of timing violations. The concept of weakly hard real-time systems can effectively improve resource efficiency without sacrificing system safety. However, the existing studies have limitations on their practical use due to the restrictions imposed on the task timing behavior, high analysis complexity, and the lack of multicore support. In this article, we propose a new job-class-level fixed-priority preemptive scheduler and its schedulability analysis framework for weakly hard real-time tasks. Our proposed scheduler employs the meet-oriented classification of jobs of a task in order to reduce the worst-case temporal interference imposed on other tasks. Under this approach, each job is associated with a “job-class” that is determined by the number of deadlines previously met (with a bounded number of consecutively missed deadlines). This approach allows decomposing the complex weakly hard schedulability problem into two subproblems that are easier to solve: 1) analyzing the response time of a job with each job-class, which can be done by an extension of the existing task-level analysis and 2) finding possible job-class patterns, which can be modeled as a simple reachability tree. We also present a semipartitioned task allocation method for multicore platforms, which enhances the schedulability of weakly hard tasks under the proposed scheduling framework. Experimental results indicate that our scheduler outperforms the prior work in terms of task schedulability and analysis time complexity. We have also implemented a prototype of a job-class-level scheduler in the Linux kernel running on Raspberry Pi with acceptably small-runtime overhead.

Multiarmed-Bandit-Based Decentralized Computation Offloading in Fog-Enabled IoT

The Internet-of-Things (IoT) environments have hard real-time tasks that need execution within fixed deadlines. As IoT devices consist of a myriad of sensors, each task is composed of multiple interdependent subtasks. Toward this, the cloud and fog computing platforms have the potential of facilitating these IoT sensor nodes (SNs) in accommodating complex operations with minimum delay. To further reduce operational latencies, we breakdown the high-level tasks into smaller subtasks and form a directed acyclic task graph (DATG). Initially, the SNs offload their tasks to a nearby fog node (FN) based on a greedy choice. The greedy formulation helps in selecting the FN in linear time while avoiding combinatorial optimizations at the SN, which saves time as well as energy. IoT environments are highly dynamic, which mandates the need for adaptive solutions. At the chosen FN, depending on the dependencies on the DATGs, its corresponding deadlines, and the varying conditions of the other FNs, we propose an $\epsilon $ -greedy nonstationary multiarmed bandit-based scheme (D2CIT) for online task allocation among them. The online learning D2CIT scheme allows the FN to autonomously select a set of FNs for distributing the subtasks among themselves and executes the subtasks in parallel with minimum latency, energy, and resource usage. Simulation results show that D2CIT offers a reduction in latency by 17% compared to traditional fog computing schemes. Additionally, upon comparison with existing online learning-based task offloading solutions in fog environments, D2CIT offers an improved speedup of 59% due to the induced parallelism.

Maximizing Utilization and Minimizing Migration in Thermal-Aware Energy-Efficient Real-Time Multiprocessor Scheduling

This work proposes CAlECs, a clustered scheduling system for MPSoCs subject to thermal and energy constraints. It calculates off-line a cyclic executive honoring temporal and thermal constraints, for a hard real-time (HRT) task set at minimum frequency to reduce consumed energy, minimizing context switches and migrations. It also provides an on-line controller able to manage system and task parametric variations and soft real-time (SRT) tasks, always meeting the HRT task set constraints and the system thermal bound. CAlECS maximizes CPU utilization to help avoid overprovisioning contributing to a low SWaP factor. Its modular design allows the utilization of different modeling and scheduling approaches, and makes the off-line and on-line components independent from each other to better suit the requirements of a specific system. We experimentally show that the cyclic executive provided by CAlECS for HRT task sets outperforms RUN, a reference off-line algorithm in terms of optimal number of context switches.

EDF scheduling of real-time tasks on multiple cores

This paper presents a novel migration algorithm for real-time tasks on multicore systems, based on the idea of migrating tasks only when strictly needed to respect their temporal constraints and a combination of this new algorithm with EDF scheduling. This new "adaptive migration" algorithm is evaluated through an extensive set of simulations showing good performance when compared with global or partitioned EDF: our results highlight that it provides a worst-case utilisation bound similar to partitioned EDF for hard real-time tasks and an empirical tardiness bound (like global EDF) for soft real-time tasks. Therefore, the proposed scheduler is effective for dealing with both hard and soft real-time workloads.

Firmness Analysis of Real-time Tasks

( m , k )-firm real-time tasks require meeting the deadline of at least m jobs out of any k consecutive jobs. When compared to hard real-time tasks, ( m , k )$-firm tasks open up the possibility of tighter resource-dimensioning in implementations. Firmness analysis verifies the satisfaction of ( m , k )-firmness conditions. Scheduling policies under which a set of periodic tasks runs on a resource influence the number of deadline missed jobs. Therefore, the nature of the firmness analysis problem depends on scheduling policies. In this work, we present Firmness Analysis (FAn) methods for three common scheduling policies—synchronous and asynchronous Static Priority Preemptive (SPP) policies and Time Division Multiple Access (TDMA). We first introduce the Balloon and Rake problem—the problem of striking the maximum number of balloons in a balloon line with a rake. We show that the common core of firmness analysis problems can be abstracted as the Balloon and Rake problem. Next, we prove that the Finite Point method is a solution to the Balloon and Rake problem. We illustrate how existing FAn methods for the TDMA and asynchronous SPP policies can be adapted to use the same solution framework for the Balloon and Rake problem. Using the solution of the Balloon and Rake problem, we adapt the existing FAn methods to synchronous SPP scheduling policies. The scalability of the FAn methods is compared with that of a timed-automata approach, a brute-force approach, and a Mixed Integer Linear Programing method. The FAn methods scale substantially better to firmness analysis problem instances with a large k and a high number of tasks.

Performance comparison of partitioned and global approaches for weakly hard real-time systems

One way to minimizing resource requirements is through the careful management and allocation, in example, scheduling. Research on weakly hard real-time scheduling on multiprocessor has been extremely limited; most prior research on real-time scheduling on weakly hard real-time has been confined to uniprocessors. The need for multiprocessor is due to issues that impose limits on the performance of a single processor. As real-time application systems increasingly come to be implemented upon multiprocessor environments, thus, this study applies multiprocessor scheduling approach for verification of weakly hard real-time tasks and to guaranteeing the timing requirements of the tasks. In fact, within the multiprocessor, the task allocation and migration problems seem even harder than in uniprocessor case; thus, in order to cater that problem, the sufficient and efficient scheduling algorithm supported by accurate schedulability analysis technique is present to provide weakly hard real-time guarantees. The proposed approach involves the two existing multiprocessor real-time scheduling algorithms combining with the hyperperiod analysis and deadline models; weakly hard constraints and μ-pattern. In this paper, the Matlab simulation tool is used in order to validate the result of analysis. From the experimental and performance evaluation results, it proved that the proposed approach is satisfied the tasks deadlines with less number of misses.

Energy-efficient offloading of real-time tasks using cloud computing

With the increasing number of sophisticated power-intensive applications, embedded systems require energy-efficient computing devices. Most real-time applications of embedded systems are subject to timing constraints that should be met for the applications to run properly. Unfortunately, local computational devices have limited computation and storage capacity. Moreover, the real-time applications that perform complex computations consume large amounts of power. Therefore, offloading the power-intensive computational tasks to a more powerful entity is an efficient technique to overcome the limited computational resources of local devices and reduces the overall power consumption. In this paper, we propose two algorithms for making an efficient offloading decision for soft and weakly hard (firm) real-time applications while guaranteeing the schedulability of tasks. We have performed different experiments and investigated the technical and economic feasibility of using offloading to perform various processes that require different computational power. Experimental results show that significant power can be saved by offloading the resources of the power-intensive applications into the cloudlet for weakly hard real-time tasks and and cloud for soft real-time tasks.

Compiling for the Worst Case

Modern embedded hard real-time systems feature multiple tasks running on multiple processing cores. Schedulability analysis of such systems is usually performed on an abstract system level with each task being represented as a black box with fixed timing properties. If timing constraints are violated, then optimizing the system on a code-level to achieve schedulability is a tedious task. To tackle this issue, we propose an extension to the WCET-aware C Compiler framework WCC. We integrated an optimization framework based on Integer-Linear Programming into the WCC that is able to optimize a multi-core system with multiple tasks running on each core with regards to its schedulability. We evaluate the framework by providing two approaches on a schedulability aware static Scratchpad Memory (SPM) allocation: one based on Integer-Linear Programming (ILP) and one based on a genetic algorithm.

Real time scheduler for multiprocessor systems based on continuous control using Timed Continuous Petri Nets

Abstract This work exploits Timed Continuous Petri Nets (TCPN) to design and test a novel energy-efficient thermal-aware real-time global scheduler for a hard real-time (HRT) task set running on a multiprocessor system. The TCPN model encompasses both the system and task set, including thermal features. In previous work we calculated the share of each task that must be executed per time interval by solving off-line an Integer Programming Problem Problem (ILP). A subsequent on-line stage allocated jobs to processors. We now perform the allocation off-line too, including an allocation controller and an execution controller in the on-line stage. This adds robustness by ensuring that actual task allocation and execution honor the safe schedule provided off-line. Last, the on-line controllers allow the design of an improved soft RT aperiodic task manager. Also, we experimentally prove that our scheduler yields fewer context switches and migrations on the HRT task set than RUN, a reference algorithm.

A Novel On-Chip Task Scheduler for Mixed-Criticality Real-Time Systems

This paper presents a novel design of a coprocessor that performs hardware-accelerated task scheduling for embedded real-time systems consisting of mixed-criticality real-time tasks. The proposed solution is based on the Robust Earliest Deadline (RED) algorithm and previously developed hardware architectures used for scheduling of real-time tasks. Thanks to the HW implementation of the scheduler in the form of a coprocessor, the scheduler operations (i.e., instructions) are always completed in two clock cycles regardless of the actual or even maximum task amount within the system. The proposed scheduler was verified using simplified version of UVM and applying billions of randomly generated instructions as inputs to the scheduler. Chip area costs are evaluated by synthesis for Intel FPGA Cyclone V and for 28-nm TSMC ASIC. Three versions of real-time task schedulers were compared: EDF-based scheduler designed for hard real-time tasks only, GED-based scheduler and the proposed RED-based scheduler, which is suitable for tasks of various criticalities. According to the synthesis results, the RED-based scheduler consumes LUTs and occupies larger chip area than the original EDF-based scheduler with equivalent parameters used. However, the RED-based scheduler handles variations of task execution times better, achieves higher CPU utilization and can be used for the scheduling of hard real-time, soft real-time and nonreal-time tasks combined in one system, which is not possible with the former algorithms.

Online Slack-Stealing Scheduling with Modified laEDF in Real-Time Systems

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.

A real-time scratchpad-centric OS with predictable inter/intra-core communication for multi-core embedded systems

Multi-core processors have replaced single-core systems in almost every segment of the industry. Unfortunately, their increased complexity often causes a loss of temporal predictability which represents a key requirement for hard real-time systems. Major sources of unpredictability are shared low level resources, such as the memory hierarchy and the I/O subsystem. In this paper, we approach the problem of shared resource arbitration at an OS-level and propose a novel scratchpad-centric OS design for multi-core platforms. In the proposed OS, the predictable usage of shared resources across multiple cores represents a central design-time goal. Hence, we show (i) how contention-free execution of real-time tasks can be achieved on scratchpad-based architectures, and (ii) how a separation of application logic and I/O operations in time domain can be enforced, and (iii) how predictable asynchronous inter/intra-core communication between tasks can be performed. To validate the proposed design, we implemented the proposed OS using commercial-off-the-shelf (MPC5777M) platform. Experimental results show that novel design delivers predictable temporal behavior to hard real-time tasks, and it provides performance gain of upto $$2.1\,\times $$ compared to traditional approaches.

Energy-efficient thermal-aware multiprocessor scheduling for real-time tasks using TCPN

We present an energy-efficient thermal-aware real-time global scheduler for a set of hard real-time (HRT) tasks running on a multiprocessor system. This global scheduler fulfills the thermal and temporal constraints by handling two independent variables, the task allocation time and the selection of clock frequency. To achieve its goal, the proposed scheduler is split into two stages. An off-line stage, based on a deadline partitioning scheme, computes the cycles that the HRT tasks must run per deadline interval at the minimum clock frequency to save energy while honoring the temporal and thermal constraints, and computes the maximum frequency at which the system can run below the maximum temperature. Then, an on-line, event-driven stage performs global task allocation applying a Fixed-Priority Zero-Laxity policy, reducing the overhead of quantum-based or interval-based global schedulers. The on-line stage embodies an adaptive scheduler that accepts or rejects soft RT aperiodic tasks throttling CPU frequency to the upper lowest available one to minimize power consumption while meeting time and thermal constraints. This approach leverages the best of two worlds: the off-line stage computes an ideal discrete HRT multiprocessor schedule, while the on-line stage manage soft real-time aperiodic tasks with minimum power consumption and maximum CPU utilization.