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.

This chapter extends the formulation from the previous chapter by including multiple organs-at-risk. The four analytical solution methods from the previous chapter are generalized to this case. Again, the structure of the solution depends on the relative values of the LQ dose-response parameters of the tumor and the organs-at-risk. The four solution methods are only adequate in two of the three possibilities that can arise regarding these relative parameter values. While these two possibilities are natural extensions of similar scenarios from the previous chapter, the third one is unique to this chapter. The chapter thus includes a fifth solution method to tackle this third possibility. That approach relies on reformulating the quadratically constrained quadratic program as an equivalent linear program with two variables. Clinical insights are obtained via numerical experiments.

This chapter accommodates uncertainty in the LQ dose-response parameters of the spatiotemporally integrated formulation of the fractionation problem from the previous chapter. It pursues a robust optimization approach, where the uncertainty is modeled using interval ranges for possible parameter values. The resulting robust formulation is infinite-dimensional. The chapter describes an approach rooted in linear programming duality to equivalently reformulate this as a finite collection of finite-dimensional convex linear-quadratic programs. The effect of the size of interval ranges on the treatment plans is studied via computational experiments.

The number of treatment sessions and the doses administered in each of these sessions were the decision variables in all chapters thus far. In practice, these doses are in turn determined by the intensity profile of the radiation field. In this chapter, we study a new, more general class of formulations where these intensity profiles are optimized directly along with the number of treatment sessions. These formulations fall within the realm of spatiotemporally integrated fractionation. They take the form of mixed integer nonconvex nonlinear programs and are computationally intractable to solve exactly. The chapter describes an approximate solution method rooted in solving a sequence of convex linear-quadratic problems. Clinical insights into the resulting treatment plans are derived via computational experiments.