Number Of Preemptions Research Articles

Litmus-RT plugins for global static scheduling of mixed criticality systems

Global static scheduling for Mixed Criticality (MC) systems demonstrates excellent results in terms of acceptance ratio and number of preemptions. But, no practical implementation and empirical evaluation have been presented yet for multi-processors systems. Moreover, the new kernel mechanisms it would require have not been studied. In this paper, we present two contributions on the implementation of global static schedulers For MC systems: G-RES, a global table-driven reservations LITMUS RT plugin, and G-MCRES, another LITMUS RT plugin scheduling MC tasks with global table-driven reservations and enforcing safe criticality mode changes. These contributions aim to solve the problems of instantaneous migrations and simultaneous mode changes in the context of global static schedulers. We based our experiments on scheduling tables generated off-line by GMH-MC-DAG, a meta-heuristic to schedule multiprocessor systems composed of multi-periodic Directed Acyclic Graphs of Mixed Criticality tasks with multiple criticality levels. The performances are very good w.r.t those of LITMUS RT and consistent with our temporal complexity evaluations.

The Price of Bounded Preemption

In this article we provide a tight bound for the price of preemption for scheduling jobs on a single machine (or multiple machines). The input consists of a set of jobs to be scheduled and of an integer parameter k ≥ 1. Each job has a release time, deadline, length (also called processing time), and value associated with it. The goal is to feasibly schedule a subset of the jobs so that their total value is maximal; while preemption of a job is permitted, a job may be preempted no more than k times. The price of preemption is the worst possible (i.e., largest) ratio of the optimal non-bounded-preemptive scheduling to the optimal k -bounded-preemptive scheduling. Our results show that allowing at most k preemptions suffices to guarantee a Θ(min {log k +1 n , log k +1 P }) fraction of the total value achieved when the number of preemptions is unrestricted (where n is the number of the jobs and P the ratio of the maximal length to the minimal length), giving us an upper bound for the price; a specific scenario serves to prove the tightness of this bound. We further show that when no preemptions are permitted at all (i.e., k =0), the price is Θ (min { n , log P }). As part of the proof, we introduce the notion of the Bounded-Degree Ancestor-Free Sub-Forest (BAS) . We investigate the problem of computing the maximal-value BAS of a given forest and give a tight bound for the loss factor, which is Θ(log k +1 n ) as well, where n is the size of the original forest and k is the bound on the degree of the sub-forest.

Generalized Mixed-Criticality Static Scheduling for Periodic Directed Acyclic Graphs on Multi-Core Processors

In safety-critical systems many software components of different criticalities or assurance levels need to interact in a timely manner to keep the system and environment safe. Nowadays, these systems are challenged by technological progress resulting in rapid increases in both software complexity and processing demands. Efficiently designing safety-critical systems subject to stringent timing requirements is therefore a challenge and a necessity. In this article, we consider the mixed-criticality execution model and homogeneous multi-core processors. We begin by defining a task model incorporating mixed-criticality, real-time and precedence constraints in the form of directed acyclic graphs. A meta-heuristic to solve the scheduling problem of this task model is then defined and proved to respect deadlines, even when the system needs to give more processing power to the most critical tasks. The state-of-the-art techniques capable of scheduling a similar task model have only been developed for dual-criticality systems. Conversely, the meta-heuristic we propose has been generalized to support an arbitrary number of criticality levels. We instantiated our meta-heuristic adopting scheduling algorithms such as G-EDF, G-LLF, or G-EDZL for each level of criticality. The experiments show excellent results in terms of acceptance ratio and number of preemptions.

Parametric analysis of the quality of single preemption schedules on three uniform parallel machines

For a scheduling problem to minimize the makespan on three uniform parallel machines we present a parametric analysis of the quality of a schedule with at most one preemption compared to the global optimal schedule with any number of preemptions. A tight bound is derived as a function of the relative speeds of the machines, provided that two of the machines have the same speed.

Comparison of Scheduling Algorithms in The Design of Fault Tolerant Real Time Systems

Most of the real time systems have the timing constraints. The main important timing constraints of any real time systems are to meet the deadlines of its application tasks. Not only satisfying the timing constraints of any real-time system, but also the functional correctness of application needs to be guaranteed. Meeting the dead line of application is no use if it deviates from its precise output. Timing constraints of the system can be satisfied by choosing proper task scheduling algorithms and the reliability of the system can be reached by providing fault-tolerance. In this paper, various fault scheduling algorithms like fixed priority, EDF(Earliest dead line first), LLF (Least Laxity First),Rate monotonic etc have been studied and compare the parameters like Worst-case execution times, response time, task missed deadlines, Number of preemption, number of context switches, Deadlock and processor utilization factor.

