Scheduling split intervals with non-uniform demands

Abstract

We study the problem of maximizing the throughput of jobs wherein each job consists of multiple tasks. Consider a system offering a capacity of one unit. We are given a set of jobs, each consisting of a sequence of $r$ tasks. Each task is associated with a demand and an interval where it should be scheduled. Each job has a profit associated with it. The objective is to select a subset of jobs having the maximum profit such that at any point of time the cumulative demand of the selected jobs does not exceed the system capacity. Prior work has presented $O\left(r\right)$-approximation algorithm for two special cases: (i) unit demands – all tasks have a demand of one unit; (ii) uniform demands – for any job, all its constituent tasks have the same demand. We study the general setting wherein the tasks of a job can have non-uniform demands. We present an $O\left(r\right)$-approximation for the case where all the tasks have demands at most $1∕2$. The prior algorithms are based on the fractional local ratio technique, which we do not know how to generalize for the setting of non-uniform demands. Instead, we devise an algorithm based on the randomized rounding strategy. Our approach also provides alternative simpler algorithms for the unit and uniform demand settings. We next extend the algorithms to the more generic scenario wherein each task is associated with a processing time and a window consisting of release time and deadline, and design pseudo-polynomial time $O\left(r\right)$-approximation procedures.

Introduction

In the maximum weight independent set (MWIS) problem on interval graphs, we have a timeline divided into discrete timeslots. The input consists of a set of jobs, each associated with an interval and a profit. Two jobs are said to conflict if their associated intervals overlap. The goal is to find a maximum profit subset of non-conflicting jobs. The problem can easily be solved optimally in polynomial time, say via dynamic programming.

The MWIS on split interval graphs is a generalization of the above problem. In this problem, each job consists of $r$ non-intersecting set of intervals, called tasks, where $r$ is a parameter. Two jobs are said to conflict, if any pair of their tasks overlap. As before, the objective is to find a maximum profit subset of non-conflicting jobs. Fig. 1 presents an illustration. The original problem corresponds to the special case of $r=1$.

The problem arises naturally in scheduling settings where we have a machine/system that can execute only a single job at any point of time and the jobs need to be executed in multiple segments with breaks in between. Scheduling jobs on a disk drive provides an example application [1]. We have a set of jobs that need to acquire locks for multiple segments of data blocks on a disk. The segments required by a job can be modeled as its constituent tasks. Another application is video on demand [2], wherein a user may wish to watch a particular video in multiple sessions of her choice. In addition to the scheduling scenarios such as the above, the problem has been used to find similarity of DNA substructures in computational biology. We refer to prior work [3] for a detailed discussion on the applications of the problem.

Split interval graphs have been studied extensively in graph theory (e.g.,[4], [5], [6], [7]). In contrast to interval graphs, the MWIS problem on split interval graphs is NP-hard, even for $r=2$ [8]. The problem generalizes multi-dimensional matching and hence, it is NP-hard to approximate within a factor of $\Omega (r∕logr)$ [3], [9]. Prior work has designed approximation algorithms for the special cases of the problem. MWIS on proper $t$-union graphs corresponds to the special case wherein the $i$th task of a job can only overlap with the $i$th task of any other job and furthermore, no task is contained within another task (across jobs). Via a reduction to the MWIS on claw-free graphs, Bafna et al. [8] derived an $O\left(2^r\right)$ approximation ratio for the above special case. Chlebík and Chlebíková [10] improved the parameters involved in the above reduction. When combined with improved approximation algorithms for MWIS on claw-free graphs, due to Berman et al. [11], we get an approximation ratio $r+(1∕2)$ for the MWIS on proper $t$-union graphs. Obtaining an $O\left(r\right)$-approximation ratio for the general case of the MWIS problem on split interval graphs was an open problem. Bar-Yehuda et al. [3] resolved the issue by designing an algorithm with an approximation ratio of $2r$. Towards this purpose, they introduced the fractional local ratio technique.

In the prior setting, the system can execute only a single job at a time. Bar-Yehuda and Rawitz [12] studied a more general scenario where the system can execute multiple jobs simultaneously. Assume that the system offers a capacity of one unit. Each job $J$ has a demand (or height) $h\left(J\right)$. A feasible solution must select a set of jobs such that at any timeslot the cumulative demand of the selected jobs does not exceed the available capacity of one unit. See Fig. 2 for an illustration. They generalized the fractional local ratio based procedure to devise an algorithm with an approximation ratio of $6r$.

