Optimal on-line algorithms for the uniform machine scheduling problem with ordinal data

We consider scheduling problems in which a job consists of components of different types to be processed on m machines. Each machine is capable of processing components of a single type. Different components of a job are independent and can be processed in parallel on different machines. A job is considered as completed only when all its components have been completed. We study both completion time and flowtime aspects of such problems. We show both lowerbounds and upperbounds for the completion time problem. We first show that even the unweighted completion time with single release date is MAX-SNP hard. We give an approximation algorithm based on linear programming which has an approximation ratio of 3 for weighted completion time with multiple release dates. We give online algorithms for the weighted completion time which are constant factor competitive. For the flowtime, we give only lowerbounds in both the offline and online settings. We show that it is NP-hard to approximate flowtime within Ω(log m) in the offline setting. We show that no online algorithm for the flowtime can have a competitive ratio better than Ω(√m).

We study a variant of classical scheduling, which is called scheduling with “end of sequence” information. It is known in advance that the last job has the longest processing time. Moreover, the last job is marked, and thus it is known for every new job whether it is the final job of the sequence. We explore this model on two uniformly related machines, that is, two machines with possibly different speeds. Two objectives are considered, maximizing the minimum completion time and minimizing the maximum completion time (makespan). Let s be the speed ratio between the two machines, we consider the competitive ratios which are possible to achieve for the two problems as functions of s. We present algorithms for different values of s and lower bounds on the competitive ratio. The proposed algorithms are best possible for a wide range of values of s. For the overall competitive ratio, we show tight bounds of ϕ + 1 ≈ 2.618 for the first problem, and upper and lower bounds of 1.5 and 1.46557 for the second problem.

The transactional approach to contention management guarantees atomicity by making sure that whenever two transactions have a conflict on a resource, only one of them proceeds. A major challenge in implementing this approach lies in guaranteeing progress, since transactions are often restarted.Inspired by the paradigm of non-clairvoyant job scheduling, we analyze the performance of a contention manager by comparison with an optimal, clairvoyant contention manager that knows the list of resource accesses that will be performed by each transaction, as well as its release time and duration. The realistic, non-clairvoyant contention manager is evaluated by the competitive ratio between the last completion time (makespan) it provides and the makespan provided by an optimal contention manager.Assuming that the amount of exclusive accesses to the resources is non-negligible, we present a simple proof that every work conserving contention manager guaranteeing the pending commit property achieves an O(s) competitive ratio, where s is the number of resources. This bound holds for the GREEDY contention manager studied by Guerraoui et al. [2] and is a significant improvement over the O(s2) bound they prove for the competitive ratio of GREEDY. We show that this bound is tight for any deterministic contention manager, and under certain assumptions about the transactions, also for randomized contention managers.When transactions may fail, we show that a simple adaptation of GREEDY has a competitive ratio of at most O(ks), assuming that a transaction may fail at most k times. If a transaction can modify its resource requirements when re-invoked, then any deterministic algorithm has a competitive ratio Ω(ks). For the case of unit length jobs, we give (almost) matching lower and upper bounds.

For most scheduling problems the set of machines is fixed initially and remains unchanged for the duration of the problem. Recently Imreh and Nogaproposed to add the concept of machine cost to scheduling problems and considered the so-called List Model problem. An online algorithm with a competitive ratio 1.618 was given while the lower bound is 4/3. In this paper, two different semi-online versions of this problem are studied. In the first case, it is assumed that the processing time of the largest job is known a priori. A semi-online algorithm is presented with the competitive ratio at most 1.5309 while the lower bound is 4/3. In the second case, it is assumed that the total processing time of all jobs is known in advance. semi-online algorithm is presented with the competitive ratio at most 1.414 while the lower bound is 1.161. It is shown that the additional partial available information about the jobs leads to the possibility of constructing a schedule with a smaller competitive ratio than that of online algorithms.

New Algorithms for an Ancient Scheduling Problem

