Online Makespan Minimization with Parallel Schedules

Online algorithms are usually analyzed using the notion of competitive ratio which compares the solution obtained by the algorithm to that obtained by an online adversary for the worst possible input sequence. Often this measure turns out to be too pessimistic, and one popular approach especially for scheduling problems has been that of which was first proposed by Kalyanasundaram and Pruhs. Although resource augmentation has been very successful in dealing with a variety of objective functions, there are problems for which even a (arbitrary) constant speedup cannot lead to a constant competitive algorithm. In this paper we propose a model which requires no resource augmentation but which permits the online algorithm to not serve an epsilon-fraction of the requests.The problems considered in this paper are in the restricted assignment setting where each job can be assigned only to a subset of machines. For the load balancing problem where the objective is to minimize the maximum load on any machine, we give O(log2 1/e)-competitive algorithm which rejects at most an e-fraction of the jobs. For the problem of minimizing the maximum weighted flow-time, we give an O(1/e4)-competitive algorithm which can reject at most an e-fraction of the jobs by weight. We also extend this result to a more general setting where the weights of a job for measuring its weighted flow-time and its contribution towards total allowed rejection weight are different. This is useful, for instance, when we consider the objective of minimizing the maximum stretch. We obtain an O(1/e6)-competitive algorithm in this case.Our algorithms are immediate dispatch, though they may not be immediate reject. All these problems have strong lower bounds in speed augmentation model.

This paper studies the online Orthogonal Variable Spreading Factor (OVSF) code assignment problem with resource augmentation introduced by Erlebach et al. (in STACS 2004. LNCS, vol. 2996, pp. 270---281, 2004). We propose a (1+1/?)-competitive algorithm with help of (1+???)lg? h trees for the height h of the OVSF code tree and any ??1. In other words, it is a (1+?)-competitive algorithm with help of (1+?1/??)lg? h trees for any constant 0<?≤1. In the case of ?=1 (or ?=1), we obtain a 2-competitive algorithm with 2lg? h trees, which substantially improves the previous resource of 3h/8+2 trees shown by Chan et al. (COCOON 2009. LNCS, vol. 5609, pp. 358---367, 2009). In another aspect, if it is not necessary to bound the incurred cost for individual requests to a constant, an amortized (4/3+?)-competitive algorithm with (11/4+4/(3?)) trees for any 0<?≤4/3 is also designed in Chan et al. (COCOON 2009. LNCS, vol. 5609, pp. 358---367, 2009). The algorithm in this paper gives us a new trade-off between the competitive ratio and the resource augmentation when ??3 (or ?≤1/3), although the incurred cost for individual requests is bounded to a constant.

Overview: We study a classical scheduling problem that has been investigated for more than forty years. Consider a sequence of jobs σ = J 1, …, J n that has to be scheduled on m identical parallel machines. Each job J t has an individual processing time p t , 1 ≤ t ≤ n. Preemption of jobs is not allowed. The goal is to minimize the makespan, i.e. the maximum completion time of any job in the constructed schedule. In the offline variant of the problem all jobs of σ are known in advance. In the online variant the jobs arrive one by one. Each incoming job J t has to be assigned immediately to one of the machines without knowledge of any future jobs J t′, t′ > t.KeywordsCompetitive RatioOnline AlgorithmOnline ScheduleIdentical Parallel MachineMaximum Completion TimeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Cloud providers such as Amazon EC2 and Google GCE typically price their idle compute resources at a significant discount in the form of transient servers. Unlike regular servers, cloud transient servers have no reliability guarantee and can be revoked anytime. In order to enjoy the price premium of transient servers while mitigating the impact of indefinite server revocations, cloud users continuously checkpoint current computational states to stable storage. To determine the optimal checkpointing interval, prior works have largely built upon predicting future revocations. However, we argue that existing prediction models may not work well if providers employ different server revocation algorithms in the future, and the required historical information can be unavailable in practice. In this work, we propose two online algorithms, one competitive and the other heuristic, that determine the checkpointing intervals without predicting future revocation based on history. Our competitive online algorithm achieves the best possible competitive ratio against the optimal, yet impractical, offline solution. Our heuristic algorithm adaptively reacts to server revocations, achieving better average performance than the competitive algorithm, especially for short-running tasks. Extensive trace-driven simulations confirm our analytical results and demonstrate the efficacy of the two online algorithms in the context of Amazon EC2 Spot Instances.

The peak-demand charge motivates large-load customers to flatten their demand curves, while their self-owned renewable generations aggravate demand fluctuations. Thus, it is attractive to utilize energy storage for shaping real-time loads and reducing electricity bills. In this paper, we propose the first peak-aware competitive online algorithm for leveraging stored energy (e.g., in fuel cells) to minimize peak-demand charges. Our algorithm decides the discharging quantity slot by slot to maintain the optimal worst-case performance guarantee (namely, competitive ratio) among all deterministic online algorithms. Interestingly, we show that the best competitive ratio can be computed by solving a linear number of linear-fractional problems. We can also extend our competitive algorithm and analysis to improve the average-case performance and consider short-term prediction.

