We investigate online scheduling with commitment for parallel identical machines. Our objective is to maximize the total processing time of accepted jobs. As soon as a job has been submitted, the commitment constraint forces us to decide immediately whether we accept or reject the job. Upon acceptance of a job, we must complete it before its deadline @math that satisfies @math , with @math and @math being the processing time and the submission time of the job, respectively while @math is the slack of the system. Since the hard case typically arises for near-tight deadlines, we consider @math . We use competitive analysis to evaluate our algorithms. Our first main contribution is a deterministic preemptive online algorithm with an almost tight competitive ratio on any number of machines. For a single machine, the competitive factor matches the optimal bound @math of the greedy acceptance policy. Then the competitive ratio improves with an increasing number of machines and approaches @math as the number of machines converges to infinity. This is an exponential improvement over the greedy acceptance policy for small @math . In the non-preemptive case, we present a deterministic algorithm on @math machines with a competitive ratio of @math . This matches the optimal bound of @math of the greedy acceptance policy for a single machine while it again guarantees an exponential improvement over the greedy acceptance policy for small @math and large @math . In addition, we determine an almost tight lower bound that approaches @math for large @math and small @math .
@cite_9: 
@cite_21: We consider an on-line non-preemptive deadline scheduling on multiple resources. Each job has the slack time during which it can wait until its expiration time, the last time it can be started to be completed by the deadline. There are a number of resources on which the jobs are allocated. The effect of slack times on the on-line deadline scheduling was investigated in [8] by analyzing the performance of the Earliest EXpiration Time First (EXF) algorithm. But most of the previous work is restricted to a single resource, and in this paper, we propose a different method of analysis which can also be applied to multiple resources. So we can extend the result of [8] to multiple resources.
@cite_13: In this paper, we derive bounds on performance guarantees of online algorithms for real-time preemptive scheduling of jobs with deadlines on K machines when jobs are characterized in terms of their minimum stretch factor α (or, equivalently, their maximum execution rate r =1 α). We consider two well known preemptive models that are of interest from practical applications: the hard real-time scheduling model in which a job must be completed if it was admitted for execution by the online scheduler, and the firm real-time scheduling model in which the scheduler is allowed not to complete a job even if it was admitted for execution by the online scheduler. In both models, the objective is to maximize the sum of execution times of the jobs that were executed to completion, preemption is allowed, and the online scheduler must immediately decide, whenever a job arrives, whether to admit it for execution or reject it. We measure the competitive ratio of any online algorithm as the ratio of the value of the objective function obtained by this algorithm to that of the best possible offline algorithm. We show that no online algorithm can have a competitive ratio greater than 1 − (1 α )+ e for hard real-time scheduling with K ≥ 1 machines and greater than 1 − (3 (4� α� )) + e for firm real-time scheduling on a single machine, where e> 0 may be arbitrarily small, even if the algorithm is allowed to know the value of α in advance. On the other hand, we exhibit a simple online scheduler that achieves a competitive ratio of at least 1 − (1 α) in either of these models with K machines. The performance guarantee of our simple scheduler shows that it is in fact an optimal scheduler for hard real-time scheduling with K machines. We also describe an alternative scheduler for firm real-time scheduling on a single machine in which the competitive ratio does not go to zero as α approaches 1. Both of our schedulers do not know the value of α in advance.
@cite_20: We study the competitiveness of online deadline scheduling problems. It is assumed that jobs are non-preemptive and we want to maximize, in an online manner, the sum of the length of jobs completed before their deadlines. When there is a single machine, Goldwasser [4] showed that the optimal deterministic competitiveness of this problem is 2+1 k, where each job of length L can be delayed for at least k • L before it is started, while still meeting its deadline. We consider the case that k < 1 and present an O((log 1 k ))-competitive randomized algorithm not only for a single machine but also for m machines where m = 1,2,•••, O(( log 1 k )).Of particular interest is our technique: we mainly consider deterministic algorithms for multiple machines in order to improve the randomized competitiveness for a single (or more) machine. Though this approach is not completely new, it is rather complicated in our case to design a deterministic algorithm for multiple machines. Specifically, we present an [m+1+ m • (1 k)(1 m)]-competitive deterministic algorithm, where m (≥ 2) machines are available to both online algorithms and the adversary.Finally we also study a related problem and present an improved algorithm.
@cite_17: We consider the online competitiveness for scheduling a single resource non-preemptively in order to maximize its utilization. Our work examines this model when parameterizing an instance by a new value which we term the patience. This parameter measures each job's willingness to endure a delay before starting, relative to this same job's processing time. Specifically, the slack of a job is defined as the gap between its release time and the last possible time at which it may be started while still meeting its deadline. We say that a problem instance has patience κ, if each job with length ||J|| has a slack of at least κ ċ ||J||.Without any restrictions placed on the job characteristics, previous lower bounds show that no algorithm, deterministic or randomized, can guarantee a constant bound on the competitiveness of a resulting schedule. Previous researchers have analyzed a problem instance by parameterizing based on the ratio between the longest job's processing time and the shortest job's processing time. Our main contribution is to provide a fine-grained analysis of the problem when simultaneously parameterized by patience and the range of job lengths. We are able to give tight or almost tight bounds on the deterministic competitiveness for all parameter combinations.If viewing the analysis of each parameter individually, our evidence suggests that parameterizing solely on patience provides a richer analysis than parameterizing solely on the ratio of the job lengths. For example, in the special case where all jobs have the same length, we generalize a previous bound of 2 for the deterministic competitiveness with arbitrary slacks, showing that the competitiveness for any κ ≥ 0 is exactly 1 + 1 (⌊κ⌋ + 1). Without any bound on the job lengths, a simple greedy algorithm is (2+ 1 κ)- competitive for any κ > 0. More generally we will find that for any fixed ratio of job lengths, the competitiveness of the problem tends towards 1 as the patience is increased. The converse is not true, as for any fixed κ > 0 we find that the competitiveness is bounded away from 1, no matter what further restrictions are placed on the ratio of job lengths.
For parallel identical machines, DasGupta and Palis @cite_13 consider preemption without migration and suggest a simple greedy algorithm. They claim the same competitive factor as for the single machine problem with preemption. They also give a lower bound of @math . For the non-preemptive case, Kim and Chwa @cite_21 apply Goldwasser's algorithm @cite_9 @cite_17 to parallel identical machines. Lee @cite_20 considers a model without commitment and presents a non-preemptive algorithm that adds many newly submitted jobs to a queue and decides later whether to schedule or to reject them. He claims a competitive ratio of @math for small slack values. This competitive ratio is slightly worse than our competitive ratio for the same problem with commitment.