Select and Permute: An Improved Online Framework for Scheduling to Minimize Weighted Completion Time

TL;DR

This paper presents a new online scheduling framework that leverages offline approximation algorithms to achieve improved competitive ratios for minimizing weighted completion time across various complex models.

Contribution

It introduces a novel online framework based on offline algorithms, enhancing competitive ratios for multiple scheduling problems and including a randomized variant for further improvements.

Findings

Achieved best known competitive ratios for concurrent open shop, coflow, and cluster models.

Developed a randomized framework that further improves competitive ratios.

Demonstrated the framework's versatility across different scheduling scenarios.

Abstract

In this paper, we introduce a new online scheduling framework for minimizing total weighted completion time in a general setting. The framework is inspired by the work of Hall et al. [Mathematics of Operations Research, Vol 22(3):513-544, 1997] and Garg et al. [Proc. of Foundations of Software Technology and Theoretical Computer Science, pp. 96-107, 2007], who show how to convert an offline approximation to an online scheme. Our framework uses two offline approximation algorithms (one for the simpler problem of scheduling without release times, and another for the minimum unscheduled weight problem) to create an online algorithm with provably good competitive ratios. We illustrate multiple applications of this method that yield improved competitive ratios. Our framework gives algorithms with the best or only known competitive ratios for the concurrent open shop, coflow, and concurrent cluster models. We also introduce a randomized variant of our framework based on the ideas of Chakrabarti et al. [Proc. of International Colloquium on Automata, Languages, and Programming, pp. 646-657, 1996] and use it to achieve improved competitive ratios for these same problems.

Equations

$$\sum _{j\in S}{w}_j{C}_j^{{\mathcal{O}\mathcal{P}\mathcal{T}}_0(S)}\le \sum _{j\in S}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}(S)}.$$

$$\sum _{j\in S_k}{w}_j{\delta }_j\le \gamma \sum _{j\in S_k}{w}_j{C}_j^{{\mathcal{O}\mathcal{P}\mathcal{T}}_0(S_k)}\le \gamma \sum _{j\in S_k}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}(S_k)}.$$

$$\sum _{j\in J}{w}_j{\delta }_j\le \gamma \sum _{j\in J}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}}.$$

$$\sum _{k=1}^L\sum _{j\in S_k}{w}_j{\delta }_j\le \gamma \sum _{k=1}^L\sum _{j\in S_k}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}(S_k)}\le \gamma \sum _{j\in J}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}},$$

$$\sum _{j\in J}{w}_j{C}_j^{\mathcal{A}}$$

$$=\alpha \sum _{k=2}^L({\tau }_k-{\tau }_{k-1})W_{\alpha {\tau }_k}^{\mathcal{A}}+\alpha W_{\alpha {\tau }_1}^{\mathcal{A}}+\sum _{j\in J}{w}_j{\delta }_j$$

$$\le 2\alpha \sum _{k=1}^L({\tau }_k-{\tau }_{k-1})W_{\alpha {\tau }_{k+1}}^{\mathcal{A}}+\alpha W+\sum _{j\in J}{w}_j{\delta }_j$$

$$\le 2\alpha \beta \sum _{k=1}^L({\tau }_k-{\tau }_{k-1})W_{{\tau }_k}^{\mathcal{O}\mathcal{P}\mathcal{T}}+\alpha W+\sum _{j\in J}{w}_j{\delta }_j$$

$$\le (2\alpha \beta +\gamma )\sum _{j\in J}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}}+\alpha W,$$

$$\displaystyle\sum_{j\in J}w_{j}(1-x_{j})\$$

$$\sum _{j\in J}{p}_{ij}{x}_j\le D\forall i\in M$$

$$x_j\in \{0,1\}\forall j\in J.$$

$$\sum _{j\in J}{w}_j{C}_j^{{\mathcal{A}}^{\prime }}\le 2\alpha \beta \sum _{k=1}^L({\tau }_k-{\tau }_{k-1})W_{{\tau }_k}^{\mathcal{O}\mathcal{P}\mathcal{T}}+\alpha W+\sum _{j\in J}{w}_j{\delta }_j.$$

$$\sum _{k=1}^L({\tau }_k-{\tau }_{k-1})W_{{\tau }_k}^{\mathcal{O}\mathcal{P}\mathcal{T}}=\sum _{j\in J}{w}_j{B}_j.$$

$$E[\sum _{j\in J}{w}_j{C}_j^{{\mathcal{A}}^{\prime }}]\le (\frac{1}{\ln 2}\alpha \beta +\gamma )\sum _{j\in J}{w}_j{C}_j^{\mathcal{O}\mathcal{P}\mathcal{T}}+\alpha W.$$

$$\sum _{j\in J}{w}_j(1-x_j)$$

$$\sum _{j\in J}\frac{P_{ji}}{m_i}{x}_j\le D\forall i\in M$$

$$B_{ji}{x}_j\le D\forall j\in J,i\in M$$

$$0\le x_j\le 1\forall j\in J.$$

$$C(S,j)=C(S\setminus \{j\},i)+w_j\underset{k\in M}{\max }\sum _{q\in S}{p}_{kq}.$$

$$\sum _{j\in J}{w}_j{x}_j$$

$$\sum _{j\in J}{p}_{ij}{x}_j\le s_i\forall i\in M$$

$$x_j\in \{0,1\},\forall j\in J.$$

$$OPT(j-1,\widehat{s_1},\widehat{s_2},\dots ,\widehat{s_m})$$

$$\max \{$$

$$w_j+OPT(j-1,\widehat{s_1}-\widehat{p_{1j}},\widehat{s_2}-\widehat{p_{2j}},\dots ,\widehat{s_m}-\widehat{p_{mj}})\}$$

$$\sum _{j\in S}{p}_{ij}$$

$$=\sum _{j\in S}\overline{p_{ij}}+\sum _{j\in S}(p_{ij}-\overline{p_{ij}})$$

