Real-Time scheduling and analysis of parallel tasks on heterogeneous multi-cores

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.

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.

Real-time scheduling and analysis of parallel tasks modeled as directed acyclic graphs (DAG) have been intensively studied in recent years. However, no existing work has explored the execution order of eligible vertices within a DAG task. In this paper, we show that this intra-task vertex execution order has a large impact on system schedulability and propose to control the execution order by vertex-level priority assignment. We develop analysis techniques to bound the worst-case response time for the proposed scheduling strategy and design heuristics for proper priority assignment to improve system schedulability as much as possible. We further extend the proposed approach to the general setting of multiple recurrent DAG tasks. Experiments with both realistic parallel benchmark applications and randomly generated workload show that our method consistently outperforms state-of-the-art methods with different task graph structures and parameter configurations.

Reducing energy consumption while providing performance and quality guarantees is crucial for computing systems ranging from battery-powered embedded systems to data centers. This article considers approximate iterative applications executing on heterogeneous multi-core platforms under user-specified performance and quality targets. We note that allowing a slight yet bounded relaxation in solution quality can considerably reduce the required iteration count and thereby can save significant amounts of energy. To this end, this article proposes Approx-RM , a resource management scheme that reduces energy expenditure while guaranteeing a specified performance as well as accuracy target. Approx-RM predicts the number of iterations required to meet the relaxed accuracy target at runtime. The time saved generates execution-time slack, which allows Approx-RM to allocate fewer resources on a heterogeneous multi-core platform in terms of DVFS, core type, and core count to save energy while meeting the performance target. Approx-RM contributes with lightweight methods for predicting the iteration count needed to meet the accuracy target and the resources needed to meet the performance target. Approx-RM uses the aforementioned predictions to allocate just enough resources to comply with quality of service constraints to save energy. Our evaluation shows energy savings of 31.6%, on average, compared to Race-to-idle when the accuracy is only relaxed by 1%. Approx-RM incurs timing and energy overheads of less than 0.1%.

Real-time scheduling and analysis of parallel tasks modeled as directed acyclic graphs (DAG) have been intensively studied in recent years. The degree of parallelism of DAG tasks is an important characterization in scheduling. This paper revisits the definition and the computing algorithms for the degree of parallelism of DAG tasks, and clarifies some misunderstandings regarding the degree of parallelism which exist in real-time literature. Based on the degree of the parallelism, we propose a real-time scheduling approach for DAG tasks, which is quite simple but rather effective and outperforms the state-of-the-art by a considerable margin.

A singular graph \(G\) has an adjacency matrix \(A(G)\) with nullity \(\eta(G)>0\). Vertices of singular graphs are classified as core and noncore vertices. There are two types of noncore vertices: noncore vertices of zero null spread and of null spread -1 . Deletion of these vertices from a singular graph either changes the nullity or leave it unaltered. In this paper larger singular and nonsingular graphs were constructed by joining singular graphs by a path. As singular graphs have different types of vertices, the graphs constructed in this way differ in nullity depending on the vertex we are joining during construction. An attempt was made to construct singular graph of maximum nullity. Various spectral properties of the resulting graphs were studied.

Most parallel real-time applications can be modeled as directed acyclic graph (DAG) tasks. Intra-task priority assignment can reduce the nondeterminism of runtime behavior of DAG tasks, possibly resulting in a smaller worst-case response time. However, intra-task priority assignment incurs dependencies between different parts of the graph, making it a challenging problem to compute the response time bound. Existing work on intra-task task priority assignment for DAG tasks is subject to the constraint that priority assignment must comply with the topological order of the graph, so that the response time bound can be computed in polynomial time. In this paper, we relax this constraint and propose a new method to compute response time bound of DAG tasks with arbitrary priority assignment. With the benefit of our new method, we present a simple but effective priority assignment policy, leading to smaller response time bounds. Comprehensive evaluation with both single-DAG systems and multi-DAG systems demonstrates that our method outperforms the state-of-the-art method with a considerable margin.

Real-time and embedded systems are shifting from single-core to multi-core processors, on which the software must be parallelized to fully utilize the computation capacity of the hardware. Recently, much work has been done on real-time scheduling of parallel tasks modeled as directed acyclic graphs (DAG). However, most of these studies assume tasks to have implicit or constrained deadlines. Much less work considered the general case of arbitrary deadlines (i.e., the relative deadline is allowed to be larger than the period), which is more difficult to analyze due to intra-task interference among jobs. In this article, we study the analysis of Global Earliest Deadline First (GEDF) scheduling for DAG parallel tasks with arbitrary deadlines. We develop new analysis techniques for GEDF scheduling of a single DAG task and this new analysis techniques can guarantee a better capacity augmentation bound 2.41 (the best known result is 2.5) in the case of a single task. Furthermore, the proposed analysis techniques are also extended to the case of multiple DAG tasks under GEDF and federated scheduling. Finally, through empirical evaluation, we justify the out-performance of our schedulability tests compared to the state-of-the-art in general.