Makespan minimization on identical machines is a fundamental problem in online scheduling. The goal is to assign a sequence of jobs to m identical parallel machines so as to minimize the maximum completion time of any job. Already in the 1960s, Graham showed that Greedy is (2-1/m)-competitive. The best deterministic online algorithm currently known achieves a competitive ratio of 1.9201. No deterministic online strategy can obtain a competitiveness smaller than 1.88. In this paper, we study online makespan minimization in the popular random-order model, where the jobs of a given input arrive as a random permutation. It is known that Greedy does not attain a competitive factor asymptotically smaller than 2 in this setting. We present the first improved performance guarantees. Specifically, we develop a deterministic online algorithm that achieves a competitive ratio of 1.8478. The result relies on a new analysis approach. We identify a set of properties that a random permutation of the input jobs satisfies with high probability. Then we conduct a worst-case analysis of our algorithm, for the respective class of permutations. The analysis implies that the stated competitiveness holds not only in expectation but with high probability. Moreover, it provides mathematical evidence that job sequences leading to higher performance ratios are extremely rare, pathological inputs. We complement the results by lower bounds, for the random-order model. We show that no deterministic online algorithm can achieve a competitive ratio smaller than 4/3. Moreover, no deterministic online algorithm can attain a competitiveness smaller than 3/2 with high probability.

We develop a new approach for online network design and obtain improved competitive ratios for several problems. Our approach gives natural deterministic algorithms and simple analyses. At the heart of our work is a novel application of embeddings into hierarchically well-separated trees (HSTs) to the analysis of online network design algorithms --- we charge the cost of the algorithm to the cost of the optimal solution on any HST embedding of the terminals. This analysis technique is widely applicable to many problems and gives a unified framework for online network design. In a sense, our work brings together two of the main approaches to online network design. The first uses greedy-like algorithms and analyzes them using dual-fitting. The second uses tree embeddings and results in randomized $O(\log n)$-competitive algorithms, where $n$ is the total number of vertices in the graph. Our approach uses deterministic greedy-like algorithms but analyzes them via HST embeddings of the terminals. Our proofs are simpler as we do not need to carefully construct dual solutions and we get $O(\log k)$ competitive ratios, where $k$ is the number of terminals. In this paper, we apply our approach to obtain deterministic $O(\log k)$-competitive online algorithms for the following problems. - Steiner network with edge duplication. Previously, only a randomized $O(\log n)$-competitive algorithm was known. - Rent-or-buy. Previously, only deterministic $O(\log^2 k)$-competitive and randomized $O(\log k)$-competitive algorithms by Awerbuch, Azar and Bartal (2004) were known. - Connected facility location. Previously, only a randomized $O(\log^2 k)$-competitive algorithm by San Felice, Williamson and Lee (2014) was known. - Prize-collecting Steiner forest. We match the competitive ratio first achieved by Qian and Williamson (2011) and give a simpler analysis.

We study the k -server problem in the resource augmentation setting, i.e., when the performance of the online algorithm with k servers is compared to the offline optimal solution with h ≤ k servers. The problem is very poorly understood beyond uniform metrics. For this special case, the classic k -server algorithms are roughly (1+1/ϵ)-competitive when k =(1+ϵ) h , for any ϵ &gt; 0. Surprisingly, however, no o ( h )-competitive algorithm is known even for HSTs of depth 2 and even when k / h is arbitrarily large. We obtain several new results for the problem. First, we show that the known k -server algorithms do not work even on very simple metrics. In particular, the Double Coverage algorithm has competitive ratio Ω ( h ) irrespective of the value of k , even for depth-2 HSTs. Similarly, the Work Function Algorithm, which is believed to be optimal for all metric spaces when k = h , has competitive ratio Ω ( h ) on depth-3 HSTs even if k =2 h . Our main result is a new algorithm that is O (1)-competitive for constant depth trees, whenever k =(1+ϵ) h for any ϵ &gt; 0. Finally, we give a general lower bound that any deterministic online algorithm has competitive ratio at least 2.4 even for depth-2 HSTs and when k / h is arbitrarily large. This gives a surprising qualitative separation between uniform metrics and depth-2 HSTs for the ( h , k )-server problem.

A generalized paging problem is considered. Each request is expressed as a set of u pages. In order to satisfy the request, at least one of these pages must be in the cache. Therefore, on a page fault, the algorithm must load into the cache at least one page out of the u pages given in the request. The problem arises in systems in which requests can be serviced by various utilities (e.g., a request for a data that lies in various web-pages) and a single utility can service many requests (e.g., a web-page containing various data). The server has the freedom to select the utility that will service the next request and hopefully additional requests in the future. The case u=1 is simply the classical paging problem, which is known to be polynomially solvable. We show that for any u>1 the offline problem is NP-hard and hard to approximate if the cache size k is part of the input, but solvable in polynomial time for constant values of k. We consider mainly online algorithms, and design competitive algorithms for arbitrary values of k, u. We study in more detail the cases where u and k are small. We also give an algorithm which uses resource augmentation and which is asymptotically optimal for u=2.

