SORTING APPROACHES IN THE HEURISTIC BASED ON REMAINING AVAILABLE AND PROCESSING PERIODS TO MINIMIZE TOTAL WEIGHTED TARDINESS IN PROGRESSIVE IDLING-FREE 1-MACHINE PREEMPTIVE SCHEDULING

Background. In preemptive job scheduling, total weighted tardiness minimization is commonly reduced to solving a combinatorial problem, which becomes practically intractable as the number of jobs and the numbers of their processing periods increase. To cope with this challenge, heuristics are used. A heuristic, in which the decisive ratio is the weighted reciprocal of the maximum of a pair of the remaining processing period and remaining available period, is closely the best one. However, the heuristic may produce schedules of a few jobs whose total weighted tardiness is enormously huge compared to the real minimum. Therefore, this heuristic needs further improvements, one of which already exists for jobs without priority weights with a sorting approach where remaining processing periods are minimized. Three other sorting approaches still can outperform it, but such exceptions are quite rare. Objective. The goal is to determine the influence of the four sorting approaches and try to select the best one in the case where jobs have their priority weights. The heuristic will be applied to tight-tardy progressive idling-free 1-machine preemptive scheduling, where the release dates are given in ascending order starting from 1 to the number of jobs, and the due dates are tightly set after the release dates. Methods. To achieve the said goal, a computational study is carried out with applying each of the four heuristic approaches to minimize total weighted tardiness. For this, two series of 4151500 scheduling problems are generated. In the solution of a scheduling problem, a sorting approach can “win” solely or “win” in a group of approaches, producing the heuristically minimal total weighted tardiness. In each series, the distributions of sole-and-group “wins” are ascertained. Results. The sole “wins” and non-whole-group “wins” are rare: the four sorting approaches produce schedules with the same total weighted tardiness in over 98.39 % of scheduling problems. Although the influence of these approaches is different, it is therefore not really significant. Each of the sorting approaches has heavy disadvantages leading sometimes to gigantic inaccuracies, although they occur rarely. When the inaccuracy occurs to be more than 30 %, this implies that 3 to 9 jobs are scheduled. Conclusions. Unlike the case when jobs do not have their priority weights, it is impossible to select the best sorting approach for the case with job priority weights. Instead, a hyper-heuristic comprising the sorting approaches (i. e., the whole group, where each sorting is applied) may be constructed. If a parallelization can be used to process two or even four sorting routines simultaneously, the computation time will not be significantly affected.

Online Non-preemptive Scheduling on Unrelated Machines with Rejections

When a computer system schedules jobs there is typically a significant cost associated with preempting a job during execution. This cost can be incurred from the expensive task of saving the memory’s state or from loading data into and out of memory. Thus, it is desirable to schedule jobs non-preemptively to avoid the costs of preemption. There is a need for non-preemptive system schedulers for desktops, servers, and data centers. Despite this need, there is a gap between theory and practice. Indeed, few non-preemptive online schedulers are known to have strong theoretical guarantees. This gap is likely due to strong lower bounds on any online algorithm for popular objectives. Indeed, typical worst-case analysis approaches, and even resource-augmented approaches such as speed augmentation, result in all algorithms having poor performance guarantees. This article considers online non-preemptive scheduling problems in the worst-case rejection model where the algorithm is allowed to reject a small fraction of jobs. By rejecting only a few jobs, this article shows that the strong lower bounds can be circumvented. This approach can be used to discover algorithmic scheduling policies with desirable worst-case guarantees. Specifically, the article presents algorithms for the following three objectives: minimizing the total flow-time, minimizing the total weighted flow-time plus energy where energy is a convex function, and minimizing the total energy under the deadline constraints. The algorithms for the first two problems have a small constant competitive ratio while rejecting only a constant fraction of jobs. For the last problem, we present a constant competitive ratio without rejection. Beyond specific results, the article asserts that alternative models beyond speed augmentation should be explored to aid in the discovery of good schedulers in the face of the requirement of being online and non-preemptive.

A SORTING IMPROVEMENT IN THE HEURISTIC BASED ON REMAINING AVAILABLE AND PROCESSING PERIODS TO MINIMIZE TOTAL TARDINESS IN PROGRESSIVE IDLING-FREE 1-MACHINE PREEMPTIVE SCHEDULING

