Introduction

In this chapter, we describe a generic primal–dual technique to bound the competitive ratio for a variety of online problems, whose relaxations can be posed as linear programs (LPs). The basic idea of this approach is to interpret the relaxation of the problem that we are interested in solving as the primal program (let it be a minimization problem). Then considering the primal and its dual together, an algorithm is proposed that updates both the primal and the dual solutions on each new request of the input sequence, such that the increment in the primal cost is upper bounded by c (for some c > 1) times the increment in the dual cost. Combining this with the weak duality of LPs, that means that the primal cost is lower bounded by the optimal value of the dual, it follows that the competitive ratio of the proposed algorithm is at most c.

We first describe this recipe in detail, and then discuss three versatile problems that are well suited for this primal–dual schema's application.

The first problem we consider is the set cover problem, where we are given a universe of elements and a collection of subsets of the universe, with each subset having an associated cost. The elements of the universe arrive online, and on each new element's arrival, if that element is not part of the current cover (collection of subsets), then at least one subset that contains that element has to be included in the cover. The objective is to choose that set of subsets that minimizes the sum of the cost of the cover at the end of all element arrivals in the input.

The set cover problem is a special case of what is known as covering problems, where the objective is to minimize the cost of selected resources under some generic coverage constraints. The dual of the covering problem is a packing problem, such as the knapsack problem (Chapter 8), where the objective is to maximize the profit of included items subject to some capacity constraints on the total size of the included items.

The next problem we consider is a packing problem, called the AdWords, that is highly relevant for online web portals like Google, Facebook, etc., where items (ad slots) arrive online and their valuation from multiple interested buyers (advertisers) are revealed.

Types of Adversaries and Their Relationships

Definition A.1.1 For randomized online algorithms, the oblivious adversary has to generate the entire input sequence in advance (using only the information about distribution used by the randomized algorithm) before any requests are served by the online algorithm. Thus, the adversary has no access to the random choices made by the algorithm. Moreover, OPT's cost is equal to the cost of the optimal offline algorithm knowing the entire input sequence in advance.

Let the oblivious adversary be denoted as Qo. Then Qo knows the distribution D used by the randomized algorithmR, but does not know the actual random choices made byR. Another way to describe this interaction is that Qo chooses input 1, 2, … , which is processed by R sequentially with decisions d1, d2, … and Qo has to make request i without any knowledge of d1, d2, … , di−1.

Definition A.1.2 For a minimization problem, a randomized algorithm R is -competitive against an oblivious adversary Qo if

whereis the input generated by Qo.

Definition A.1.3 Adaptive adversary Qa: Adversary is allowed to observe the online algorithm's decisions (random choices) and generate the next request based on that. Thus, Qa's request i can depend on d1, d2, … , di−1

Definition A.1.4 Adaptive offline adversary Qaf: Adversary is allowed to observe the online algorithm's decisions (random choices) and generate the next request based on that. Moreover, OPT is allowed access to this sequence offline and hence is charged the optimum offline cost for that sequence. Thus, once R has made its sequential decisions d1, d2, … , dn that can be used to generate 1, 2, … , n, OPT's cost is the cost incurred by the optimal offline algorithm knowing the full sequence 1, 2, … , n ahead of time.

A slightly weaker definition is as follows.

Definition A.1.5 Adaptive online adversary Qao: Adversary is allowed to observe the online algorithm's decisions (random choices) and generate the next request based on that. OPT, however, also must serve each request online, i.e., before knowing the random choices made by the online algorithm on the present request, which in turn possibly influences the next request made by the adversary.

Introduction

In this chapter, we consider a very general and abstract online problem that generalizes various problems already studied in this book, e.g., paging and list accessing. For any generic problem, the cost paid by any online algorithm on the arrival of a new request is a function of its current state and the action taken to fulfil the new request. Typically, the chosen action also alters the state of the algorithm, which then determines the subsequent costs. To model this interplay between cost and state transitions, an abstract paradigm called the metrical task system (MTS) is defined, where there is a set of all possible states (one of them is occupied by any online algorithm at any time).

Requests arrive over time, and the cost of an online algorithm to serve or fulfil each request depends on the state from which it chooses to fulfil the request. This cost is called the state dependent cost. If the online algorithm serves the newly arrived request from its current state, then the only cost it pays is the state dependent cost. Otherwise, it first transitions to a new state and then serves the request. In the event of a transition, the algorithm pays the state dependent cost of the new state in addition to the switching cost to move from the present state to the new state. The switching cost is restricted to satisfying the usual metric properties, e.g., the triangle inequality. The overall cost of an online algorithm is the sum of the state dependent cost and the switching cost, summed over all requests. This is a very generic formulation and can model any finite state dependent dynamical system.