Traditional real-time task scheduling strategies focus on solely on the CPU, and do not take in account memory access and cache effects. In this paper we propose real-time parallel scheduling (PRTTS) strategy on multicore platforms. Each task is represented as a directed acyclic graph (DAG). Tasks priorities are assigned according to task periods (rate monotonic, RM). In PRTTS scheduling strategy priorities of tasks which access memory are promoted over priorities of tasks not accessing memory. Tasks which read/write data in cache dynamically have their priority increased above all tasks. The results of simulation experiment show that proposed scheduling strategy offers better performance in terms of core utilization and schedulability rate of tasks.

The group-based preemptive scheduling provides a flexible mechanism to define the preemptive relations between tasks. However, this scheduling scheme together with a resource access synchronization protocol and requirements of fault tolerance makes the predication of a real-time system's behaviors more difficult than traditional scheduling scheme. The major contribution of our work is an algorithm to calculate the worst-case response time for tasks under the fault-tolerant group-based preemptive scheduling. We first present the algorithm assuming that no task suffers any error. Then the algorithm is extended to consider a fault model and a primary/alternative fault-tolerant mechanism. Based on the tasks' worst-case response time, the schedulability of a given task set can be determined. Moreover, we also introduce a method to calculate the minimum allowed time between two consecutive faults.

Failure-resilient DAG task scheduling in edge computing

Energy harvesting sensors move into the mainstream because they are regarded as a perfect match for the monitoring applications. Nonetheless, their implementation is only feasible if the computing unit, generally a microcontroller, is capable of running the real-time tasks using sophisticated scheduling and power management techniques. In this paper, we address the hard real-time scheduling problem of Directed Acyclic Graph (DAG) tasks in a uniprocessor RTEH (Real Time Energy Harvesting) computing system. In this model, a task is defined as a set of dependent sub-tasks that execute under precedence constraints with processing time and energy requirements. We demonstrate that the energy aware ED-H algorithm provides an optimal solution. We show that the scheduling policy directly includes a feasibility analysis by enforcing the precedence constraints, thus making it possible to get rid of semaphore synchronization.

As social media becomes more feature-rich and the capability for interactions between users becomes more complex as a result, it may become necessary to expand the models used in data analysis to represent more complex interactions and networks. To that effect, researchers have begun using graphs with different types of vertices or even hyperedges to represent more complex networks. In this chapter, we will explore some of the community detection approaches state-of-the-art research uses to deal with the increasing complexity of social networks, and particularly representing those networks as multi-mode networks (or heterogeneous networks). This chapter will cover the approaches used as well as the graph representations of complex networks. Though the work studied uses social networks as the basis for analysis, the use of multi-mode networks and hyperedges is principled in any analysis task where the complexity of the data calls for multiple types of entities with interactions involving two or more entities in the network.

Single-ISA heterogeneous multi-core processors are typically composed of small (e.g., in-order) power-efficient cores and big (e.g., out-of-order) high-performance cores. The effectiveness of heterogeneous multi-cores depends on how well a scheduler can map workloads onto the most appropriate core type. In general, small cores can achieve good performance if the workload inherently has high levels of ILP. On the other hand, big cores provide good performance if the workload exhibits high levels of MLP or requires the ILP to be extracted dynamically. This paper proposes Performance Impact Estimation (PIE) as a mechanism to predict which workload-to-core mapping is likely to provide the best performance. PIE collects CPI stack, MLP and ILP profile information, and estimates performance if the workload were to run on a different core type. Dynamic PIE adjusts the scheduling at runtime and thereby exploits fine-grained time-varying execution behavior. We show that PIE requires limited hardware support and can improve system performance by an average of 5.5% over recent state-of-the-art scheduling proposals and by 8.7% over a sampling-based scheduling policy.

Service migration is crucial in mobile edge computing (MEC) to ensure seamless service provision as users move. Although some migration schemes have been proposed, they fail to efficiently support the migration of microservices in a directed acyclic graph (DAG)-based service across different edge servers, resulting in high service latency. This paper focuses on the DAG-based service migration problem and proposes a collaborative microservice migration framework for MEC, aiming to minimize the service migration latency while efficiently distributing the migration workload across edge servers. We divide edge servers into clusters and formulate the DAG-based service migration problem as a two-stage optimization problem. In the first stage, a deep reinforcement learning-based service pre-migration algorithm is developed to identify the optimal cluster of edge servers for hosting the migrated service. In the second stage, a microservice migration algorithm is devised, utilizing topological sorting and network flow techniques to further determine the target edge server for each microservice. Our design addresses the inherent dependencies among microservices within a DAG task and adapts well to dynamic network environments. Experimental results on real-world datasets demonstrate that our approach significantly reduces service migration latency.