The transactional approach to contention management guarantees consistency by making sure that whenever two transactions have a conflict on a resource, only one of them proceeds. A major challenge in implementing this approach lies in guaranteeing progress, since transactions are often restarted. Inspired by the paradigm of non-clairvoyant job scheduling, we analyze the performance of a contention manager by comparison with an optimal, clairvoyant contention manager that knows the list of resource accesses that will be performed by each transaction, as well as its release time and duration. The realistic, non-clairvoyant contention manager is evaluated by the competitive ratio between the last completion time (makespan) it provides and the makespan provided by an optimal contention manager. Assuming that the amount of exclusive accesses to the resources is non-negligible, we present a simple proof that every work conserving contention manager guaranteeing the pending commit property achieves an O(s) competitive ratio, where s is the number of resources. This bound holds for the Greedy contention manager studied by Guerraoui et al. (Proceedings of the 24th Annual ACM Symposium on Principles of Distributed Computing (PODC), pp. 258–264, 2005) and is a significant improvement over the O(s 2) bound they prove for the competitive ratio of Greedy. We show that this bound is tight for any deterministic contention manager, and under certain assumptions about the transactions, also for randomized contention managers. When transactions may fail, we show that a simple adaptation of Greedy has a competitive ratio of at most O(ks), assuming that a transaction may fail at most k times. If a transaction can modify its resource requirements when re-invoked, then any deterministic algorithm has a competitive ratio Ω(ks). For the case of unit length jobs, we give (almost) matching lower and upper bounds.

In this paper we present algorithms for the problem of scheduling n independent jobs on m identical machines. As a generalization of the classical multiprocessor scheduling problem each machine is available only at a machine dependent release time. Two objective functions are considered. To minimize the makespan, we develop a dual approximation algorithm with a worst case bound of 5/4. For the problem of maximizing the minimum completion time, we develop an algorithm, such that the minimum completion time in the schedule produced by this algorithm is at least 2/3 times the minimum completion time in the optimum schedule. The paper closes with some numerical results.

Generating subproblems in branch and bound algorithms for parallel machines scheduling problem

Chapter 2 - Background

In any organization and business, efficient scheduling cause increased efficiency, reducing the time required to complete jobs and increasing an organization’s profitability in a competitive environment. Also, the flow-shop scheduling problem is a vital type of scheduling problem with many real-world applications. Flow-shop scheduling has numerous exciting applications in various manufacturing and industrial domains. During the past eras, the growing interests in the arrangement of flow shops with diverse objective functions (for example, minimizing the makespan and flow-time) were observed. The permutation flow-shop is formulated as mixed-integer programming, and it is an NP-Hard problem. Therefore, in this paper, a novel method is provided to decrease the makespan and completion time. Since parallel algorithms use some computing elements to accelerate the search and present a new exploration pattern that is frequently suitable to enhance the quality of the results, in this research, a parallel ant colony optimization algorithm is employed to solve the mentioned problem. The Matlab simulation setting in Net Beans IDE 8.0.2 and Java to simulate the introduced method is applied. According to the obtained results, the suggested procedure has more efficiency than the previous methods. The Matlab simulator outcomes have indicated that the average response time has been improved compared to the PSO-SA and HBC algorithms. Also, the makespan is improved in comparison to GA and MOACSA.

In this thesis, we study the theoretical approach on energy-efficient scheduling problems arising in demand response management in the modern electrical smart grid. Consumers send in power requests with flexible feasible timeslots during which their requests can be served. The grid controller, upon receiving power requests, schedules each request within the specified interval. The electricity cost is measured by a convex function of the load in each timeslot. The objective is to schedule all requests with the minimum total electricity cost. We study the smart grid scheduling problem in different models. For the offline model, we prove the problem is NP-hard for the general case. We propose a polynomial time algorithm for special input where jobs have unit power request and unit time duration. By adapting the polynomial time algorithm for unit-size jobs, we propose an approximation algorithm for more general input. On the other hand, we also present an exact algorithm to find the optimal schedule for the problem with general input. For the online model, we propose an online algorithm for jobs with jobs with arbitrary power request, arbitrary time duration, and arbitrary contiguous feasible intervals. We also show a lower bound of the competitive ratio for the smart grid scheduling problem with unit height and arbitrary width. For special cases, we design different online algorithms with better competitive ratios. Finally, we look at other optimization problems and show how to solve them by adapting our techniques. We prove that our online algorithm can solve the machine minimization problem with an asymptotically optimal competitive ratio. We also show that our exact algorithm can be adapted to solve other demand response management problems.