We begin this chapter by deriving a lower bound on the competitive ratio of any deterministic algorithm for the MTS. Because of the generality of the MTS, the power of deterministic online algorithms is limited, and the competitive ratio of any deterministic online algorithm is at least 2|S| − 1, where |S| is the total number of states. Thus, more the number of states, more is the power that adversary has over an online algorithm. We next present a simple algorithm called work-function, based on the broad principle of dynamic programming, that achieves this lower bound exactly.

Introduction

In Chapter 13, we considered the problem of minimizing flow time for both single and multiple servers, when server speeds were fixed, and the only decision variable was which job to schedule or process at each time. With speed tuneable servers, a natural extension of this problem, called speed scaling, was studied in Chapter 14, where the problem of minimizing flow time plus energy was studied, with two decision variables: which job to schedule or process and its processing speed.

In this chapter, we consider an alternate formulation of the speed scaling problem, where jobs have deadlines, and server speeds are tuneable with corresponding power functions. The problem is to find which job to schedule or process at each time, and its processing speed, so as to minimize the total energy used, such that each job is complete by its deadline. For this formulation, both the common deadline case (all deadlines are identical) and the individual deadline case are of interest.

With a single server, for the commonly used power function P(s) = s,> 1 with speed s, we present an online algorithm for both the common and the individual deadlines case, for which the competitive ratio is upper bounded by , and the upper bound is also tight for the considered algorithm. For P(s) = s,> 1, we also consider the more modern paradigm of machine learning augmented algorithm for going beyond the worst case, where prediction about job arrival times and their sizes is available, but with uncertain accuracy.

Another power function of interest, motivated by information theory, is given by P(s) = 2s − 1, which results in fundamentally different results than P(s) = s. For P(s) = 2s − 1, with a single server, we present an online algorithm whose competitive ratio is at most 3 only for the common deadline case. For the common deadline case, we also show how to extend results from the single server case to the multiple server case without changing the competitive ratio.

Introduction

In this chapter, we consider a more complicated scheduling problem than Chapter 15, where the resource needed for the processing of packets, energy, itself arrives over time, and the algorithm has only causal knowledge about it. This paradigm is relevant for communication systems powered by renewable energy sources, where the amount of energy arriving at each time slot is unpredictable. This scenario also models scheduling problems on factory floors where the availability time of, say, raw materials or multiple machines needed to complete a complicated job is uncertain and is revealed causally to the algorithm.

Conventionally, in online scheduling, unlimited energy is available, and the objective is to minimize a combination of energy used and relevant performance metrics, e.g., makespan, completion time, flow time, and the only uncertainty is about the packet or job arrival times and their sizes. For the online scheduling problem considered in the chapter, both the amount of energy and its arrival slots in the future are unknown to the algorithm and are possibly controlled by the adversary. With energy arriving over time and in arbitrary amounts, the generic scheduling problem is to minimize any performance metric, subject to the energy neutrality constraint, i.e., the amount of energy used by any time is at most the amount of energy that has arrived so far.

With arbitrary energy arrivals, we consider a canonical problem of transmitting a single packet (with a fixed number of bits) to minimize its completion time. Without loss of generality, we assume that the total amount of energy that arrives over time is sufficient to transmit the packet completely by the optimal offline algorithm OPT. The challenge is to propose an algorithm that can compete with OPT. We show that a Lazy algorithm has a competitive ratio of 2, which is also the best possible.

The considered problem in this chapter is fairly versatile. For example, it can model a scheduling paradigm where there are multiple servers but their availability is unknown, and the amount of work done in each slot is a concave function of the number of servers used in that slot. Then a scheduling problem (with any usual performance metric such as flow time, makespan, completion time) emerges where the decision is: how many servers to use among the available ones at each time.

Introduction

In this chapter, we visit a classical combinatorial problem, the travelling salesman problem (TSP). In the offline case, TSP is formulated over an undirected graph, where each edge has a weight, and the objective is to minimize the total edge weight of the tour that starts and ends at the same vertex and visits each vertex of the graph at least once. TSP in the offline case is a very rich problem and has been an object of intense study. In the online setting, TSP can be posed in multiple ways, and we study two of the most prominent versions in this chapter.