$$\le \sum _{j\in S}\overline{p_{ij}}+n\cdot b_i$$

$$\le \overline{s_i}+n\cdot b_i$$

$$\le s_i+b_i+n\cdot b_i$$

$$=s_i+(n+1)\cdot \frac{ϵ}{n+1}{s}_i$$

$$=(1+ϵ)s_i.$$

Full text

We illustrate multiple applications of this method that yield improved competitive ratios. Our framework gives algorithms with the best or only-known competitive ratios for the concurrent open shop, coflow, and concurrent cluster models. We also introduce a randomized variant of our framework based on the ideas of Chakrabarti et al. [3] and use it to achieve improved competitive ratios for these same problems.

1 Introduction

Modern computing frameworks such as MapReduce, Spark, and Dataflow have emerged as essential tools for big data processing and cloud computing. To exploit large-scale parallelism, these frameworks act in several computation stages, which are interspersed with intermediate data transfer stages. During data transfer, results from computations must be efficiently scheduled for transfer across clusters so that the next computation stage can begin.

The coflow model [5, 6] and the concurrent cluster model [13, 19] were introduced to capture the distributed processing requirements of jobs across many machines. In these models, the objective of primary theoretical and practical interest is to minimize average job completion time [1, 5, 6, 14, 19, 20]. The concurrent open shop problem, a special case of the above models, has emerged as a key subroutine for designing better approximation algorithms [1, 14, 19].

There has been a lot of work studying offline algorithms for these problems (see [1, 14, 20] for the coflow model, [19] for the concurrent cluster model, and [4, 9, 18, 23] for the concurrent open shop model), but in real-world applications, jobs often arrive in an online fashion, so studying online algorithms is critical for accurate modeling of data centers.

Hall et al. [11] proposed a general framework which converts offline scheduling algorithms to online ones. Inspired by this result, we introduce a new online framework that improves upon the online algorithms of Garg et al. [9] for concurrent open shop and also gives the first algorithms with constant competitive ratios for other multiple-machine scheduling settings.

1.1 Formal Problem Statement

In the concurrent open shop setting, the problem is to schedule a set of jobs with machine-dependent components on a set of machines. Let $J=\{1,\ldots,n\}$ denote the set of jobs and $M=\{1,\ldots,m\}$ denote the set of machines. Each job $j$ has one component for each of the $m$ machines. For each job $j$, we denote the processing time of the component on machine $i$ as $p_{ij}$, its release time as $r_{j}$, and its weight as $w_{j}$. The different components of each job can be processed concurrently and in any order, as long as no component of job $j$ is processed before $r_{j}$. Job $j$ is complete when all of its components have been processed; we denote its completion time by $C_{j}$. Our goal is to specify a schedule of the jobs on the machines that minimizes $\sum_{j\in J}w_{j}C_{j}$; see Fig. 1 for an example.

We follow the 3-field $\alpha\,|\beta|\,\gamma$ notation (see [10]) for scheduling problems, where $\alpha$ denotes the scheduling environment, $\beta$ denotes the job characteristics, and $\gamma$ denotes the objective function. As stated above, we focus on the case where $\gamma=\sum_{j}{w_{j}C_{j}}$. In accordance with the notation of [11, 18, 19], we let $\alpha=PD$ denote the concurrent open shop setting and $\alpha=CC$ denote the concurrent cluster setting, see below for definitions.

1.2 Related Work

The concurrent open shop model is a relaxation of the well-known open shop model that allows components of the same job to be processed in parallel on different machines. Roemer [21] showed that $PD\,||\,\sum_{j}w_{j}C_{j}$ is NP-hard and after several successive approximation hardness results [2, 18], Sachdeva and Saket [22] showed that it is not approximable within a factor less than $2$ unless P = NP, even when job release times are identical. For this model, Wang and Cheng [23] gave a $\frac{16}{3}$-approximation algorithm. This was later improved to a 2-approximation for identical job release times [4, 9, 15, 18], matching the above lower bound, and a 3-approximation for arbitrary job release times [1, 9, 15].

In the online setting, Hall et al. [11] introduced a general framework that improved the best-known approximation guarantees for several well-studied scheduling environments. They showed that the existence of an offline dual $\rho$-approximation yields an online $4\rho$-approximation, where a dual $\rho$-approximation is an algorithm that packs as much weight of jobs into a time interval of length $\rho D$ as the optimal algorithm does into an interval of length $D$. Furthermore, they showed that when $m=1$, a local greedy ordering of jobs yields further improvements. While the framework of Hall et al. [11] is entirely deterministic, Chakrabarti et al. [3] gave a randomized variant with an improved competitive ratio guarantee. Specifically, they showed a dual-$\rho$ approximation algorithm can be converted to an expected $2.89\rho$-competitive online scheduling algorithm in the same setting, improving upon the $4\rho$ competitive ratio of Hall et al. [11].

The online version of $PD\,||\,\sum_{j}w_{j}C_{j}$ was first studied by Garg et al. [9]. They noted that applying the framework of [11] was not straightforward, so they focused on minimizing the weight of unscheduled jobs rather than maximizing the weight of scheduled jobs. Using a similar approach to that of Hall et al. [11], they gave an exponential-time 4-competitive algorithm and a polynomial-time 16-competitive algorithm for the online version of $PD\,||\,\sum_{j}w_{j}C_{j}$.

The coflow scheduling model was first introduced as a networking abstraction to model communications in datacenters [5, 6]. In the coflow scheduling problem, the goal is to schedule a set of coflows on a non-blocking switch with $m$ input ports and $m$ output ports, where any unused input-output ports can be connected via a path through unused nodes regardless of other existing paths. Each coflow is a collection of parallel flow demands that specify the amount of data that needs to be transferred from an input port to an output port.

