Scheduling Of Parallel Real-time Tasks Research Articles

Energy-harvesting-aware federated scheduling of parallel real-time tasks

Energy-harvesting-aware federated scheduling of parallel real-time tasks

Scheduling Parallel Real-Time Tasks on Virtual Processors

In many popular parallel programming models, e.g., OpenMP (OpenMP, 2013), applications are usually dispatched into several dedicated scheduling entities (named ”threads” in common) for which the processor time of physical platform is provided through the OS schedulers. This behavior requires for a hierarchical scheduling framework, considering each thread as a virtual processor (VP). Moreover, hierarchical scheduling allow separate applications to execute together on a common hardware platform, with each application having the “illusion” of executing on a dedicated component. However, the problem for scheduling parallel real-time tasks on virtual multiprocessor platform has not been addressed yet. An analogous approach to virtual scheduling for parallel real-time tasks is federeted scheudling, where each task exclusively executes on a set of dedicated physical processors. However, federated scheduling suffers significant resource wasting. In this article, we study the scheduling of real-time parallel task on virtual multiprocessors. As a physical processor is shared by virtual processors, tasks effectively share processors with each other. We conduct comprehensive performance evaluation to compare our proposed approach with existing methods of different types. Experiment results show that our approach consistently outperforms existing methods to a considerable extent under a wide range of parameter settings.

Global Fixed-Priority Scheduling for Parallel Real-Time Tasks with Constrained Parallelism

With the rapid development of parallel programming techniques and the widespread use of multiprocessors, scheduling and analysis techniques supporting parallel real-time tasks become a critical topic for multiprocessor real-time systems. Global scheduling that allows the vertices of a parallel task to execute on any processor is a promising scheduling approach with guaranteed theoretical bounds and wide use in practice. However, the complex internal structure of parallel tasks leads to extensive inner- and inter-task interference, which leads to significant pessimism in the worst-case timing analysis. In this paper, a global fixed-priority (G-FP) scheduling with constrained parallelism for parallel real-time tasks based on the sporadic directed acyclic graph (DAG) model is proposed. Each DAG task is assigned a parallel threshold, such that the number of processors occupied by the task is limited to the parallel threshold of the task at a time. We propose a heuristic algorithm to set the parallel threshold and present a response-time analysis (RTA) to exploit the feature of the constrained parallel scheduling. Experiments with randomly generated tasks show that the proposed approach improves the schedulability upon G-FP and federated scheduling in terms of acceptance ratio.

Holistic Resource Allocation Under Federated Scheduling for Parallel Real-time Tasks

With the technology trend of hardware and workload consolidation for embedded systems and the rapid development of edge computing, there has been increasing interest in supporting parallel real-time tasks to better utilize the multi-core platforms while meeting the stringent real-time constraints. For parallel real-time tasks, the federated scheduling paradigm, which assigns each parallel task a set of dedicated cores, achieves good theoretical bounds by ensuring exclusive use of processing resources to reduce interferences. However, because cores share the last-level cache and memory bandwidth resources, in practice tasks may still interfere with each other despite executing on dedicated cores. Such resource interferences due to concurrent accesses can be even more severe for embedded platforms or edge servers, where the computing power and cache/memory space are limited. To tackle this issue, in this work, we present a holistic resource allocation framework for parallel real-time tasks under federated scheduling. Under our proposed framework, in addition to dedicated cores, each parallel task is also assigned with dedicated cache and memory bandwidth resources. Further, we propose a holistic resource allocation algorithm that well balances the allocation between different resources to achieve good schedulability. Additionally, we provide a full implementation of our framework by extending the federated scheduling system with Intel’s Cache Allocation Technology and MemGuard. Finally, we demonstrate the practicality of our proposed framework via extensive numerical evaluations and empirical experiments using real benchmark programs.

Decomposition-based scheduling for parallel real-time tasks on multiprocessors