We investigate the power of migration in online scheduling for parallel identical machines. Our objective is to maximize the total processing time of accepted jobs. Once we decide to accept a job, we have to complete it before its deadline d that satisfies d >= (1+epsilon)p + r, where p is the processing time, r the submission time and the slack epsilon > 0 a system parameter. Typically, the hard case arises for small slack epsilon << 1, i.e. for near-tight deadlines. Without migration, a greedy acceptance policy is known to be an optimal deterministic online algorithm with a competitive factor of (1+epsilon)/epsilon (DasGupta and Palis, APPROX 2000). Our first contribution is to show that migrations do not improve the competitive ratio of the greedy acceptance policy, i.e. the competitive ratio remains (1+epsilon)/epsilon for any number of machines. Our main contribution is a deterministic online algorithm with almost tight competitive ratio on any number of machines. For a single machine, the competitive factor matches the optimal bound of (1+epsilon)/epsilon of the greedy acceptance policy. The competitive ratio improves with an increasing number of machines. It approaches (1+epsilon) ln((1+epsilon)/epsilon) as the number of machines converges to infinity. This is an exponential improvement over the greedy acceptance policy for small epsilon. Moreover, we show a matching lower bound on the competitive ratio for deterministic algorithms on any number of machines.

Recently, Huo et al. (J Sched 17(2):161–172, 2014) addressed single-machine scheduling problems with an unexpected machine unavailable interval. In their study, both the start time and the length of the unavailable interval are unknown beforehand. Two models were considered according to the way that the machine becomes unavailable, the breakdown model and the emergent job model. In this note, we further study several single-machine scheduling problems with an unexpected machine unavailable interval. For the breakdown model to minimize the total weighted completion time, we give a better lower bound which shows that the simple LPT rule can give the best possible competitive ratio. For the emergent job model to minimize the total weighted completion time, we give a new lower bound and design a best possible algorithm with a competitive ratio of $$1+4\alpha /(4+\alpha ^2)$$ , where $$\alpha \approx 0.6109$$ is the root in (0, 1) of the equation $$23\alpha ^4+24\alpha ^3+72\alpha ^2-32\alpha -16=0$$ . This improves upon the worst-case bound $$(11-\sqrt{2})/7$$ of the heuristic presented by Huo et al. (J Sched 17(2):161–172, 2014). Moreover, for minimizing the total completion time, we prove no 9/7- and 5/4-competitive online algorithm exist for the breakdown model and emergent job model, respectively. Then, we propose a best possible algorithm for the latter model.

Two important characteristics encountered in many real-world scheduling problems are heterogeneous processors and a certain degree of uncertainty about the sizes of jobs. In this paper we address both, and study for the first time a scheduling problem that combines the classical unrelated machine scheduling model with stochastic processing times of jobs. Here, the processing time of job j on machine i is governed by random variable P_{ij} , and its realization becomes known only upon job completion. With w_j being the given weight of job j, we study the objective to minimize the expected total weighted completion time E[Sum w_j.C_j] , where C_j is the completion time of job j. By means of a novel time-indexed linear programming relaxation, we compute in polynomial time a scheduling policy with performance guarantee (3+D)/2+e. Here, e>0 is arbitrarily small, and D is an upper bound on the squared coefficient of variation of the processing times. When jobs also have individual release dates r_{ij}, our bound is (2+D)+e. We also show that the dependence of the performance guarantees on D is tight. Via D=0, currently best known bounds for deterministic scheduling on unrelated machines are contained as special case.

This paper investigates a classic online scheduling problem with learning effect on a single machine. Specifically, a number of independent jobs that arrive online over time will be processed on a single machine and learning effect implies that the real processing time of job [Formula: see text] is a non-increasing function of its position [Formula: see text], i.e., [Formula: see text], where [Formula: see text] is the basic processing time of job [Formula: see text] and [Formula: see text] is the learning index. Our goal is to minimize the total completion time of all jobs. For the problem, we develop a deterministic polynomial time online algorithm called Delayed Shortest Basic Processing Time (DSBPT) and state that it is an online algorithm with a competitive ratio of 2, which matches the lower bound of the online scheduling problem we focus on.