For $\mbox{Coflow}\,|r_{j}=0|\,\sum_{j}{w_{j}C_{j}}$, Qiu et al. [20] gave deterministic $\frac{64}{3}$ and randomized $(8+\frac{16\sqrt{2}}{3})$ approximation algorithms. For arbitrary release times, they gave deterministic $\frac{67}{3}$ and randomized $9+\frac{16\sqrt{2}}{3}$ approximation algorithms. Khuller and Purohit [14] later improved these deterministic approximations to 8 and 12 for identical and arbitrary release times respectively, and also gave a randomized $(3+2\sqrt{2})$-approximation algorithm for identical release times. Recently, Ahmadi et al. [1] gave a deterministic 4-approximation and 5-approximation for identical and arbitrary release times, respectively. To the best of our knowledge, there are no known constant-factor competitive algorithms for online coflow scheduling, although Li et al. [16] have given a $O(n\ln m)$-competitive algorithm when all coflow weights are equal to 1.

Finally, we mention the concurrent cluster model recently introduced by Murray et al. [19]. The concurrent cluster model generalizes the concurrent open shop model by replacing each machine by a cluster of machines, where different machines in the same cluster may have different processing speeds. Each job still has $m$ processing requirements, but this requirement can be fulfilled by any machine in the corresponding cluster. Murray et al. [19] give the first constant-factor approximations for minimizing total weighted completion time via a reduction to concurrent open shop and a list-scheduling subroutine.

1.3 Paper Outline and Results

In Sect. 2, we introduce a general framework for designing online scheduling algorithms for minimizing total weighted completion time. The framework divides time into intervals of geometrically-increasing size, and greedily “packs” jobs into each interval, and then imposes a locally-determined ordering of the jobs within each interval. It is inspired by the framework of Hall et al. [11] and an adaptation by Garg et al. [9].

In Sect. 3, we apply our framework to $PD\,||\,\sum_{j}w_{j}C_{j}$. We show that an offline exponential-time algorithm that optimally solves $PD\,|r_{j}=0|\,\sum_{j}w_{j}C_{j}$ yields an exponential-time 3-competitive algorithm for $PD\,||\,\sum_{j}w_{j}C_{j}$. We also combine the algorithms given by Garg et al. [9] and Mastrolilli et al. [18] to create a polynomial-time 10-competitive algorithm for $PD\,||\,\sum_{j}w_{j}C_{j}$. We conclude Sect. 3 by giving a polynomial-time $(3+\epsilon)$-competitive algorithm when the number of machines $m$ is fixed.

In Sect. 4, extending the ideas of Sect. 3, we apply our framework to online coflow scheduling to design an exponential-time 6-competitive algorithm, and a polynomial-time 12-competitive algorithm.

Section 5, describes an extension of techniques of Chakrabarti et al. [3] that produces a randomized variant of our framework that yields better competitive ratio guarantees than the deterministic version. Section 6 describes the concurrent cluster model of Murray et al. [19]; we show that extending subroutines used for the concurrent open shop setting yields an online 19-competitive algorithm via our framework. Sections 7 and 8 describe the subroutines used in Sect. 3.

A summary of online approximation guarantees and the best-known previous results, where $m$ denotes the number of machines, $\epsilon$ is arbitrarily small, and “-” indicates the absence of a relevant result. The two numbers in each entry of the “Our ratios” column denote the competitive and expected ratio of our deterministic and randomized algorithms, respectively.

Problem

Running time

Our ratios

Previous ratio

$PD\,||\,\sum_{j}{w_{j}C_{j}}$

polynomial

10, 7.78

16 [9]

$PD\,||\,\sum_{j}{w_{j}C_{j}}$

exponential

3, 2.45

4 [9]

$PD\,||\,\sum_{j}{w_{j}C_{j}}$

polynomial, fixed $m$

$3+\epsilon$, $2.45+\epsilon$

$\mbox{Coflow}\,||\,\sum_{j}{w_{j}C_{j}}$

polynomial

12, 9.78

$\mbox{Coflow}\,||\,\sum_{j}{w_{j}C_{j}}$

exponential

6, 5.45

$CC\,||\,\sum_{j}{w_{j}C_{j}}$

polynomial

19, 14.55

2 A Minimization Framework for Online Scheduling

In this section, we introduce our framework for online scheduling problems. To motivate the key ideas of this section, we begin by briefly reviewing the work of Hall et al. [11] and Garg et al. [9].

2.1 The maximization framework of Hall et al. [11]

The framework of Hall et al. [11] divides the online problem into a sequence of offline maximum scheduled weight problems, each of which is solved using an offline dual approximation algorithm.

Definition 1** (Maximum scheduled weight problem (MSWP) [11]).**

Given a set of jobs, a non-negative weight for each job, and a deadline $D$, construct a schedule that maximizes the total weight of jobs completed by time $D$.

Definition 2** (Dual $\rho$-approximation algorithm [11]).**

An algorithm for the MSWP is a dual $\rho$-approximation algorithm if it constructs a schedule of length at most $\rho D$ and has total weight at least that of the schedule which maximizes the weight of jobs completed by $D$.

Fix a scheduling environment and suppose we have a dual $\rho$-approximation for the MSWP. We divide time into intervals of geometrically-increasing size by letting $t_{0}=0$ and $t_{k}=2^{k-1}$ for $k=1,\ldots,L$ where $L$ is large enough to cover the entire time horizon. At each time $t_{k}$, let $R(t_{k})$ denote the set of jobs that have arrived by $t_{k}$ but have not yet been scheduled. We run the dual $\rho$-approximation algorithm on $R(t_{k})$ with deadline $D=t_{k+1}-t_{k}=t_{k}$. In the output schedule, we take only jobs which complete by $\rho D$ and schedule them in the interval starting at time $\rho t_{k}$. Hall et al. [11] show that this framework produces an online $4\rho$-competitive algorithm.

2.2 The minimum unscheduled weight problem of Garg et al. [9]

Garg et al. [9] sought to apply the framework of Hall et al. [11] to the concurrent open shop setting. They noted that devising a dual-$\rho$ approximation algorithm for concurrent open shop was difficult, so they instead proposed a variant of the MSWP. The definitions below generalize those used by Garg et al. [9] to arbitrary scheduling problems.