Our Contributions. The main objective of our paper is to study the generalized split interval scheduling wherein the constituent tasks of a job can have different demands; namely, for each job $J$ and each task $u$ of $J$, the input specifies a demand $h\left(u\right)$. As before, the objective is to select a set of jobs having the maximum profit such that the cumulative demand at any timeslot does not exceed one unit. Fig. 3 presents an illustration. We denote the problem as SplitIntervalJob. The two problems considered in prior work form special cases. (i) Unit demand case: all the tasks across all jobs have a demand of one unit (thus, a feasible solution cannot select overlapping jobs). (ii) Uniform demand case: for any job $J$, all the tasks $J$ have the same demand $h\left(J\right)$.

As discussed earlier, the prior $O\left(r\right)$-approximation algorithms for the unit and uniform demand cases work via the fractional local technique. We do not know how to generalize these algorithms to handle the generic SplitIntervalJob problem wherein the demands are non-uniform. Instead, we show that a simple randomized rounding strategy yields an $O\left(r\right)$-approximation ratio. We consider the case where the demands are sufficiently small compared to the available capacity. A task $u$ is said to be small, if its demand $h\left(u\right)\le 1∕2$. Our main result is a randomized $\left(8r\right)$-approximation algorithm for the SplitIntervalJob problem wherein all the tasks are small. We also design simpler alternative algorithms for the unit and uniform demand cases with approximation ratios of $4r$ and $12r$, respectively. We show that the algorithms can be derandomized at constant factor loss in the approximation ratio.

Devising an $O\left(r\right)$-approximation algorithm for the general case (where tasks need not be small) remains open. We point out a difficulty in solving the above problem. Both the prior algorithms (based on fractional local ratio technique) and our algorithm (based on randomized rounding) utilize a natural LP formulation. We show that the LP has an integrality gap of $\Omega \left(2^r\right)$.

In the SplitIntervalJob problem, each task is specified by a fixed interval. However, real-life scenarios offer the flexibility of executing a task within a given window. Namely, each task $u$ is associated with a processing time $\rho \left(u\right)$ and window $[\mathrm{rt}\left(u\right),\mathrm{dl}\left(u\right)]$ consisting of release time and deadline, and the task can be scheduled in any segment of length $\rho \left(u\right)$ within the window. A feasible solution must not only select the jobs to be scheduled, but also select the segments for the tasks of the selected jobs. We present pseudo-polynomial time $O\left(r\right)$-approximation algorithms for SplitIntervalJob problem with windows.

Related Work. The SplitIntervalJob problem falls under the general framework of packing integer programs (PIP). These are integer programs with $n$ variables and $m$ constraints, wherein the coefficients of the constraint matrix $\mathbf{A}$ are positive and drawn from ${[0,1]}^{m\times n}$. The input includes a weight (profit) vector $\mathbf{w}\in {[0,1]}^n$. The goal is to find a solution $\mathbf{x}\in {\{0,1\}}^n$ maximizing the total profit $\mathbf{w}\cdot \mathbf{x}$ subject to the constraint that $\mathbf{A}\cdot \mathbf{x}\le {\mathbf{1}}^n$, where ${\mathbf{1}}^n$ is the all $1$’s vector.

The framework includes the maximum independent set problem, which cannot be approximated within a factor $n^{1-ϵ}$, for any $ϵ>0$ [13]. However, prior work has obtained approximation ratios in terms of the number of constraints $m$. When $m=1$, PIP is the same as the knapsack problem and admits an FPTAS [14], whereas PTAS is known for any constant $m$ [15]. For arbitrary $m$, prior work has presented algorithms with an approximation ratio of $O\left(\sqrt{m}\right)$ [16]. Improved ratios have been derived for the case of small demands. For any integer $B\ge 1$, the above work guarantees a ratio of $O\left(m^{\frac{1}{B+1}}\right)$, if all the coefficients of $\mathbf{A}$ are at most $1∕B$. Matching hardness results have been obtained as well: the problem is NP-hard to approximate within a factor of $\Omega \left(m^{\frac{1}{B+1}-ϵ}\right)$, for any $ϵ>0$ [17].

The SplitIntervalJob problem can be modeled as PIP via representing each job by a variable and the capacity limit at each timeslot by a constraint. In our setting, the number of timeslots $T=m$ is large and so, the prior algorithms yield poor approximation ratios. In contrast, we derive approximation ratios in terms of the number of tasks $r$, which is typically much smaller.

A special case of PIP that deals with the parameter of sparsity is closer to our scenario. A PIP is said to be $r$-sparse, if every variable appears (i.e., has non-zero coefficient) in at most $r$ constraints. Building on prior work [18], Bansal et al. [19] presented an $O\left(r\right)$-approximation algorithm for $r$-sparse PIP. Subsequently, Brubach et al. [20] improved the ratio by a constant factor and derived a guarantee of $2r+o\left(r\right)$. The $r$-sparse PIP has also been studied in conjunction with the notion of small demands. For an integer $B$, if all the coefficients of the constraints matrix are at most $1∕B$, then the approximation ratio can be improved to $O\left(r^{1∕B}\right)$ [19].