The first version we consider involves sites to be visited that belong to a metric space. Consider a walker that can walk at most unit speed. Starting at a fixed site, sites (locations) to be visited in the future belonging to a metric space are revealed sequentially, while the walker is travelling. The goal of the walker is to visit all sites and return to the starting site in the minimum time possible while ensuring that a site is visited only after it has been revealed. This version captures some of the online counterparts of the usual offline TSP applications. For this version, we first show that the competitive ratio of any online algorithm is at least 2, and then present a simple algorithm that achieves the lower bound.

The second version we consider is an exploration problem over an unknown graph. Assume that a walker is at a particular (starting) vertex of an unknown undirected edge weighted graph G. The walker's objective is to visit all the vertices of G and return to the starting vertex over the shortest path. The online restriction is that at any time, only the neighbours of all the visited vertices so far and the associated edge weights are revealed. Thus, each time a walker reaches a new vertex, it has to decide which vertex to visit next, given the partial graph information. This unknown graph exploration version is seemingly more difficult than the site exploration version, and we present the best-known online algorithm with the competitive ratio of at most 16.

Introduction

In this chapter, we discuss the online version of one of the most versatile combinatorial problems, called the knapsack. In the classical offline version of the knapsack problem, we are provided with a set of items I and a knapsack of size or capacity C. Each item i * I has value v(i) and size w(i), and the problem is to select a subset of I that maximizes the sum of the value of the selected items, subject to the sum of the sizes of the selected items being less than the capacity C of the knapsack.

Because of the two unrelated attributes for each item, value and size, the knapsack problem is sufficient to model various real-world problems where the objective is to maximize a utility function subject to an independent capacity constraint. Important examples of the knapsack problem are scheduling with resource capacity constraints, budgeted auctions, combinatorial resource allocation, etc.

In the online version, the knapsack capacity constraint is available ahead of time, but each item is presented sequentially when its value and size are revealed. An item on its arrival has to be permanently accepted or rejected, irrevocably. It is worth mentioning that the secretary problem considered in Chapter 7 is a special case of the online knapsack problem, where the size of each item is 1 and the knapsack capacity is also 1. Thus, unfortunately, the result that no algorithm is competitive for the secretary problem under the adversarial input carries over for the knapsack problem. Therefore, in this chapter, we primarily consider the secretarial input and present an online algorithm whose competitive ratio is a constant.

We show that a randomized algorithm based on the sample and price philosophy is 1/10ecompetitive in expectation for the knapsack problem with the secretarial input model. We also consider the worst-case input, though with resource augmentation, where an online algorithm is allowed more capacity than the optimal offline algorithm, and an online algorithm is also allowed to reject previously accepted items.

Introduction

In this chapter, we begin our discussion on the problem of scheduling jobs with multiple servers, which has widespread applications in areas of operations research, communication networks, etc. Essentially, jobs with a certain processing requirement, called size, arrive over time. There are multiple identical fixed-speed servers, and the problem is to assign jobs to fixed-speed servers so as to minimize some function of the job response time (departure minus the arrival time).

Different objectives are of interest for solving the scheduling problem that are application specific. For example, when an application depends on the time when all the jobs are finished, then makespan (the finishing time of the last completed job) is considered, while when the total delay is of interest, flow time (sum of the response times of all jobs) is the chosen objective. A special case of flow time is the completion time, which is defined as the sum of the departure times of all jobs, disregarding their arrival times.

As we discussed in Chapter 12, the load balancing problem with the objective of minimizing the maximum load is the same as minimizing makespan. Thus, in this chapter, we concentrate on solving the scheduling problem with the objective of minimizing the flow time. The completion time problem is simpler than the flow time problem.

For the considered scheduling problem, multiple classes of restrictions are possible, e.g., whether preemption is allowed or not, can a job be migrated between servers or not, are jobs required to be assigned to a server (which cannot be changed later) as soon as they arrive or not, whether server speeds are identical or not, and, finally, is there a job–server assignment restriction (a job can be processed by only a subset of servers). Different restrictions imply very different results on the competitive ratio for online algorithms.

In this chapter, we concentrate on the simplest setting where both preemption and job migration are allowed. Moreover, we consider that all servers are identical, having fixed speed, with no job–server assignment restriction, and a job can be assigned to a server any time after it has arrived, and not necessarily on its arrival. Some other settings are explored via problems at the end of the chapter. Scheduling problem with variable speed servers is discussed in the next chapter.