This paper addresses the problem of multiprocessor real-time scheduling for parallel tasks modeled as directed acyclic graph (DAG). We propose a new decomposition-based scheduling algorithm to schedule parallel DAG tasks with implicit-deadlines. We prove that our algorithm has a resource augmentation bound of 2.618 for DAG tasks with implicit-deadlines when the decomposed tasks are scheduled using Global EDF scheduling, i.e., if the input set of DAG tasks is schedulable on m unit-speed processors, the proposed scheduling algorithm will always succeed on m processors with speed 2.618. This result improves the resource augmentation bound of 2.618 for tasks with special DAGs provided by Qamhieh et al. in 2019. Moreover, when using Global DM (Partitioned-DM, respectively) scheduling for the decomposed tasks, we prove a resource augmentation bound of 3.42 for DAG tasks with implicit-deadlines, which improves the resource augmentation bound of 3.73 for tasks with special DAGs (3.42 for fork-join tasks, respectively).

Decomposition-Based Real-Time Scheduling of Parallel Tasks on Multicores Platforms

Multicore processors have become mainstream computation platforms not only for general and high-performance computers but also for real-time embedded systems. To fully utilize the computation power of multicores, software must be parallelized. Recently, there has been a rapidly increasing interest in real-time scheduling of parallel real-time tasks, but the field is still much less mature than traditional real-time scheduling of sequential tasks. In this article, we study the real-time scheduling and techniques for parallel real-time tasks based on decomposition, where a task graph is transferred to a set of independent sporadic tasks. In particular, we propose new decomposition strategies that better explore the structure feature of each task to improve schedulability. We develop schedulability tests for the global earliest deadline first (EDF) scheduling algorithm based on decomposition and three types of its variants, with their own pros and cons in different aspects. We conduct experiments to evaluate the real-time performance of our proposed scheduling algorithms against the state-of-the-art scheduling and analysis methods of different types.

Power-efficient scheduling of parallel real-time tasks on performance asymmetric multicore processors

The use of computing devices has increased dramatically in recent time, which results in huge power consumption. This situation has made the power consumption a critical metric for evaluating the performance of a computing device. In this paper, we have addressed the real-time scheduling problem of parallel tasks on a performance asymmetric multicore processor with m cores with intent to reduce the power consumption. The proposed algorithm – parallel EDF – first divides the tasks into m segments and then executes these distributed tasks in earliest deadline first (EDF) fashion. Dynamic voltage and frequency scaling (DVFS) is also applied for power savings. We have evaluated the performance of the parallelEDF scheduling algorithm with Equally Fit (EF) algorithm on 70nm based performance asymmetric multicore processor. The results reveal that up to 28% power can be saved at high system utilization level (about 80% system utilization). We have formally modeled the parallelEDF algorithm using high-level Petri nets (HLPN) while these models are also verified using the Satisfiability Modulo Theory (SMT), and Z3 Solver.

Mixed-criticality federated scheduling for parallel real-time tasks

A mixed-criticality system comprises safety-critical and non-safety-critical tasks sharing a computational platform. Thus, different levels of assurance are required by different tasks in terms of real-time performance. As the computational demands of real-time tasks increase, tasks may require internal parallelism in order to complete within stringent deadlines. In this paper, we consider the problem of mixed-criticality scheduling of parallel real-time tasks and propose a novel mixed-criticality federated scheduling (MCFS) algorithm for parallel tasks modeled by a directed acyclic graph. MCFS is based on federated intuition for scheduling parallel real-time tasks. It strategically assigns cores and virtual deadlines to tasks to achieve good schedulability. For high-utilization tasks (utilization $$\ge $$ 1), we prove that MCFS provides a capacity augmentation bound of $$2+\sqrt{2}$$ and $$(5+\sqrt{5})/2$$ for dual- and multi-criticality, respectively. We show that MCFS has a capacity augmentation bound of $$11m/(3m-3)$$ for dual-criticality systems with both high- and low-utilization tasks. For high-utilization tasks, we further provide a MCFS-Improve algorithm that has the same bound but can admit many more task sets in practice. Results of numerical experiments show that MCFS-Improve significantly improves over MCFS for many different workload settings. We also present an implementation of a MCFS runtime system in Linux that supports parallel programs written in OpenMP. Our implementation provides graceful degradation and recovery features. We conduct empirical experiments to demonstrate the practicality of our MCFS approach.

