An Integrated Scheduling Algorithm for Precedence Constrained Hard and Soft Real-Time Tasks on Heterogeneous Multiprocessors

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.

Increasingly, real-time systems are being used in applications that contain tasks that have deadlines and require predictable performance. Many complex real-time applications require modern operating systems capable of scheduling multiple classes of tasks in an integrated way. These applications require scheduling that result in high utilization of available processing power to accommodate as many tasks as possible while satisfying the required deadlines of each task. In this paper, we propose a combined heuristic approach to schedule a set of independent soft and hard real-time tasks in multiprocessor computing systems. Each of these tasks is characterized by its arrival time, deadline and required processing power. The proposed approach distributes the total available processing power of any processor, if it is needed and possible, among more than one task, while ensuring that hard real-time tasks are given higher priority and enough processing power to meet deadlines. This strategy can be used as a tool to efficiently guide scheduling processes. In addition, it can help to optimize processor utilization and maintain higher success ratios by maximizing the schedulability of soft tasks without jeopardizing the schedulability of hard tasks.

A digital broadcasting satellite (DBS) receiver converts digital A/V streams received from a satellite to analog NTSC A/V signals in real-time. Multi-tasking is an efficient way to improve the utilization of the processor core in real-time applications. In this paper, we propose a hybrid approach with a balanced trade-off between hardware kernel and multi-tasking programming to increase a system throughput. First, the schedulability of the critical hard real-time tasks in the DBS receiver is verified by using a simple feasibility test. Then, several soft real-time tasks are thoughtfully programmed to satisfy functional requirements of the system.

We consider the problem of scheduling tasks on multiprocessor architectures in the presence of communication delays. Given a set of dependent tasks, the scheduling problem is to allocate the tasks to processors such that the pre-specified precedence constraints among the tasks are obeyed and certain cost-measures (such as the computation time) are minimized. Several cases of the scheduling problem have

For better utilization of computing resources, it is important to consider parallel programming environments in which the number of available processors varies at runtime. In this paper, we discuss runtime support for data parallel programming in such an adaptive environment. Executing data parallel-programs in an adaptive environment requires redistributing data when the number of processors changes, and also requires determining new loop bounds and communication patterns for the new set of processors. We have developed a runtime library to provide this support. We also present performance results for a multiblock Navier-Stokes solver run on a network of workstations using PVM for message passing. Our experiments show that if the number of processors is not varied frequently, the cost of data redistribution is not significant compared to the time required for the actual computations. >

The UAV (unmanned aerial vehicle) performs various kinds of missions while performing autonomous flight navigation. In order to realize all functionalities of the UAV, the software part becomes a very complex hard real-time system because some hard real-time tasks, soft real-time tasks and non-real-time tasks are concurrently working together under a RTOS. In this paper, a hierarchical architecture for unmanned autonomous helicopter system is proposed that guarantees the real-time performance of hard real-time tasks and the re-configurability of soft realtime or non-real-time tasks under the RT-Linux. This software architecture has four layers: hardware, execution, service agent and remote user interface layer according to the reactiveness level for external events. In addition, the layered separation of concurrent tasks makes different kinds of mission reconfiguration possible in the system. An unmanned autonomous helicopter system was implemented using Kyosho RC Helicopter to test and evaluate the performance of the proposed systems.

A multiprocessor scheduling scheme is presented for supporting hierarchical containers that encapsulate sporadic soft and hard real-time tasks. In this scheme, each container is allocated a specified bandwidth, which it uses to schedule its children (some of which may also be containers). This scheme is novel in that, with only soft real-time tasks, no utilization loss is incurred when provisioning containers, even in arbitrarily deep hierarchies. Presented experiments show that the proposed scheme performs well compared to conventional real-time scheduling techniques that do not provide container isolation.

This paper presents a static scheduler which selects, from a set of scheduling algorithms, a subset of those which carry out the best assignment of a DAG representing an application program. To make that selection, some characteristics of the DAG, a decision model, and the evaluation parameters for choosing the best solution provided by the selected scheduling algorithms are defined. The selection of the scheduling algorithms is based on five decision levels. At each level, a subset of scheduling algorithms is selected. The final decision is made by carrying out an intersection operation between the subsets. When the scheduler was tested with a series of DAGs having different characteristics, the scheduler's decision was right 95% of the time in those cases in which the number of available processors is known, and 75% of the time when the number of processors is unbounded.