Definition 3** (Minimum unscheduled weight problem (MUWP)).**

Given a set of jobs, a non-negative weight for each job, and a deadline $D$, find a subset of jobs $S$ which can be completed by time $D$ and minimizes the total weight of jobs not in $S$. We call this quantity the unscheduled weight.

Definition 4** ($(\alpha,\beta)$-approximation algorithm).**

An algorithm for the MUWP is an $(\alpha,\beta)$-approximation if it finds a subset of jobs which can be completed by $\alpha D$ and has unscheduled weight at most $\beta$ times that of the subset of jobs with minimum unscheduled weight that completes by $D$.

Note that a dual $\rho$-approximation for the MSWP is a $(\rho,1)$-approximation for the MUWP. With these definitions, Garg et al. [9] established constant-factor approximations for $PD\,||\,\sum_{j}{w_{j}C_{j}}$.

2.3 A minimization framework

We now describe a new framework inspired by the ideas of Hall et al. [11] and Garg et al. [9]. For the settings we consider, previous online algorithms do not impose any particular ordering of jobs within each interval, which can lead to schedules with poor local performance. In our framework, we combine an $(\alpha,\beta)$-approximation algorithm for MUWP and a $\gamma$-approximation to the offline version of the scheduling problem with identical release times to address this issue. Our framework generalizes and merges some of the ideas of Garg et al. [9] and Hall et al. [11] so that it can be applied to a broader class of scheduling problems and only requires blackbox access to approximation algorithms for simpler problems.

As in the works of Hall et al. [11] and Garg et al. [9], we assume that all processing times are at least 1. This is to avoid the extreme scenario that a single job of size $\epsilon\ll 1$ arrives just after time 0, and our framework waits until time 1 to schedule, thus leading to arbitrarily large competitive ratio.

Let $W$ denote the total weight of all the jobs in $J$, and let $W_{\tau}^{\mathcal{A}}$ ($W_{\tau}^{\mathcal{OPT}}$) denote the total weight of jobs that complete after time $\tau$ by our algorithm $\mathcal{A}$ (by the optimal algorithm $\mathcal{OPT}$). Note that $W_{\tau}^{\mathcal{A}},W_{\tau}^{\mathcal{OPT}}$ include the weight of jobs not yet released at time $\tau$. Let $\tau_{0}=0$, and for $k\geq 1$, let $\tau_{k}=2^{k-1}$, $I_{k}$ denote the $k^{\text{th}}$ interval $[\tau_{k},\tau_{k+1})$, $\alpha I_{k}$ denote $[\alpha\tau_{k},\alpha\tau_{k+1})$, and $R(\tau_{k})$ denote the set of jobs released but not yet scheduled before $\tau_{k}$ by $\mathcal{A}$.

Our online algorithm $\mathcal{A}$ works as follows. At each $\tau_{k}$, run an $(\alpha,\beta)$-approximation algorithm on $R(\tau_{k})$ with deadline $D=\tau_{k+1}-\tau_{k}$. Schedule the output set of jobs in $\alpha I_{k}$ using the offline $\gamma$-approximation algorithm.222We make the critical assumption that the offline $\gamma$-approximation algorithm does not increase the makespan of the given subset of jobs, so as to ensure that the schedule fits inside of $\alpha I_{k}$. For the scheduling models studied in this paper, this assumption will indeed hold. In fact, if it can be shown that the $\gamma$-approximation algorithm also approximates the makespan criteria within some factor $\mu$, then it is straightforward to incorporate this into the model, at the expense of an additional $\mu$ factor in the approximation guarantee. For example, Chakrabarti et al. [3] provide bicriteria approximation algorithms for the total weighted completion time and makespan objective functions.

Theorem 1**.**

Algorithm $\mathcal{A}$ is $(2\alpha\beta+\gamma)$-competitive, with an additive $\alpha W$ term.

To prove Theorem 1, we first show that at each time step, $\mathcal{A}$ remains competitive with the optimal schedule by incurring a time delay.

Lemma 1**.**

For any $k\geq 0$, we have $W^{A}_{\alpha\tau_{k+1}}\leq\beta W^{\mathcal{OPT}}_{\tau_{k}}$ .

Proof.

Every job completed by $\mathcal{OPT}$ by $\tau_{k}$ must have been released before $\tau_{k}$. For each such job $j$, either our algorithm completed it before time $\tau_{k}$ or $j\in R(\tau_{k})$. The set of jobs completed by $\mathcal{OPT}$ by time $\tau_{k}$ gives a feasible solution to the MUWP with deadline $D=\tau_{k+1}-\tau_{k}=\tau_{k}$ and its total unscheduled weight is $W^{\mathcal{OPT}}_{\tau_{k}}$. Therefore, the optimal total unscheduled weight value for the MUWP when considering all $j\in R(\tau_{k})$ with deadline $D$ is at most $W^{\mathcal{OPT}}_{\tau_{k}}$. By the definition of $(\alpha,\beta)$-approximation, the claim follows. ∎

The next lemma states that ordering jobs within each interval further approximates the optimal schedule closely. For a fixed subset $S$ of jobs, let $\mathcal{OPT}(S)$ denote the optimal schedule for $S$ and $C^{\mathcal{OPT}(S)}_{j}$ denote the completion time of job $j$ in $\mathcal{OPT}(S)$. Also, let $\mathcal{OPT}_{0}(S)$ denote an optimal schedule that starts at time 0 and ignores all job release times, and let $C^{\mathcal{OPT}_{0}(S)}_{j}$ denote the completion time of job $j$ in $\mathcal{OPT}_{0}(S)$.

Lemma 2**.**

The weighted completion time for schedule $\mathcal{OPT}_{0}(S)$ is at most that of schedule $\mathcal{OPT}(S)$; i.e.,

[TABLE]

Proof.

The optimal schedule of $S$ with release times defines a valid schedule for $S$ without release times, so the claim follows. ∎