Introduction

In this chapter, we consider the load balancing problem, which in its simplest form is to assign jobs with different sizes sequentially to multiple machines so as to minimize the maximum of the sum of the sizes of jobs assigned to any machine at any point in time.

We present some of the basic techniques developed for solving the load balancing problem under many settings of interest. We start with the simplest setting, where all machines are identical and all jobs are of equal size, and they are permanent, i.e., once they arrive, they do not leave the system. In this setting, round robin is an optimal algorithm; however, it needs to remember past decisions, requiring memory. One challenge is to devise algorithms that are memoryless but still have performance close to that of round robin. In this setting, we present the power-of-d algorithm, where a job on its arrival is assigned to the least loaded machine among d machines, where the d machines are chosen uniformly randomly from the set of all machines.

When job sizes are arbitrary, the load balancing problem is a bit more difficult. For permanent jobs with arbitrary sizes, we consider the case where machine speeds are not identical, and present a near-optimal deterministic online algorithm. Compared to the permanent jobs setting, the temporary jobs setting is more practical but challenging, where jobs arrive into the system and leave at an arbitrary time that is not necessarily known to an algorithm. In the temporary jobs case, we consider two well-studied models: (i) with machine restriction, where each job can be processed by a subset of machines while all the machines have identical speed, and (ii) without machine restriction, where any job can be processed by any machine; however, machine speeds are non-identical.

Finally, we consider the load balancing problem over a network, where each job corresponds to a source–destination pair, and fulfilling a job involves finding a path from the specified source to the destination. Assigning a job to a path means that each edge on that path carries an additional load equal to the size of the job.

Introduction

In this chapter, we supplement the problem of minimizing the flow time with multiple fixedspeed servers considered in Chapter 13 by allowing the flexibility for each server to have a tuneable speed. This setup is typically referred to as speed scaling in the literature. Increasing server speed decreases the flow time but comes at a cost of increased energy consumption, which is typically accounted for by defining a speed based power cost function P(s) that is an increasing function of speed s.

A variety of problems can now be formulated, such as minimizing flow time subject to a constraint on the total energy cost, or minimizing a linear combination of flow time and total energy cost, etc. The most popular problem studied in literature is the linear combination of flow time and total energy cost, generally referred to as the flow time plus energy problem.

In this chapter, we consider the flow time plus energy problem and begin with the single server case. With a single server, SRPT remains an optimal scheduling algorithm, and the only non-trivial decision is the speed choice. We will show that an algorithm that chooses speed such that the power consumption at each time instant is equal to the number of incomplete jobs in the system plus one is 3-competitive, independent of the power cost function P.

Next, we consider the more challenging speed scaling problem when there are multiple identical servers, i.e., with the same power cost function P. We consider the multi-server version of the SRPT algorithm for scheduling, and the following speed choice: the total power consumption across all servers at any time instant is equal to the number of incomplete jobs in the system, and all servers process their jobs at the same speed. We show that this algorithm is constant competitive, where the constant depends only on the cost function P. Recall from Chapter 13 that the competitive ratio of the SRPT algorithm with fixed speed servers to minimize the flow time is, where n is the number of jobs and m is the number of servers, and wmax and wmin are the maximum and minimum job sizes.

Introduction

In this chapter, we consider a classical online problem, called paging, where a file request sequence is served from two memories – one fast, called the cache, with finite size, and the other slow, which contains all the files. On a file request, if that file is not found in the cache, then it is loaded from the large memory into the cache by ejecting one of the existing files of the cache. Each such ejection is called a fault and the goal is to minimize the total number of faults without knowing the future file request sequence.

The paging problem is directly relevant for the critical question of what to store in the random access memory (RAM) of a computer system so as to minimize the number of memory overwrites. It has also received renewed attention recently with the advent of large content distribution networks (CDNs), e.g., Youtube, where multiple limited-sized caches serve fastevolving contents that are located closer to the end-users.