We present an O((log log N)/sup 2/) -time algorithm for computing the distance transform of an N /spl times/ N binary image. Our algorithm is designed for the common concurrent read concurrent write parallel random access machine (CRCW PRAM) and requires O(N/sup 2+/spl epsi///log log N) processors, for any /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithm is based on a novel deterministic sampling scheme and can be used for computing distance transforms for a very general class of distance functions. We also present a scalable version of our algorithm when the number of processors is available p/sup 2+/spl epsi///log log p for some p < N. In this case, our algorithm runs in O((N/sup 2//p/sup 2/)+(N/p) log log p + (log log p)/sup 2/) time. This scalable algorithm is more practical since usually the number of available processors is much less than the size of the image.

Slack clustering for scheduling frame-based tasks on multicore embedded systems

The scheduling of real-time tasks with primary-backup based fault-tolerant requirements has been an important problem for several years. Most of the known scheduling schemes are non-adaptive in nature meaning that they do not adapt to the dynamics of faults and task’s parameters in the system. In this paper,we propose an adaptive faulttolerant scheduling scheme that has a mechanism to control the overlap interval between the primary and backup versions of tasks such that the overall performance of the system is improved. The overlap interval is determined based on the estimated primary fault probability and task’s soft laxity. We also propose a new performance index that integrates schedulability (S) and reliability (R) into a single metric, called SR index. To evaluate the proposed scheme, we have conducted analytical and simulation studies under different fault and deadline scenarios, and found that the proposed adaptive scheme adapts to system dynamics and offers better SR index than that of the non-adaptive schemes.KeywordsSchedule SchemeProcessor UtilizationFault RateFault ProbabilityExecution IntervalThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In this paper we study the schedulability conditions of multiple types of real-time tasks (periodic real-time tasks, sporadic real-time tasks and aperiodic soft real-time tasks) in a heterogeneous multiprocessing environment. With the practical application of complicated environment, we propose a mixed scheduling algorithm in this paper, which itegrates UEDF algorithm with Task-Centric with Slack Defragmentation algorithm in the heterogeneous multiprocessor. Due to its characteristics that making the most of the processor which is already in use at first in the process of scheduling in order to reserve more free resources for future tasks, this algorithm can effectively improve the success rate of the entire hybrid task set scheduling. The results in simulation experiments show that the performance of the proposed algorithm scheduling on both the monotonic performance ordering and the non-monotonic performance ordering resource have obvious advantages over that of the current other combination algorithms.

In this paper we study the scheduling of parallel and real-time recurrent tasks on multiprocessor platforms. Firstly, we propose a new parallel task model which allows recurrent tasks to be composed of several phases, each one composed of several threads. Each thread requires a single processor for execution and can be scheduled simultaneously. We then propose an algorithm to transpose popular Fork-Join task model to our MPMT task model. Secondly, we define several kinds of real-time schedulers that can be applied to our parallel task model. We distinguish between two scheduling classes: Hierarchical schedulers and Global Thread schedulers. We present and prove correct an exact schedulability test for each class. Lastly, we also evaluate the performance of our scheduling paradigm in comparison with Gang scheduling by means of simulations. In this work we extend the work of Lupu and Goossens in Scheduling of hard real-time multi-thread periodic tasks (Real-Time and Network Systems, 2011) which considers mono-phase multi-thread task model. We extend their previous results to a Multi-Phase Multi-Thread task model.

Partitioned multiprocessor scheduling has been widely accepted in academia and industry to statically assign and partition real-time tasks onto identical multiprocessor systems. This paper studies fixed-priority partitioned multiprocessor scheduling for sporadic real-time systems, in which deadline-monotonic scheduling is applied on each processor. Prior to this paper, the best known results are by Fisher, Baruah, and Baker with speedup factors 4-2/M and 3-1/M for arbitrary-deadline and constrained-deadline sporadic real-time task systems, respectively, where M is the number of processors. We show that a greedy mapping strategy has a speedup factor 3-1/M when considering task systems with arbitrary deadlines. Such a factor holds for polynomial-time schedulability tests and exponential-time (exact) schedulability tests. Moreover, we also improve the speedup factor to 2.84306 when considering constrained-deadline task systems. We also provide tight examples when the fitting strategy in the mapping stage is arbitrary and M is sufficiently large. For both constrained-and arbitrary-deadline task systems, the analytical result surprisingly shows that using exact tests does not gain theoretical benefits (with respect to speedup factors) if the speedup factor analysis is oblivious of the particular fitting strategy used.

We consider the problem of on-line scheduling of a set of hard real-time tasks in an environment where future task parameters are not known a-priori. First, we derive necessary and sufficient conditions to determine whether a given set of tasks with known parameters is feasible using a set of m processors. Next, we consider two sets of tasks T/sub 0/ and T/sub t/ where T/sub 0/ is the set of tasks that need to be scheduled at time 0 such that any future task set T/sub t/, t>0 can be scheduled with or without disturbing the schedule for T/sub 0/. In this context, we derive necessary and sufficient conditions applicable to the schedule obtained for T/sub 0/ at time 0 such that, any future task set T/sub t/ can be scheduled provided the task set T/sub 0//spl cup/T/sub t/ is feasible using m processors.