Online algorithms are a hallmark of worst case optimization under uncertainty. On the other hand, in practice, the input is often far from worst case, and has some predictable characteristics. A recent line of work has shown how to use machine learned predictions to circumvent strong lower bounds on competitive ratios in classic online problems such as ski rental and caching. We study how predictive techniques can be used to break through worst case barriers in online scheduling. The makespan minimization problem with restricted assignments is a classic problem in online scheduling theory. Worst case analysis of this problem gives Ω(log m) lower bounds on the competitive ratio in the online setting. We identify a robust quantity that can be predicted and then used to guide online algorithms to achieve better performance. Our predictions are compact in size, having dimension linear in the number of machines, and can be learned using standard off the shelf methods. The performance guarantees of our algorithms depend on the accuracy of the predictions, given predictions with error η, we show how to construct O(log η) competitive fractional assignments. We then give an online algorithm that rounds any fractional assignment into an integral schedule. Our algorithm is O((log log m)3)-competitive and we give a nearly matching Ω(log log m) lower bound for online rounding algorithms.1 Altogether, we give algorithms that, equipped with predictions with error η, achieve O(log η (log log m)3) competitive ratios, breaking the Ω(log m) lower bound even for moderately accurate predictions.

Applying “Peeling Onion” approach for competitive analysis in online scheduling with rejection

We study the dynamic bin packing problem introduced by Coffman, Garey and Johnson. This problem is a generalization of the bin packing problem in which items may arrive and depart from the packing dynamically. The main result in this paper is a lower bound of 2.5 on the achievable competitive ratio, improving the best known 2.428 lower bound, and revealing that packing items of restricted form like unit fractions (i.e., of size 1/k for some integer k), for which a 2.4985-competitive algorithm is known, is indeed easier. We also investigate the resource augmentation version of the problem where the on-line algorithm can use bins of size b (>1) times that of the optimal off-line algorithm. An interesting result is that we prove b=2 is both necessary and sufficient for the on-line algorithm to match the performance of the optimal off-line algorithm, i.e., achieve 1-competitiveness. Further analysis gives a trade-off between the bin size multiplier 1<b≤2 and the achievable competitive ratio.

In this paper we study a dynamic version of capacity maximization in the physical model of wireless communication. In our model, requests for connections between pairs of points in Euclidean space of constant dimension d arrive iteratively over time. When a new request arrives, an online algorithm needs to decide whether or not to accept the request and to assign one out of k channels and a transmission power to the request. Accepted requests must satisfy constraints on the signal-to-interference-plus-noise (SINR) ratio. The objective is to maximize the number of accepted requests. Using competitive analysis we study algorithms using distance-based power assignments, for which the power of a request relies only on the distance between the points. Such assignments are inherently local and particularly useful in distributed settings. We first focus on the case of a single channel. For request sets with spatial lengths in [1,Δ] and duration in [1,Γ] we derive a lower bound of ?(Γ?Δ d/2) on the competitive ratio of any deterministic online algorithm using a distance-based power assignment. Our main result is a near-optimal deterministic algorithm that is O(Γ?Δ(d/2)+? )-competitive, for any constant ?>0. Our algorithm for a single channel can be generalized to k channels. It can be adjusted to yield a competitive ratio of O(k?Γ 1/k??Δ(d/2k?)+? ) for any factorization (k?,k?) such that k??k?=k. This illustrates the effectiveness of multiple channels when dealing with unknown request sequences. In particular, for ?(log?Γ?log?Δ) channels this yields an O(log?Γ?log?Δ)-competitive algorithm. Additionally, we show how this approach can be turned into a randomized algorithm, which is O(log?Γ?log?Δ)-competitive even for a single channel.

We first show that for any bipartite graph H with at most five vertices there exists an on-line competitive algorithm for the class of H-free bipartite graphs. We then analyze the performance of an on-line algorithm for coloring bipartite graphs on various subfamilies. The algorithm yields new upper bounds for the on-line chromatic number of bipartite graphs. We prove that the algorithm is on-line competitive for $P_7$-free bipartite graphs, i.e., that do not contain an induced path on seven vertices. The number of colors used by the on-line algorithm for $P_6$-free and $P_7$-free bipartite graphs is, respectively, bounded by roughly twice and roughly eight times the on-line chromatic number. In contrast, it is known that there exists no competitive on-line algorithm to color $P_6$-free (or $P_7$-free) bipartite graphs, i.e., for which the number of colors is bounded by any function depending only on the chromatic number.

We study competitive on-line scheduling in multiprocessor real-time environments. In our model, every task has a deadline and a value that it obtains only if it completes by its deadline. A task can be assigned to any processor, all of which are equally powerful. The problem is to design an on-line scheduling algorithm (i.e., one in which the scheduler has no knowledge of a task until it is released) with worst case guarantees as to the total value obtained by the system. We study systems with two or more processors. We present an inherent limit on the best competitive guarantee that any on-line parallel real-time scheduler can give. Then we present a competitive algorithm that achieves a worst case guarantee which is within a small factor from the best possible guarantee in many cases. The models are a distributed system having a centralized scheduler as well as a shared memory multiprocessor. >