Recall that at each $\tau_{k}$, $\mathcal{A}$ uses an $(\alpha,\beta)$-approximation on the MUWP to select a subset $S_{k}$ of $R(\tau_{k})$ to schedule within $\alpha I_{k}$ using a $\gamma$-approximation that ignores release times. Let $C_{j}^{\mathcal{A}}$ denote the completion time of job $j$ in the schedule produced by $\mathcal{A}$, $t(j)$ denote the largest index such that job $j$ begins processing after time $\tau_{t(j)}$, and $\delta_{j}=C_{j}^{\mathcal{A}}-\alpha\tau_{t(j)}$ for each job $j\in J$ (see Fig. 2). Let $L$ be the smallest time index such that the optimal schedule finishes by time $\tau_{L}$, and let $S_{k}$ denote the set of jobs scheduled independently by $\mathcal{A}$ in the interval $\alpha I_{k}$. Then Lemma 2 implies

[TABLE]

Lemma 3**.**

The weighted sum of the $\delta_{j}$ is at most $\gamma$ times the optimal weighted completion time; i.e.,

[TABLE]

Proof.

Recall that $S_{1},\ldots,S_{L}$ partition $J$, and notice that due to (1), we have

[TABLE]

thus proving the lemma. ∎

Proof of Theorem 1.

We rewrite the total weighted completion time of the schedule produced by $\mathcal{A}$ to obtain the following.

[TABLE]

where the last two inequalities follow from Lemmas 1 and 3, respectively. ∎

3 Applications to Concurrent Open Shop

Now we apply our minimization framework to $PD\,||\,\sum_{j}{w_{j}C_{j}}$. In Section 7, we give an offline dynamic program that optimally solves $PD\,|r_{j}=0|\,\sum_{j}w_{j}C_{j}$ in exponential time, giving $\gamma=1$ in our framework.

For the MUWP, in exponential time, we can iterate over every subset of jobs to find a feasible schedule that minimizes the total weight of unscheduled jobs, so this is a $(1,1)$-approximation, giving $\alpha=\beta=1$. Thus, Theorem 1 yields the following, which improves upon the competitive ratio of 4 from Garg et al. [9].

Corollary 1**.**

There exists an exponential time 3-competitive algorithm for the concurrent open shop setting.

In polynomial time, Garg et al. [9] provide a $(2,2)$-approximation for the MUWP, and Mastrolilli et al. [18] provide a 2-approximation for offline version of $PD\,|r_{j}=0|\,\sum_{j}w_{j}C_{j}$. These results with Theorem 1 improve the ratio of 16 by Garg et al. [9]. We note that the additional additive term of $\alpha W$ in Theorem 1 is smaller than the additive $3W$ term in the guarantees of Garg et al. [9], for both the exponential-time and polynomial-time cases.

Corollary 2**.**

There exists a polynomial-time 10-competitive algorithm for the concurrent open shop setting.

When the number of machines $m$ is constant, there exists a polynomial-time $(1+\epsilon,1)$-approximation algorithm for the MUWP (see Section 8) by a reduction to the multidimesional knapsack problem. Furthermore, when $m$ is fixed, Cheng et al. [7] gave a PTAS for the offline $PD\,|r_{j}=0|\,\sum_{j}w_{j}C_{j}$. Combining these results with Theorem 1 yields the following.

Corollary 3**.**

There exists a polynomial time, $(3+\epsilon)$-competitive algorithm for $PD\,||\,\sum{w_{j}C_{j}}$ when the number of machines is fixed.

4 Applications to Coflow Scheduling

We now apply our framework to coflow scheduling, introduced by Chowdhury and Stoica [5]. We are given a non-blocking network with $m$ input ports and $m$ output ports. A coflow is a collection of parallel flows processed by the network. We represent a coflow $j$ by an $m\times m$ matrix $D^{j}=(d_{io}^{j})_{i,o\in[m]}$, where $d_{io}^{j}$ denotes the integer amount of data to be transferred from input port $i$ to output port $o$ for coflow $j$. Each port can process at most one unit of data per time unit, and we assume that the transfer of data within the network is instantaneous.

The problem is to schedule a set of $n$ coflows, each with a non-negative weight $w_{j}$ and release time $r_{j}$, that minimizes the sum of weighted completion times, where the completion time of a coflow is the earliest time at which all of its flows have been processed. We denote this problem by $\mbox{Coflow}\,||\,\sum_{j}{w_{j}C_{j}}$.

As in Sect. 3, in exponential time, we can iterate over all subsets of coflows to optimally solve the MUWP, giving a $(1,1)$-approximation. Moreover, Ahmadi et al. [1] proposed a 4-approximation for offline coflow scheduling333Since permutation schedules are not necessarily optimal for coflow scheduling [6], even finding a factorial-time optimal algorithm is nontrivial. For simplicity, we have chosen to use a polynomial-time algorithm to achieve Corollary 4..

Corollary 4**.**

There exists an exponential-time $6$-competitive algorithm for online coflow scheduling.

Furthermore, we can show that the polynomial-time $(2,2)$-approximation for the MUWP for $PD\,||\,\sum_{j}{w_{j}C_{j}}$ of Garg et al. [9] can be applied to coflow scheduling with the same approximation guarantees. Combined with the $4$-approximation of Ahmadi et al. [1], our framework yields the following.

Corollary 5**.**

There exists a polynomial-time $12$-competitive algorithm for online coflow scheduling.

To show that the $(2,2)$-approximation for the MUWP for $PD\,||\,\sum_{j}{w_{j}C_{j}}$ of Garg et al. [9] can be applied to coflow scheduling with the same approximation guarantees, we recall the reduction from $\mbox{Coflow}\,||\,\sum_{j}{w_{j}C_{j}}$ to $PD\,||\,\sum_{j}{w_{j}C_{j}}$ given by Khuller and Purohit [14]. Given an instance of coflow scheduling $\mathcal{I}$, let $L_{i}^{j}=\sum_{o=1}^{m}d_{io}^{j}$ denote the total amount of data that co-flow $j$ needs to transmit through input port $i$, and similarly, we let $L_{o}^{j}=\sum_{i=1}^{m}d_{io}^{j}$ or output port $o$. From this, create a concurrent open shop instance $\mathcal{I}^{\prime}$ with a set $M$ of $2m$ machines (one for each port) and a set $J$ of $n$ jobs (one for each coflow), with processing times $p_{sj}$ set equal to $L^{j}_{s}$ for job $j$ on machine $s$.