Simulation-based evaluations of DAG scheduling in hard real-time multiprocessor systems

The scheduling of parallel real-time tasks on multiprocessor systems is more complicated than the one of independent sequential tasks, specially for the Directed Acyclic Graph (DAG) model. The complexity is due to the structure of DAG tasks and the precedence constraints between their subtasks. The trivial DAG scheduling approach is to directly apply common real-time scheduling algorithms on DAGs despite their lack of compatibility with the parallel model. Another scheduling approach, which is called the stretching method, aims at transforming each parallel DAG task in the set into a collection of independent sequential threads that are easier to be scheduled. In this paper, we are interested in analyzing global preemptive scheduling of DAGs using both approaches by showing that they are not comparable when associated with Deadline Monotonic (DM) and Earliest Deadline First (EDF) scheduling algorithms. Then we use extensive simulations to evaluate their schedulability performance. To this end, we use our simulation tool YARTISS to generate random DAG tasks with many parameter variations so as to guarantee reliable experimental results.

Global EDF scheduling for parallel real-time tasks

As multicore processors become ever more prevalent, it is important for real-time programs to take advantage of intra-task parallelism in order to support computation-intensive applications with tight deadlines. In this paper, we consider the global earliest deadline first (GEDF) scheduling policy for task sets consisting of parallel tasks. Each task can be represented by a directed acyclic graph (DAG) where nodes represent computational work and edges represent dependences between nodes. In this model, we prove that GEDF provides a capacity augmentation bound of $$4-\frac{2}{m}$$ and a resource augmentation bound of $$2-\frac{1}{m}$$ . The capacity augmentation bound acts as a linear-time schedulability test since it guarantees that any task set with total utilization of at most $$m/(4-\frac{2}{m})$$ where each task’s critical-path length is at most $$1/(4-\frac{2}{m})$$ of its deadline is schedulable on $$m$$ cores under GEDF. In addition, we present a pseudo-polynomial time fixed-point schedulability test for GEDF; this test uses a carry-in work calculation based on the proof for the capacity bound. Finally, we present and evaluate a prototype platform—called PGEDF—for scheduling parallel tasks using global earliest deadline first (GEDF). PGEDF is built by combining the GNU OpenMP runtime system and the $$\text {LITMUS}^\text {RT}$$ operating system. This platform allows programmers to write parallel OpenMP tasks and specify real-time parameters such as deadlines for tasks. We perform two kinds of experiments to evaluate the performance of GEDF for parallel tasks. (1) We run numerical simulations for DAG tasks. (2) We execute randomly generated tasks using PGEDF. Both sets of experiments indicate that GEDF performs surprisingly well and outperforms an existing scheduling techniques that involves task decomposition.

Partitioned scheduling of parallel real-time tasks on multiprocessor systems

In this paper, we focus on the scheduling of periodic fork-join real-time tasks on multiprocessor systems. Parallel real-time tasks in the fork-join model have strict parallel segments without laxity. We propose a partitioned scheduling algorithm which increases the laxity of the parallel segments and therefore the schedulability of tasksets of this model. A similar algorithm has been proposed in the literature but it produces job migrations. Our algorithm eliminates the use of job migrations in order to create a portable algorithm that can be implemented on a standard Linux kernel. Results of extensive simulations are provided in order to analyze the schedulability of the proposed algorithm, and to provide comparisons with the other algorithm proposed in the literature.