Preemptive scheduling with rejection

We consider the problem of preemptively scheduling a set of n jobs on m (identical, uniformly related, or unrelated) parallel machines. The scheduler may reject a subset of the jobs and thereby incur job-dependent penalties for each rejected job, and he must construct a schedule for the remaining jobs so as to optimize the preemptive makespan on the m machines plus the sum of the penalties of the jobs rejected

Throughput Maximization in Multiprocessor Speed-Scaling

We are given a set of $n$ jobs that have to be executed on a set of $m$ speed-scalable machines that can vary their speeds dynamically using the energy model introduced in [Yao et al., FOCS'95]. Every job $j$ is characterized by its release date $r_j$, its deadline $d_j$, its processing volume $p_{i,j}$ if $j$ is executed on machine $i$ and its weight $w_j$. We are also given a budget of energy $E$ and our objective is to maximize the weighted throughput, i.e. the total weight of jobs that are completed between their respective release dates and deadlines. We propose a polynomial-time approximation algorithm where the preemption of the jobs is allowed but not their migration. Our algorithm uses a primal-dual approach on a linearized version of a convex program with linear constraints. Furthermore, we present two optimal algorithms for the non-preemptive case where the number of machines is bounded by a fixed constant. More specifically, we consider: {\em (a)} the case of identical processing volumes, i.e. $p_{i,j}=p$ for every $i$ and $j$, for which we present a polynomial-time algorithm for the unweighted version, which becomes a pseudopolynomial-time algorithm for the weighted throughput version, and {\em (b)} the case of agreeable instances, i.e. for which $r_i \le r_j$ if and only if $d_i \le d_j$, for which we present a pseudopolynomial-time algorithm. Both algorithms are based on a discretization of the problem and the use of dynamic programming

Online Min-Sum Flow Scheduling with Rejections

International audienceIn this paper, we study the problems of preemptive and non-preemptive online scheduling of jobs on unrelated machines in order to minimize the average time a job remains in the system.Both problems are known to be non-approximable by a constant factor. However, the preemptive variant has been extensively studied under the different resource augmentation models. On the other hand, the non-preemptive variant is much less explored. An O( 1/epsilon )-competitive algorithm has been presented in [7] for the non-preemptive average flow-time minimization problem on a set of unrelated machines if bothan epsilon-speed augmentation is used and an epsilon-fraction of jobs is rejected. We are interested here in exploring the power of the rejection model and, mainly, in eliminating the need for speed augmentation in the latter result. On the road to this, we show how to replace speed augmentation with rejection in the preemptive variant. Our analysis is based on the dual-fitting paradigm

Quasi-Dynamic Frame Coordination For Ultra- Reliability and Low-Latency in 5G TDD Systems

The fifth generation (5G) mobile technology features the ultra-reliable and low-latency communications (URLLC) as a major service class. URLLC applications demand a tight radio latency with extreme link reliability. In 5G dynamic time division duplexing (TDD) systems, URLLC requirements become further challenging to achieve due to the severe and fast-varying cross link interference (CLI) and the switching time of the radio frame configurations (RFCs). In this work, we propose a quasi-dynamic inter-cell frame coordination algorithm using hybrid frame design and a cyclic-offset-based RFC code-book. The proposed solution adaptively updates the RFCs in time such that both the average CLI and the user-centric radio latency are minimized. Compared to state-of-the-art dynamic TDD studies, the proposed scheme shows a significant improvement in the URLLC outage latency, i.e., 92% reduction gain, while boosting the cell-edge capacity by 189% and with a greatly reduced coordination overhead space, limited to B-bit

Online Non-Preemptive Scheduling to Minimize Maximum Weighted Flow-Time on Related Machines

We consider the problem of scheduling jobs to minimize the maximum weighted flow-time on a set of related machines. When jobs can be preempted this problem is well-understood; for example, there exists a constant competitive algorithm using speed augmentation. When jobs must be scheduled non-preemptively, only hardness results are known. In this paper, we present the first online guarantees for the non-preemptive variant. We present the first constant competitive algorithm for minimizing the maximum weighted flow-time on related machines by relaxing the problem and assuming that the online algorithm can reject a small fraction of the total weight of jobs. This is essentially the best result possible given the strong lower bounds on the non-preemptive problem without rejection

From Preemptive to Non-preemptive Scheduling Using Rejections

International audienceWe study the classical problem of scheduling a set of independent jobs with release dates on a single machine. There exists a huge literature on the preemptive version of the problem, where the jobs can be interrupted at any moment. However, we focus here on the non-preemptive case, which is harder, but more relevant in practice. For instance, the jobs submitted to actual high performance platforms cannot be interrupted or migrated once they start their execution (due to prohibitive management overhead). We target on the minimization of the total stretch objective, defined as the ratio of the total time a job stays in the system (waiting time plus execution time), normalized by its processing time. Stretch captures the quality of service of a job and the minimum total stretch reflects the fairness between the jobs. So far, there have been only few studies about this problem, especially for the non-preemptive case. Our approach is based to the usage of the classical and efficient for the preemptive case shortest remaining processing time (SRPT) policy as a lower bound. We investigate the (offline) transformation of the SRPT schedule to a non-preemptive schedule subject to a recently introduced resource augmentation model, namely the rejection model according to which we are allowed to reject a small fraction of jobs. Specifically, we propose a 2 ǫ-approximation algorithm for the total stretch minimization problem if we allow to reject an ǫ-fraction of the jobs, for any ǫ > 0. This result shows that the rejection model is more powerful than the other resource augmentations models studied in the literature, like speed augmentation or machine augmentation, for which non-polynomial or non-scalable results are known. As a byproduct, we present a O(1)-approximation algorithm for the total flow-time minimization problem which also rejects at most an \epsilon-fraction of jobs