Now, the MUWP on $\mathcal{I}^{\prime}$ can be formulated by the following integer program of Garg et al. [9].

[TABLE]

Let $W^{\prime}$ denote the optimal unscheduled weight for the MUWP on $\mathcal{I}^{\prime}$, and define $W$ similarly. The algorithm of Garg et al. [9] solves the linear relaxation of this integer program to obtain an optimal fractional solution $\bar{x}$, and outputs the set of jobs $S^{\prime}=\{j\in J\mid\bar{x}_{j}\geq\frac{1}{2}\}$. Letting $W^{*}$ denote the objective function value of an optimal solution of the LP relaxation, it is straightforward to check that the total processing time of $S^{\prime}$ on any machine is at most $2D$, the total unscheduled weight is at most $2W^{*}$, and $W^{*}\leq W^{\prime}$. Hence, the algorithm of Garg et al. [9] is indeed a $(2,2)$-approximation for the MUWP in the concurrent open shop environment.

Lemma 4**.**

The optimal unscheduled weight for the MUWP on $\mathcal{I}^{\prime}$ is at most that for the MUWP on $\mathcal{I}$; i.e., $W^{\prime}\leq W\enspace.$

Proof.

The proof is essentially identical to that of Lemma 1 in [14]. Let $S$ be the optimal solution to the MUWP for $\mathcal{I}$. Then there exists a schedule of the coflows in $S$ such that every coflow completes by the deadline $D$. Now consider the set $S^{\prime}$ of corresponding jobs in $\mathcal{I}^{\prime}$. Processing job $j\in S^{\prime}$ on machine $s$ whenever data is being processed for coflow $j\in S$ on port $s$ in the schedule for $S$ gives a schedule for $S^{\prime}$ in which every job also completes by deadline $D$. Thus $S^{\prime}$ is a feasible solution to the MUWP for $\mathcal{I}^{\prime}$ with objective function value equal to that of the optimal solution $S$ to the MUWP for $\mathcal{I}$, and the claim follows. ∎

Let $S$ be the set of coflows in $\mathcal{I}$ corresponding to the jobs $S^{\prime}$ defined above.

Lemma 5**.**

In polynomial time, we can find a schedule for $S$ that completes by time $2D$, and whose total unscheduled weight is at most $2W$.

Proof.

We know that for any machine $s$ in $\mathcal{I}^{\prime}$, $\sum_{j\in S^{\prime}}p_{sj}=\sum_{j\in S}L_{s}^{j}\leq 2D$. Thus, if we take any schedule for the coflows $S$ without idle time, every port $s$ finishes processing data by time $\sum_{j\in S}L_{s}^{j}\leq 2D$. Since all coflows complete at the same time when all ports have finished processing the data, we get a schedule in which all coflows in $S$ will complete without idle time by time $2D$.

The total unscheduled weight in $\mathcal{I}$ is the same as the total unscheduled weight in $\mathcal{I}^{\prime}$. By Lemma 4, the total unscheduled weight in $\mathcal{I}$ is at most $2W^{\prime}\leq 2W$. ∎

Hence, the $(2,2)$-approximation for the MUWP for $PD\,||\,\sum_{j}{w_{j}C_{j}}$ of Garg et al. [9] can be applied to $\mbox{Coflow}\,||\,\sum_{j}{w_{j}C_{j}}$ with the same guarantees.

5 A Randomized Online Scheduling Framework

In this section, we show how our ideas can be combined with the randomized framework of Chakrabarti et al. [3] to develop an analogue of the deterministic framework of Sect. 2.

The framework of Chakrabarti et al. [3] modify that of Hall et al. [11] (see Sect. 2.1) by setting $\tau_{k}=\eta 2^{k}$, where $\eta\in[\frac{1}{2},1)$ is a randomly chosen parameter. After making this choice, the online algorithm proceeds exactly as before, by applying the dual $\rho$-approximation to the MSWP at each interval.

Let $C^{\mathcal{OPT}}_{j}$ denote the completion time of job $j$ in an optimal schedule, and let $B_{j}$ denote the start of the interval $(\tau_{k-1},\tau_{k}]$ in which job $j$ completes. Chakrabarti et al. [3] show that if one takes $\eta=2^{-X}$, where $X$ is chosen uniformly at random from $(0,1]$, then the following holds.

Lemma 6** ([3]).**

$E[B_{j}]=\frac{1}{2\ln 2}C^{\mathcal{OPT}}_{j}\enspace.$**

Hall et al. [11] showed how to produce a schedule of total weighted completion time at most $4\rho\sum_{j}w_{j}B_{j}$. By linearity of expectation, one can apply Lemma 6, so that the schedule produced has total weighted completion at most $\frac{2}{\ln 2}\rho\sum_{j}w_{j}C^{\mathcal{OPT}}_{j}$, resulting in a randomized $\frac{2}{\ln 2}\rho\leq 2.89\rho$-competitive algorithm.

We can directly adapt this idea of randomly choosing the interval end points in our minimization framework to develop a randomized version of Theorem 1. Specifically, we take $\tau_{k}=\eta 2^{k}$, using the same $\eta$ above, and run the framework described in Sect. 2.3 using this new choice of interval end points. Note that Lemma 1, Lemma 2, and Lemma 3 still hold with our new choice of $\tau_{k}$.

Let $\mathcal{A}^{\prime}$ denote this randomized algorithm and using the same notation as in Sect. 2.3, we can achieve the following result.