QoS oriented dynamic flow preemption (DFP) in MANET

Mobile Ad Hoc Network requires various types of applications’ communication. One of the important is multimedia communication. Such flows demand stringent requirements for Quality of Service. Multimedia or real flows need to book resources such as bandwidth. But in some scenario bandwidth may be occupied by some other resources. In some situation high priority real flows has to wait for resource allocation on a shorter path or may be supplied with another longer path. To overcome such a situation we have provided hop to hop preemption on the basis of number of preemption required on a hop and also by calculating threshold priority difference. In this article, we have proposed Dynamic Flow Preemption (DFP) which will preempt the low priority flow (using some constraints), by another high priority flow. We have evaluated DFP with AdHoc QoS On Demand Routing AQOR. AQOR is considered as it maintains multiple paths like DFP. NS2 simulator is used to compare both the protocols. Result from different parameters and metrics suggest better performance using DFP over AQOR.

Real-time uniprocessor scheduling with fewer preemptions

In this paper, we propose a simple, but effective scheduling framework for EDF and RM, which reduces the number of preemptions by simply introducing a dummy task. We first observe useful preemption behavior under EDF and RM, leading to an interesting finding: an effective way to reduce the number of preemptions is to prevent jobs of a task with the smallest task period from preempting other jobs upon their release. To achieve this, we add a dummy task that invokes its job only when a newly-released job of the task with the smallest task period has a higher priority than the currently-executing job. Then, the currently-executing job can continue its execution without getting preempted by inheriting the priority of the dummy job. Since adding the dummy task can make a schedulable task set unschedulable, we propose how to set the dummy task’s parameters without compromising schedulability. In addition to the negligible overhead of this framework due to its simplicity, it holds an important property that does not increase the number of preemptions of any task set, compared to the original scheduling algorithm, which has not been achieved by existing studies. We also demonstrate via simulation that the proposed framework effectively reduces the number of preemptions under EDF and RM.

Non-permutation flow shop scheduling problem with preemption-dependent processing time

AbstractIn this paper, the non-permutation flow shop scheduling problem with preemption-dependent processing times is considered. A mixed integer programming formulation is proposed to tackle the problem. The optimization objective considered is the minimization of the total tardiness. The model is tested against random instances. The results allow us to identify the effect of some parameters such as coefficient of preemption-dependent processing time, number of preemptions and the selected machine for preemption on the total tardiness.

Makespan minimisation for a parallel machine scheduling problem with preemption and job incompatibility

In this paper, an extension of the graph colouring problem is introduced to model a parallel machine scheduling problem with job incompatibility. To get closer to real-world applications, where the number of machines is limited and jobs have different processing times, each vertex of the graph requires multiple colours and the number of vertices with the same colour is bounded. In addition, several objectives related to scheduling are considered: makespan, number of pre-emptions and summation over the jobs’ throughput times. Different solution methods are proposed, namely, two greedy heuristics, two tabu search methods and an adaptive memory algorithm. The latter uses multiple recombination operators, each one being designed for optimising a subset of objectives. The most appropriate operator is selected dynamically at each iteration, depending on its past performance. Experiments show that the proposed algorithm is effective and robust, while providing high-quality solutions on benchmark instances for the graph multi-colouring problem, a simplification of the considered problem.

A Technique to Calculate Cache Related Preemption Delay Using Constraints on Non-nested Preemptions

Abstract Caches incur an indirect cost to the response times of tasks due to preemptions in a task system. Hence the computation of Cache Related Preemption Delay (CRPD) is an important problem to assess the schedulability of a task system. In this paper, we have introduced the concept of inhibiting and non-nested preemptions. We have proposed a novel method to calculate tight upper and lower bounds on the number of preemptions of every task in the task-system across all phases . The problem of calculation of CRPD is modelled as a constraint satisfaction problem that can be solved by using Integer Linear Programming (ILP). The CRPD values are integrated in the worst case response time analysis.

A preemptive priority queue with preemptions penalty

Preemption is one of the important features in scheduling problems. When preemption is allowed, a customer can immediately receive the service on the arrival time whenever the server is idle or the preemption is justified. While a customer receives a service, one or more preemptions may occur. The primary objective of this paper is to minimize the average waiting time that all customers spend on the system. We consider some thresholds for the maximum allowed number of preemptions and their times to prevent from having a very long waited customer. A heuristic algorithm is presented for the problem, and the implementation of the proposed approach is demonstrated using some numerical examples. In addition, the performance of the proposed algorithm is compared with another existing algorithm.