We can reduce $r$-sparse PIP to the SplitIntervalJob problem by taking each variable as a job and each constraint as a timeslot. Each non-zero coefficient of a variable is then represented as a task with the demand equal to the coefficient. The resulting SplitIntervalJob instance has $r$ tasks per job. We can see that $r$-sparse PIP corresponds to the special case of SplitIntervalJob wherein all the tasks are only one timeslot long, whereas the general SplitIntervalJob problem allows for the tasks to be arbitrary long.

The $r$-set packing problem is the special case of $r$-sparse PIP wherein all the coefficients are from $\{0,1\}$. Equivalently, we have a set of elements and a collection of subsets of the elements, where each subset is of cardinality $r$. The aim is to select the maximum number of subsets such that the selected sets are pairwise disjoint. For the above problem, it is not difficult to show that any maximal solution yields an $r$-approximation ratio. Hazan et al. [21] proved a nearly matching hardness bound: for any sufficiently large constant $r$, $r$-set packing is NP-hard to approximate within a factor of $\Omega (r∕logr)$. The same hardness result applies to the unit demand case of the SplitIntervalJob problem.

The unsplittable flow problem on the path (UFP) is another problem closely related to SplitIntervalJob. In this problem, we have a timeline divided into discrete timeslots and each timeslot is associated with a capacity. The input consists of a set of jobs each associated with a profit, a demand and an interval where it must be executed. The goal is to select the maximum profit subset of jobs such that at any timeslot, the cumulative demand of the selected jobs does not exceed the capacity available at the timeslot. In contrast to SplitIntervalJob, the problem allows for the capacity to vary across the timeslots, but each job consists of a single task. The UFP problem with uniform capacities corresponds to the special case of the SplitIntervalJob problem with $r=1$. A long line of work has studied the UFP problem and its special cases (e.g., [22], [23], [24], [25], [26], [27], [28]). In particular, for the non-uniform capacity setting, quasi-polynomial time approximation schemes [23] and polynomial time $(2+ϵ)$-approximation algorithms (for any $ϵ>0$) [22] have been designed. The concept of windows has also been considered in the context of UFP. A $5$-approximation algorithm is known for the uniform capacity setting [25]. For the non-uniform capacity setting, logarithmic approximation ratios have been derived [29] and constant factor algorithms available under certain (no-bottleneck) assumption on the demands [30], [31].

Proof Techniques. As mentioned earlier, Bar-Yehuda et al. [3] presented a $2r$-approximation algorithm for the unit demand case of the SplitIntervalJob problem. Their approach was to formulate a natural linear program and obtain the fractional optimum LP solution. The solution was then rounded using the fractional local ratio technique. At the heart of the rounding procedure is an interesting combinatorial lemma that provides an ordering of the jobs satisfying the following useful property. They showed that for any job $J$ in the above ordering, the sum of LP values assigned to jobs conflicting with $J$ and appearing to the right of $J$ is at most $2r$. Based on this lemma, they showed how to get an integral solution within a factor of $2r$ of the optimum. Bar-Yehuda and Rawitz [24] showed that the above combinatorial lemma can be suitably extended, when the demands of all the tasks within the same job are uniform. Then they combined the extended lemma with the fractional local ratio technique and derived a $6r$-approximation algorithm for the uniform demand case.

It is not clear how to find such a special ordering for the general case of non-uniform task demands; this seems to be non-trivial. We adopt a different approach that only requires the natural ordering of the tasks that goes by the start times. The approach is based on a simple randomized rounding strategy inspired from similar algorithms for the UFP problem [28] and $r$-sparse PIP [19]. Recall that UFP admits only a single task per job and $r$-sparse PIP allows for tasks to be only a single timeslot long. We adapt the techniques from the above work to the generic SplitIntervalJob problem, wherein jobs can have multiple tasks and the tasks can be arbitrarily long. The strategy also provides simpler alternative algorithms for dealing with the unit and uniform demand cases, as against the fractional local ratio technique employed in prior work. Generalizing the combinatorial lemma suitably for the case of non-uniform heights so as to apply the fractional local ratio technique is left as an interesting open question.

In the case of SplitIntervalJob problem with windows, the natural LP has an exponential number of variables and so, it cannot be solved directly. We address this issue by considering the dual of the LP and devise a separation oracle for the dual. The rounding procedures are similar to that of the basic version without windows.

Organization. Section 2 deals with the basic SplitIntervalJob problem without windows. We first develop a randomized $O\left(r\right)$-approximation algorithm for the case of small tasks and then, provide a sketch for the unit and uniform demand cases. The algorithms are derandomized in the subsequent section. This is followed by discussion on the integrality gap and hardness results. Section 5 generalizes the approximation algorithms for the SplitIntervalJob problem with windows.