Theorem 2**.**

Algorithm $\mathcal{A}^{\prime}$ is $(\frac{1}{\ln 2}\alpha\beta+\gamma)$-competitive in expectation, with an additive $\alpha W$ term.

Proof.

The same steps as in the proof of Theorem 1 yield

[TABLE]

By definition of $B_{j}$, we notice that

[TABLE]

By linearity of expectation and Lemma 6, we conclude that

[TABLE]

∎

Using the guarantee of Theorem 2, we can instantiate this framework in various scheduling settings and find values for $\alpha,\beta,\gamma$ to achieve improved competitive ratios over our deterministic framework. The results obtained when applying the same subroutines as we did for the framework of Sect. 2.3 are summarized in Table 1.3.

6 Applications to Concurrent Cluster Scheduling

We now describe the concurrent cluster model introduced by Murray et al. [19] and give the first online algorithm in this setting. In the concurrent cluster model, there is a set $M$ of $m$ clusters, where each cluster $i\in M$ consists of a set of $m_{i}$ parallel machines. We are given a set of jobs $J$, where each job $j$ has $m$ subjobs, each corresponding to one of the clusters. Each subjob is specified by a set $T_{ji}$ of tasks to be completed by the machines in cluster $i$. Each task $t$ in $T_{ji}$ has a processing requirement of $p_{jit}$ time units. The subjobs of a given job may be processed concurrently across multiple clusters, and the tasks of a given subjob may be processed concurrently across multiple machines within the same cluster. A job is complete when all of its subjobs are complete, and a subjob is complete when all of its tasks are complete. A task can be completed by any machine within the cluster of that task. Furthermore, the speed of machines within a cluster may vary, but for our purposes, we assume that all of the machines in each cluster are identical. In the three field notation, we denote this by $CC\,|v=1|\,\sum_{j}w_{j}C_{j}$, where $v=1$ means the machines all have the same speed. The goal is to schedule the jobs to minimize total weighted completion time. Among other results for variants of this problem, Murray et al. [19] gave an offline 3-approximation algorithm when all subjobs have identical release times.

Here, we present a $(4,2)$-approximation for the MUWP in the concurrent cluster setting. Using this in conjunction with the offline 3-approximation algorithm of Murray et al. [19], our framework gives the following online guarantee.

Corollary 6**.**

There exists a polynomial time 19-competitive algorithm for scheduling in the concurrent cluster model.

Now recall that the MUWP is the following: given a set of jobs and a deadline $D$, find a subset of the jobs that can be completed by time $D$ and minimizes the total weight of unscheduled jobs. The concurrent cluster setting differs from the settings we have already seen because it is nontrivial to even decide if a given subset of jobs can be scheduled to complete by a certain deadline.

For each job $j$ and subjob $i$ of $j$, let $P_{ji}=\sum_{t\in T_{ji}}p_{jit}$ denote the total processing requirements of the $i$-th subjob of job $j$, and let $B_{ji}=\max_{t\in T_{ji}}p_{jit}$ denote the processing time of the largest task of subjob $i$ of job $j$. We can then formulate the following LP relaxation of MUWP, which is similar to the LP relaxation of Garg et al. [9] in the concurrent open shop setting:

[TABLE]

It is straightforward to see why this is a relaxation of the problem. Indeed, the first set of constraints requires that for each cluster $i$, the total processing time of all jobs in a feasible solution does not add up to more than the deadline. The second set of constraints requires that the largest task in each subjob can be completed on one machine by the deadline.

Lemma 7**.**

There exists a polynomial-time $(2,2)$-approximation to the above LP for the MUWP in the concurrent cluster model.

Proof.

The proof is similar to that of Garg et al. [9]. We can solve the LP in polynomial time to obtain an optimal solution $\bar{x}$, and return the set $S=\{j\in J\mid\bar{x}_{j}\geq\frac{1}{2}\}$. It follows that the total processing time of $S$ is at most $2D$ and the total weight of jobs not in $S$ is at most twice the value of the optimum solution $\bar{x}$ of the LP. ∎

Note that the set obtained from Lemma 7 does not necessarily have a schedule which completes by time $2D$ in the MUWP for the concurrent cluster model. However, if we relax the deadline further from $2D$ to $4D$, then we can guarantee the existence of such a schedule.

Lemma 8**.**

There exists a feasible schedule of the set $S$ from Lemma 7 that completes by time $4D$.

Proof.

On each cluster $i$, we apply the classical list scheduling algorithm for minimizing the makespan on a set of identical parallel machines. Thus, the makespan of cluster $i$ is at most $\sum_{j\in S}\frac{P_{ji}}{m_{i}}+\max_{j\in S}B_{ji}$. Furthermore, Lemma 7 implies that each of these terms is at most $2D$. So, the makespan of cluster $i$ is at most $4D$, and the lemma follows. ∎

Lemma 8 directly implies Corollary 6.

7 An optimal exponential-time offline algorithm for concurrent open shop

In this section, we present an offline exponential-time algorithm that optimally solves $PD\,|r_{j}=0|\,\sum{w_{j}C_{j}}$. The algorithm is based on the Held-Karp algorithm (see [12]) for the traveling salesperson problem.

First, we state a definition and a lemma that restricts the number of possible schedules.

Definition 5** ([18]).**

A schedule is a permutation schedule if it is nonpreemptive, contains no unnecessary idle time, and there exists a permutation of the jobs $\sigma:J\rightarrow J$ such that on every machine, the jobs are scheduled in the order specified by $\sigma$.

Next, we rephrase a lemma from [18] that allows us to restrict our attention to permutation schedules.

Lemma 9** ([18]).**

For any schedule for concurrent open shop with identical release times, there exists a corresponding permutation schedule in which the completion time of every job is no later than it is in the original schedule.