Race-to-halt energy saving strategies

Energy consumption is one of the major issues for modern embedded systems. Early, power saving approaches mainly focused on dynamic power dissipation, while neglecting the static (leakage) energy consumption. However, technology improvements resulted in a case where static power dissipation increasingly dominates. Addressing this issue, hardware vendors have equipped modern processors with several sleep states. We propose a set of leakage-aware energy management approaches that reduce the energy consumption of embedded real-time systems while respecting the real-time constraints. Our algorithms are based on the race-to-halt strategy that tends to run the system at top speed with an aim to create long idle intervals, which are used to deploy a sleep state. The effectiveness of our algorithms is illustrated with an extensive set of simulations that show an improvement of up to 8% reduction in energy consumption over existing work at high utilization. The complexity of our algorithms is smaller when compared to state-of-the-art algorithms. We also eliminate assumptions made in the related work that restrict the practical application of the respective algorithms. Moreover, a novel study about the relation between the use of sleep intervals and the number of pre-emptions is also presented utilizing a large set of simulation results, where our algorithms reduce the experienced number of pre-emptions in all cases. Our results show that sleep states in general can save up to 30% of the overall number of pre-emptions when compared to the sleep-agnostic earliest-deadline-first algorithm.

An optimal boundary fair scheduling

Nowadays, many real-time operating systems discretize the time relying on a system time unit. To take this behavior into account, real-time scheduling algorithms must adopt a discrete-time model in which both timing requirements of tasks and their time allocations have to be integer multiples of the system time unit. That is, tasks cannot be executed for less than one time unit, which implies that they always have to achieve a minimum amount of work before they can be preempted. Assuming such a discrete-time model, the authors of Zhu et al. (Proceedings of the 24th IEEE international real-time systems symposium (RTSS 2003), 2003, J Parallel Distrib Comput 71(10):1411–1425, 2011) proposed an efficient “boundary fair” algorithm (named BF) and proved its optimality for the scheduling of periodic tasks while achieving full system utilization. However, BF cannot handle sporadic tasks due to their inherent irregular and unpredictable job release patterns. In this paper, we propose an optimal boundary-fair scheduling algorithm for sporadic tasks (named BF\(^2\)), which follows the same principle as BF by making scheduling decisions only at the job arrival times and (expected) task deadlines. This new algorithm was implemented in Linux and we show through experiments conducted upon a multicore machine that BF\(^2\) outperforms the state-of-the-art discrete-time optimal scheduler (PD\(^2\)), benefiting from much less scheduling overheads. Furthermore, it appears from these experimental results that BF\(^2\) is barely dependent on the length of the system time unit while PD\(^2\)—the only other existing solution for the scheduling of sporadic tasks in discrete-time systems—sees its number of preemptions, migrations and the time spent to take scheduling decisions increasing linearly when improving the time resolution of the system.

LLFRP: An Energy Efficient Variant of LLF with Reduced Pre-emptions for Real – Time Systems

AbstractEnergy efficiency without performance degradation is a challenge in battery operated real-time systems. One way to achieve this is by optimizing scheduling parameters like preemptions and cache activities. In this work, we present an energy efficient variant of Least Laxity First scheduler – Least Laxity First with Reduced Preemptions – that reduces the number of preemptions in a schedule. We prove that our scheduler offers the same feasibility as LLF. We present extensive analysis through experimental results to show that our variant significantly reduces the number of preemptions. Our results also show that the number of preemptions in the schedule output by this algorithm is close to the minimum possible number. Our analysis addresses the following metrics: preemptions, cache impacts, decision points, response time, response time jitter, latency, time complexity and energy consumption. In this work the proposed algorithm is compared with dynamic priority scheduling algorithms like RM, EDF, nonstrict LLF and strict-LLF. The result shows that the proposed algorithm offers 4.25% of energy saving in comparison with EDF, RM and non-strict LLF and it offers 7% energy saving in comparison with strict-LLF. The result also shows that the proposed algorithm increases the scheduling utilization by 4% in comparison with EDF, RM and non-strict LLF and it increases scheduling utilization by 6% in comparison with strict-LLF.

Parallel machine covering with limited number of preemptions

In this paper, we investigate the i-preemptive scheduling on parallel machines to maximize the minimum machine completion time, i.e., machine covering problem with limited number of preemptions. It is aimed to obtain the worst case ratio of the objective value of the optimal schedule with unlimited preemptions and that of the schedule allowed to be preempted at most i times. For the m identical machines case, we show the worst case ratio is {ie18-1}, and we present a polynomial time algorithm which can guarantee the ratio for any 0 ≤ i ≤ m − 1. For the i-preemptive scheduling on two uniform machines case, we only need to consider the cases of i = 0 and i = 1. For both cases, we present two linear time algorithms and obtain the worst case ratios with respect to s, i.e., the ratio of the speeds of two machines.