Background. In preemptive job scheduling, which is a part of the flow-shop sequencing tasks, one of the most crucial goals is to obtain a schedule whose total tardiness would be minimal. Total tardiness minimization is commonly reduced to solving a combinatorial problem which becomes practically intractable as the number of jobs and the numbers of their processing periods increase. To cope with this challenge, heuristics are used. A heuristic, in which the decisive ratio is the reciprocal of the maximum of a pair of the remaining processing period and remaining available period, is closely the best one. However, the heuristic may produce schedules of a few jobs whose total tardiness is 25 % greater than the minimum or even worse. Therefore, this heuristic needs a corrective branch which would further try to minimize total tardiness under certain conditions. Objective. The goal is to ascertain what is to be corrected in the heuristic so that the total tardiness value could be obtained lesser. The heuristic will be applied to tight-tardy progressive idling-free 1-machine preemptive scheduling, where the release dates are given in ascending order starting from 1 to the number of jobs, and the due dates are tightly set after the release dates. In this scheduling problem, the inaccuracy of finding the minimal total tardiness has the strongest negative impact, so this is almost the worst case, which defines the accuracy limit of the heuristic and positively serves just as the principle of minimax guaranteeing decreasing losses in the worst conditions. Methods. The heuristic sorts maximal decisive ratios by release dates, where the scheduling preference is given to the earliest job. To achieve the said goal, three other sorting approaches are presented and a computational study is carried out with applying each of the four heuristic approaches to minimize total tardiness. For this, two series of 266000 and 1064000 scheduling problems are generated. Results. The earliest-job sorting ensures a heuristically minimal total tardiness value in more than 97.6 % of scheduling problems, but it fails to minimize total tardiness in no less than 2.2 % of the cases. Nevertheless, a sorting approach with minimizing remaining processing periods produces a heuristically minimal total tardiness for almost any scheduling problem. If an exception occurs, this sorting approach “loses” to the other sorting approaches very little. Moreover, the exceptions are quite rare as it has been registered just a one scheduling problem (out of 31914 cases followed by a sole “win” of a heuristic version) whose minimal total tardiness is achieved by the earliest-job sorting. Conclusions. The best heuristic version is that one which uses the sorting approach with minimizing remaining processing periods. This, however, is confirmed only for the case where jobs do not have any priorities. The case when jobs have their priority weights is to be yet analyzed.

TIGHT-TARDY PROGRESSIVE IDLING-FREE 1-MACHINE PREEMPTIVE SCHEDULING WITH JOB PRIORITY WEIGHTS BY HEURISTIC’S EFFICIENT JOB ORDER INPUT

Background. In setting a problem of minimizing total weighted tardiness by the heuristic based on remaining available and processing periods, there are two opposite ways to input the data: the job release dates are given in either ascending or descending order. It was recently ascertained that scheduling a few equal-length jobs is expectedly faster by ascending order, whereas scheduling 30 to 70 equal-length jobs is 1.5 % to 2.5 % faster by descending order. For the number of equal-length jobs between roughly 90 and 250, the ascending job order again results in shorter computation times. In the case when the jobs have different lengths, the significance of the job order input is much lower. On average, the descending job order input gives a tiny advantage in computation time. This advantage decreases as the number of jobs increases. Objective. The goal is to ascertain whether the job order input is significant in scheduling by using the heuristic for the case when the jobs have different lengths with job priority weights. Job order efficiency will be studied on tight-tardy progressive idling-free 1-machine preemptive scheduling. Methods. To achieve the said goal, a computational study is carried out with a purpose to estimate the averaged computation time for both ascending and descending orders of job release dates. First, the computation time for the ascending job order input is estimated for a series of job scheduling problems. Then, in each instance of this series, job lengths, priority weights, release dates, and due dates are reversed making thus the respective instance for the descending job order input, for which computation time is estimated as well. Results. The significance of the job order input is much lower than that for the case of jobs without priorities. With assigning the job priority weights, the job order input becomes further “dithered”, adding randomly scattered priority weights to randomly scattered job lengths and partially randomized due dates. On average, the descending job order input is believed to give a tiny advantage in computation time in scheduling up to 100 jobs. However, this advantage, if any (being tinier than that in the case of random job lengths without priorities), quickly vanishes as the number of jobs increases. Conclusions. It is better to compose job scheduling problems which would be closer to the case with equal-length jobs without priorities, where the saved computational time can be counted in hours. Even if the job lengths and priority weights are scattered, it is recommended to artificially “flatten” them. When artificial manipulations over job processing periods and job priority weights are impossible, it is recommended to use the descending job order input in scheduling up to 100 jobs, and either job order input in scheduling more than 100 jobs, although substantial benefits are not expected in this case.

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.