For any subset $S\subseteq J$ of jobs and job $j\in S$, let $C(S,j)$ denote the weighted completion time of the optimal schedule for $S$ that completes job $j$ last. If $S$ only contains one job $j$, then certainly there is only one feasible schedule, so we have that $C(S,j)=w_{j}\cdot\max_{i\in M}p_{ij}$. If $S$ contains at least two jobs, consider an optimal schedule for $S$ in which $j$ finishes last. Suppose job $i\in S\setminus\{j\}$ finishes second-to-last in this schedule. Since any contiguous subsequence of jobs in an optimal schedule is itself an optimal schedule for that subset of jobs,

[TABLE]

Algorithm 1 contains the pseudocode for this algorithm. Using standard backtracking techniques, one can obtain an optimal schedule using this dynamic program.

Theorem 3**.**

Algorithm 1 optimally solves the offline concurrent open shop with identical release times problem in $O(mn^{2}2^{n})$ time.

Proof.

The optimality of the algorithm follows from the above discussion, and we briefly sketch the running time bound.

There are $2^{n}$ subsets $S\subseteq J$ and $O(n)$ jobs $j\in S$, so there are $O(n\cdot 2^{n})$ subproblems $C(S,j)$. For each subproblem $C(S,j)$, the search over the possible penultimate jobs in Algorithm 1 takes $O(mn)$ time, giving a final running time of $O(mn^{2}2^{n})$. ∎

8 A polynomial-time $(1+\epsilon,1)$-approximation for MUWP in concurrent open shop when $m$ is fixed

In this section, we present a dual $(1+\epsilon)$-approximation algorithm for the MSWP for concurrent open shop. Recall that this is algorithm is also a $(1+\epsilon,1)$-approximation algorithm for the MUWP.

We can view the MSWP for concurrent open shop as a multidimensional version of the knapsack problem see  [8]. We briefly reformulate the maximum scheduled weight problem as a generalization of the knapsack problem. We are given a set $J$ of $n$ items (jobs) in $m$ dimensions (machines). Each job $j$ has a non-negative weight $w_{j}$, and a non-negative size $p_{ij}$ in the $i^{\text{th}}$ dimension, where $i\in M$. We have a single knapsack (set of machines) which has non-negative capacity $s_{i}$ in the $i^{\text{th}}$ dimension. For the maximum scheduled weight problem, the capacity for each dimension is the same, that is, $s_{1}=s_{2}=...=s_{m}=D$, where $D$ denotes the common deadline on every machine. We want to find a maximum-weight subset of items that can be packed into the knapsack without exceeding the knapsack capacity in any dimension.

This problem can be formulated as the following integer program $P$:

[TABLE]

Our dual $(1+\epsilon)$-approximation algorithm for $P$ runs a dynamic program on a scaled version $\widehat{P}$ of $P$, and returns the resulting set of jobs (see Hall et al. [11] for a similar approach when $m=1$). For every $i\in M,j\in J$, let $\widehat{p_{ij}}=\lfloor\frac{p_{ij}}{b_{i}}\rfloor$ and $\widehat{s_{i}}=\lceil\frac{s_{i}}{b_{i}}\rceil$, where $b_{i}=\frac{\epsilon}{n+1}s_{i}$, and substitute these values in $P$ to obtain the new integer program $\widehat{P}$. The weights of the jobs remain unchanged.

Next, we state a well-known dynamic program for the multidimensional knapsack problem and appy it to $\widehat{P}$. Let $OPT(j,\widehat{s_{1}},\widehat{s_{2}},\ldots,\widehat{s_{m}})$ denote the optimum value of $\widehat{P}$ when restricted to the items $\{1,\ldots,j\}$ and the knapsack has remaining capacity $\widehat{s_{i}}$ in dimension $i\in M$. Then $OPT(j,\widehat{s_{1}},\widehat{s_{2}},\ldots,\widehat{s_{m}})$ is equal to

[TABLE]

if $s_{i}<p_{ij}$ for some $i\in M$ and

[TABLE]

otherwise.

Lemma 10**.**

The above dynamic program runs in $O(m\left(\frac{n}{\epsilon}\right)^{m})$ time.

Proof.

Computing the optimal solution value $OPT(n,\widehat{s_{1}},\widehat{s_{2}},\ldots,\widehat{s_{m}})$ can be seen as filling a table of size $n\cdot\widehat{s_{1}}\cdot\ldots\cdot\widehat{s_{m}}$. Since each entry takes $O(m)$ time to compute, the lemma follows. ∎

Let $S$ denote the subset of jobs obtained from solving $\widehat{P}$.

Lemma 11**.**

The optimum value of $\widehat{P}$ is at least that of $P$. Furthermore, for every $i\in M$, the total size of the items in the $i$-th dimension of $S$ is at most $(1+\epsilon)s_{i}$.

Proof.

To obtain $\widehat{P}$ from $P$, we rounded the $p_{ij}$ down and $s_{i}$ up. Thus, every feasible solution of $P$ is feasible for $\widehat{P}$, so the first statement follows.

For every $i\in M$ and $j\in J$, let $\overline{s_{i}}=\widehat{s_{i}}\cdot b_{i}=\lceil\frac{s_{i}}{b_{i}}\rceil b_{i}$, and let $\overline{p_{ij}}=\widehat{p_{ij}}\cdot b_{i}=\lfloor\frac{p_{ij}}{b_{i}}\rfloor b_{i}$, so that $s_{i}+b_{i}\geq\overline{s_{i}}$ and $p_{ij}\leq\overline{p_{ij}}+b_{i}$. Then for each dimension $i\in M$,

[TABLE]

∎

Theorem 4**.**

The algorithm described above runs in $O((\frac{n}{\epsilon})^{m}m)$ time and is a dual $(1+\epsilon)$-approximation algorithm for the maximum scheduled weight problem in the concurrent open shop setting.

Proof.

The proof follows directly from Lemma 10 and Lemma 11. Note that this is a polynomial-time algorithm when $m$ is fixed. ∎

Acknowledgements. We would like to thank Sungjin Im and Clifford Stein for directing us to [3, 17], and William Gasarch for organizing the REU program.