Enhancing the Simulation Speed of Sensor Network Applications by Asynchronization of Interrupt Service Routines

Sensor network simulations require high fidelity and timing accuracy to be used as an implementation and evaluation tool. The cycle-accurate and instruction-level simulator is the known solution for these purposes. However, this type of simulation incurs a high computation cost since it has to model not only the instruction level behavior but also the synchronization between multiple sensors for their causality. This paper presents a novel technique that exploits asynchronous simulations of interrupt service routines (ISR). We can avoid the synchronization overheads when the interrupt service routines are simulated without preemption. If the causality errors occur, we devise a rollback procedure to restore the original synchronized simulation. This concept can be extended to any instruction-level sensor network simulator. Evaluation results show our method can enhance the simulation speed up to 52% in the case of our experiments. For applications with longer interrupt service routines and smaller number of preemptions, the speedup becomes greater. In addition, our simulator is 2 to 11 times faster than the well-known sensor network simulator.

Two-level Hierarchical Scheduling Algorithm for Real-time Multiprocessor Systems

The Earliest Deadline First (EDF) scheduling algorithm has the least runtime complexity among joblevel fixed-priority algorithms for scheduling tasks on multiprocessor architectures. However, EDF suffers from suboptimality in multiprocessor systems. This paper proposes a new restricted migration-based scheduling algorithm for multiprocessor real-time systems, called Two-level Hierarchical Scheduling Algorithm (2L-HiSA), to address this sub-optimality. 2L-HiSA algorithm divides the problem of multiprocessor scheduling into a two-level hierarchy of schedulers. This algorithm works in two phases: i- A taskpartitioning phase in which, each task from application task set is assigned to a specific processor by following simple bin-packing approach. If a task can not be partitioned on any processor in the platform, it qualifies as migrating task. ii- A processor-grouping phase in which, processors are clustered together such that, per cluster, the unused fragmented computation power equivalent to at most one processor is available. We provide schedulability analysis and experimental evaluation to support our proposition. Moreover, our simulation results show an average difference of 18-folds in the number of preemptions and 10-folds in the number of task migrations under 2L-HiSA and PD2 algorithm.

Performance Evaluation of Preemption Algorithms in MPLS Networks

Preemption is a traffic engineering technique in Multiprotocol Switching Networks that enables creation of high priority paths when there is not enough free bandwidth left on the route. Challenging part of any preemption method is to select the best set of paths for removal. Several heuristic methods are available but no wider comparison had been published before. In this paper, we discuss the dilemmas in implementing preemption methods and present the simulation study of well known existing algorithms. Based on the results, we provide recommendations for deployment of preemption for the two most common evaluation criteria: number of preemptions and preempted bandwidth.

High-Priority First Transmission to Efficiently Support Service Differentiation in Just-in-Time OBS Networks

The provision of service differentiation is an important aspect that has to be considered for the definition of next-generation networks due to the high heterogeneity of the traffic that will dominate networks in the near future. This is particularly important in the context of optical burst switching, which is emerging as one of the strong candidate technologies for the next-generation optical Internet. Preemptive contention resolution schemes are very effective solutions for providing service differentiation in such networks; however, they cannot be applied together with the just-in-time signaling protocol because of the great loss in efficiency in terms of wavelength utilization and maximum achieved throughput that results when the number of preemptions becomes too large. This paper presents a preemption-based service differentiation solution that is suitable for the just-in-time optical burst switching paradigm because it keeps the preemption probability (i.e., the probability of observing a preemption when a contention occurs) low. Within the proposed technique, bursts are created at their ingress node and combined into chains, arranging them in order of decreasing priority. Then, a conventional preemption scheme is adopted at core nodes to handle contentions. An analytical study is presented and some traffic scenarios are analyzed by simulation to evaluate the performance of the proposed method.

The maximum gain of increasing the number of preemptions in multiprocessor scheduling

We consider the optimal makespan C(P, m, i) of an arbitrary set P of independent jobs scheduled with i preemptions on a multiprocessor with m identical processors. We compare the ratio for such makespans for i and j preemptions, respectively, where i < j. This ratio depends on P, but we are interested in the P that maximizes this ratio, i.e. we calculate a formula for the worst case ratio G(m, i, j) defined as $${G(m,i,j)=\max \frac{C(P,m,i)}{C(P,m,j)},}$$where the maximum is taken over all sets P of independent jobs.