For the paging problem, we first consider the deterministic setting, for which we first find a lower bound on the competitive ratio of any online algorithm and then describe an algorithm whose competitive ratio matches the lower bound. Similar strategy is adopted for randomized algorithms, where we first derive a lower bound, and then discuss an almost optimal randomized algorithm. Machine learning augmented algorithms are also considered, where prediction about the future request arrivals is available, albeit with uncertain accuracy. The goal in this paradigm is to design online algorithms that are close to optimal when the accuracy of prediction is very good, and have a reasonable competitive ratio otherwise. We also discuss the randomized input setting, where we show that all natural deterministic algorithms perform poorly, and non-trivial algorithms are required to achieve close to optimal competitive ratios.

To address the modern application of paging in CDNs, we finally consider the multiple cache paging problem, where the input at each time is a vector of file requests that are served by multiple caches parallely.

Introduction

In this chapter, we consider an important practical problem in modern data centres: how many servers to provision, given the uncertain demand, in the presence of a switching cost incurred in increasing or decreasing the number of active servers over time.

At a data centre, let the demand at time t be D(t) that is revealed causally over time. Dedicating S(t) number of servers at time t to support this demand, two types of costs are incurred; the quality of service cost depending on D(t), S(t) and the energy cost required to run the S(t) servers. The two costs are combined to produce a single cost function ft(St, Dt). In addition, because of obvious practical limitations, there is a penalty in changing the number of servers across time slots, captured by cost function c(S(t − 1), S(t)), where c is a specific function that increases with |S(t − 1) − S(t)|. Overall, the optimization problem is to choose S(t) with uncertain demand D(t) so as to minimize ft(St, Dt) + c(S(t − 1), S(t)) summed across time. This problem is popularly known as server provisioning for power-proportional data centers.

To model this popular and important problem, in this chapter, we consider a general framework of online convex optimization (OCO) with switching cost, where at each discrete time t, a convex function ft : d → + is revealed, and an algorithm has to choose an action xt knowing all f, ≤ t. The cost of choosing action xt at time t is the sum of the suboptimality/ hitting cost ft(xt), and the switching cost c(xt−1, xt). The goal is to choose xt, 1 ≤ t ≤ T such that the overall cost summed over T slots is minimized. Note that for the server provisioning problem, d = 1.

Problem Formulation

At each discrete time 1 ≤ t ≤ T, a non-negative convex function ft arrives such that ft : d → +. Let x⋆t = arg minx ft(x). Let x0 be fixed for time 0. On the arrival of the function ft at time t, the decision is to move from the current action xt−1 to a new action xt, where the total cost is the sum of two types of costs: (i) hitting cost ft(xt) and (ii) switching cost c(xt−1, xt).

Introduction

In this chapter, we will consider one of the earliest studied online problems called list accessing. This problem is motivated by memory systems, where files are stored in a stack or a list, and the cost of accessing any file depends on the location of the file in the list. In particular, with files ordered from left to right, the cost of accessing a file is the number of files preceding it in the list from the left plus one.

Requests for files arrive online, and the memory system is allowed to move or shuffle the files after every file request in the quest for minimizing future costs, without of course knowing the file requests to be made in the future. Thus, the decision variable is how to move files in an online manner after every file request so as to minimize the sum of the costs across all file requests. This problem is non-trivial even in the offline setting, and for very long its complexity was unknown. Only in the early 2000s did it get settled and was shown to be NP-hard.

In the online setting, early progress was made for deterministic algorithms, where a natural algorithm called move-to-front, which moves the requested file to the first place/front of the list, is shown to be optimal and achieves a competitive ratio close to 2. For the randomized setting, an online algorithm with a competitive ratio of 1.6 is known, with the best-known lower bound being 1.5. Thus, there is a gap in characterizing the optimal randomized algorithm.

In this chapter, we will first consider the deterministic setting and show that the move-tofront algorithm is optimal. Next, we present the lower bound of 1.5 on randomized algorithms and a randomized algorithm whose competitive ratio is at most 1.75.

Problem Definition

Consider that there is a collection of L files that are stored in a horizontal stack of size L called the list, where file fi, i = 1, … , L, is in location ℓi(t) at time t from the left. The inputis a sequence of file requests, where if at time t, file fi is requested, then the cost for fulfilling this request is ℓi(t).

This chapter studies a robust counterpart with interval range uncertainty for LQ dose-response parameters in the fractionation problem with two modalities. As in previous chapters, the robust formulation is inevitably infinite-dimensional. The chapter describes its equivalent reformulation that calls for solving a finite set of subproblems. Each of these subproblems can be solved using the two analytical solution methods described in the previous chapter. Clinical insights into the resulting treatment plans are derived via numerical experiments.