Streaming Algorithms for Bin Packing and Vector Scheduling

TL;DR

This paper introduces the first efficient streaming algorithms for bin packing and vector scheduling, achieving near-optimal approximation ratios with small memory, suitable for massive data that cannot fit into memory.

Contribution

It presents novel streaming algorithms for fundamental combinatorial optimization problems with provably optimal or near-optimal space complexity and approximation guarantees.

Findings

Achieves a $(1+ ext{}\varepsilon)$-approximation for bin packing with $ ilde{O}(1/ ext{ ext}varepsilon)$ space.

Provides a $d+ ext{ ext}varepsilon$-approximation for vector bin packing in $d$ dimensions.

Constructs input summaries for vector scheduling with space $ ilde{O}(d^2 m / ext{ ext}varepsilon^2)$, preserving the optimum within a factor of $2 - 1/m + ext{ ext}varepsilon$.

Abstract

Problems involving the efficient arrangement of simple objects, as captured by bin packing and makespan scheduling, are fundamental tasks in combinatorial optimization. These are well understood in the traditional online and offline cases, but have been less well-studied when the volume of the input is truly massive, and cannot even be read into memory. This is captured by the streaming model of computation, where the aim is to approximate the cost of the solution in one pass over the data, using small space. As a result, streaming algorithms produce concise input summaries that approximately preserve the optimum value. We design the first efficient streaming algorithms for these fundamental problems in combinatorial optimization. For Bin Packing, we provide a streaming asymptotic $1+\varepsilon$-approximation with $\widetilde{O}\left(\frac{1}{\varepsilon}\right)$ memory, where $\widetilde{O}$ hides logarithmic factors. Moreover, such a space bound is essentially optimal. Our algorithm implies a streaming $d+\varepsilon$-approximation for Vector Bin Packing in $d$ dimensions, running in space $\widetilde{O}\left(\frac{d}{\varepsilon}\right)$. For the related Vector Scheduling problem, we show how to construct an input summary in space $\widetilde{O}(d^2\cdot m / \varepsilon^2)$ that preserves the optimum value up to a factor of $2 - \frac{1}{m} +\varepsilon$, where $m$ is the number of identical machines.

Equations

$$|\mathcal{S}|\le \text{OPT}(I_{\mathrm{R}})+\sigma \le (1+\epsilon )\cdot \text{OPT}(I_{\mathrm{B}})+\mathcal{O}\left(\log \frac{1}{\epsilon }\right)+\sigma \le (1+\epsilon )\cdot \text{OPT}(I)+\mathcal{O}\left(\log \frac{1}{\epsilon }\right)+\sigma ,$$

$$\text{ALG}(I)\le \frac{1+\epsilon }{1-\epsilon }\cdot \text{SIZE}(I)+1\le (1+3\epsilon )\cdot \text{OPT}(I)+1.$$

$$\text{SIZE}(I_{\mathrm{B}})>\sum _{j=0}^k\frac{N_j}{2^{j+1}}.$$

$$q_j=\mathcal{O}\left(\frac{1}{\delta }\cdot \log \delta N_j\right)=\mathcal{O}\left(\frac{1}{\epsilon }\cdot \log \left(\epsilon \cdot 2^{j+1}\text{OPT}(I_{\mathrm{B}})\right)\right)=\mathcal{O}\left(\frac{1}{\epsilon }\cdot \log \text{OPT}(I_{\mathrm{B}})\right),$$

$$\sigma \le \sum _{j=0}^{k-1}{q}_j=\sum _{j=0}^{k-1}\mathcal{O}\left(\frac{1}{\epsilon }\cdot \log \text{OPT}(I_{\mathrm{B}})\right)=\mathcal{O}\left(\frac{k}{\epsilon }\cdot \log \text{OPT}(I_{\mathrm{B}})\right)=\mathcal{O}\left(\frac{1}{\epsilon }\cdot \log \frac{1}{\epsilon }\cdot \log \text{OPT}(I_{\mathrm{B}})\right).$$

$$\sum _{j=0}^k\lceil \frac{4\delta N_j}{2^j}\rceil \le 4\cdot \frac{1}{8}\epsilon \cdot \sum _{j=0}^k\frac{N_j}{2^j}+k\le \frac{1}{2}\epsilon \cdot 2\cdot \text{SIZE}(I_{\mathrm{B}})+k\le \epsilon \cdot \text{OPT}(I_{\mathrm{B}})+k.$$

$$\sum _{j=0}^k\frac{4\delta N_j}{2^j}\le 4\cdot \frac{1}{8}\epsilon \cdot 2\cdot \sum _{j=0}^k\frac{N_j}{2^{j+1}}\le \epsilon \cdot \text{SIZE}(I_{\mathrm{B}}),$$

$$\mathrm{rank}(q)\le r\le \mathrm{rank}(q)+\epsilon \mathrm{rank}(q)+2\epsilon N+o(N).$$

$$\mathrm{Pr}[X>(1+\epsilon )\cdot \frac{1}{2\gamma }\cdot L_k^{\prime }]\le \exp \left(-\frac{1}{3}\cdot {\epsilon }^2\cdot \frac{1}{2\gamma }\cdot L_k^{\prime }\right).$$

$$\exp \left(-\frac{1}{3}\cdot {\epsilon }^2\cdot \frac{1}{2\gamma }\cdot L_k^{\prime }\right)\le \exp \left(-\Omega \left(\log \frac{d^2}{\epsilon }\right)\right)\le \frac{\epsilon }{d^2},$$

$$\mathbb{E}[G]\le \sum _{\mathbf{c}}\frac{\epsilon }{d}\cdot \Vert \mathbf{c}{\Vert }_1\le \frac{\epsilon }{d}\cdot m\cdot d=\epsilon \cdot m,$$

Full text

We design the first efficient streaming algorithms for these fundamental problems in combinatorial optimization. For Bin Packing, we provide a streaming asymptotic $1+\varepsilon$-approximation with $\widetilde{\mathcal{O}}\left(\frac{1}{\varepsilon}\right)$ memory, where $\widetilde{\mathcal{O}}$ hides logarithmic factors. Moreover, such a space bound is essentially optimal. Our algorithm implies a streaming $d+\varepsilon$-approximation for Vector Bin Packing in $d$ dimensions, running in space $\widetilde{\mathcal{O}}\left(\frac{d}{\varepsilon}\right)$. For the related Vector Scheduling problem, we show how to construct an input summary in space $\widetilde{\mathcal{O}}(d^{2}\cdot m/\varepsilon^{2})$ that preserves the optimum value up to a factor of $2-\frac{1}{m}+\varepsilon$, where $m$ is the number of identical machines.

1 Introduction

The streaming model captures many scenarios when we must process very large volumes of data, which cannot fit into the working memory. The algorithm makes one or more passes over the data with a limited memory, but does not have random access to the data. Thus, it needs to extract a concise summary of the huge input, which can be used to approximately answer the problem under consideration. The main aim is to provide a good trade-off between the space used for processing the input stream (and hence, the summary size) and the accuracy of the (best possible) answer computed from the summary. Other relevant parameters are the time and space needed to make the estimate, and the number of passes, which ideally should be equal to one.

While there have been many effective streaming algorithms designed for a range of problems in statistics, optimization, and graph algorithms (see surveys by Muthukrishnan [38] and McGregor [37]), there has been little attention paid to the core problems of packing and scheduling. These are fundamental abstractions, which form the basis of many generalizations and extensions [14, 13]. In this work, we present the first efficient algorithms for packing and scheduling that work in the streaming model.

A first conceptual challenge is to resolve what form of answer is desirable in this setting. If items in the input are too many to store, then it is also unfeasible to require a streaming algorithm to provide an explicit description of how each item is to be handled. Rather, our objective is for the algorithm to provide the cost of the solution, in the form of the number of bins or the duration of the schedule. Moreover, many of our algorithms can provide a concise description of the solution, which describes in outline how the jobs are treated in the design.

A second issue is that the problems we consider, even in their simplest form, are NP-hard. The additional constraints of streaming computation do not erase the computational challenge. In some cases, our algorithms proceed by adopting and extending known polynomial-time approximation schemes for the offline versions of the problems, while in other cases, we come up with new approaches. The streaming model effectively emphasizes the question of how compactly can the input be summarized to allow subsequent approximation of the problem of interest. Our main results show that in fact the inputs for many of our problems of interest can be “compressed” to very small intermediate descriptions which suffice to extract near-optimal solutions for the original input. This implies that they can be solved in scenarios which are storage or communication constrained.

We proceed by formalizing the streaming model, after which we summarize our results. We continue by presenting related work, and contrast with the online setting.

1.1 Problems and Streaming Model

Bin Packing.

The Bin Packing problem is defined as follows: The input consists of $N$ items with sizes $s_{1},\dots,s_{N}$ (each between 0 and 1), which need to be packed into bins of unit capacity. That is, we seek a partition of the set of items $\{1,\dots,N\}$ into subsets $B_{1},\dots,B_{m}$, called bins, such that for any bin $B_{i}$, it holds that $\sum_{j\in B_{i}}s_{j}\leq 1$. The goal is to minimize the number $m$ of bins used.

We also consider the natural generalization to Vector Bin Packing, where the input consists of $d$-dimensional vectors, with the value of each coordinate between 0 and 1 (i.e., the scalar items $s_{i}$ are replaced with vectors $\mathbf{v^{i}}$). The vectors need to be packed into $d$-dimensional bins with unit capacity in each dimension, we thus require that $\|\sum_{\mathbf{v}\in B_{i}}\mathbf{v}\|_{\infty}\leq 1$ (where, the infinity norm $\|\mathbf{v}\|_{\infty}=\max_{i}\mathbf{v}_{i}$).

Scheduling.

The Makespan Scheduling problem is closely related to Bin Packing but, instead of filling bins with bounded capacity, we try to balance the loads assigned to a fixed number of bins. Now we refer to the input as comprising a set of jobs, with each job $j$ defined by its processing time $p_{j}$. Our goal is to assign each job on one of $m$ identical machines to minimize the makespan, which is the maximum load over all machines.

In Vector Scheduling, a job is described not only by its processing time, but also by, say, memory or bandwidth requirements. The input is thus a set of jobs, each job $j$ characterized by a vector $\mathbf{v^{j}}$. The goal is to assign each job into one of $m$ identical machines such that the maximum load over all machines and dimensions is minimized.

Streaming Model.

In the streaming scenario, the algorithm receives the input as a sequence of items, called the input stream. We do not assume that the stream is ordered in any particular way (e.g., randomly or by item sizes), so our algorithms must work for arbitrarily ordered streams. The items arrive one by one and upon receiving each item, the algorithm updates its memory state. A streaming algorithm is required to use space sublinear in the length of the stream, ideally just $\operatorname{polylog}(N)$, while it processes the stream. After the last item arrives, the algorithm computes its estimate of the optimal value, and the space or time used during this final computation is not restricted.

For many natural optimization problems outputting some explicit solution of the problem is not possible owing to the memory restriction (as the algorithm can store only a small subset of items). Thus the goal is to find a good approximation of the value of an offline optimal solution. Since our model does not assume that item sizes are integers, we express the space complexity not in bits, but in words (or memory cells), where each word can store any number from the input; a linear combination of numbers from the input; or any integer with $\mathcal{O}(\log N)$ bits (for counters, pointers, etc.).

1.2 Our Results

Bin packing.

In Section 3, we present a streaming algorithm for Bin Packing, which outputs an asymptotic $1+\varepsilon$-approximation of OPT, the optimal number of bins, using $\mathcal{O}\left(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon}\cdot\log\textsf{OPT}\right)$ memory. This means that the algorithm uses at most $(1+\varepsilon)\cdot\textsf{OPT}+o(\textsf{OPT})$ bins, and in our case, the additive $o(\textsf{OPT})$ term is bounded by the space used. The novelty of our contribution is to combine a data structure that approximately tracks all quantiles in a numeric stream [26] with techniques for approximation schemes [18, 33]. We show that we can improve upon the $\log\textsf{OPT}$ factor in the space complexity if randomization is allowed or if item sizes are drawn from a bounded-size set of real numbers. On the other hand, we argue that our result is close to optimal, up to a factor of $\mathcal{O}\left(\log\frac{1}{\varepsilon}\right)$, if item sizes are accessed only by comparisons (including comparisons with some fixed constants). Thus, one cannot get an estimate with at most $\textsf{OPT}+o(\textsf{OPT})$ bins by a streaming algorithm, unlike in the offline setting [28]. The hardness emerges from the space complexity of the quantiles problem in the streaming model.

For Vector Bin Packing, we design a streaming asymptotic $d+\varepsilon$-approximation algorithm running in space $\mathcal{O}\left(\frac{d}{\varepsilon}\cdot\log\frac{d}{\varepsilon}\cdot\log\textsf{OPT}\right)$; see Section 3.3. We remark that if vectors are rounded into a sublinear number of types, then better than $d$-approximation is not possible [7].

Scheduling.

For Makespan Scheduling, one can obtain a straightforward streaming $1+\varepsilon$-approximation111Unlike for Bin Packing, an additive constant or even an additive $o(\textsf{OPT})$ term does not help in the definition of the approximation ratio, since we can scale every number on input by any $\alpha>0$ and OPT scales by $\alpha$ as well. with space of only $\mathcal{O}(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon})$ by rounding sizes of suitably large jobs to powers of $1+\varepsilon$ and counting the total size of small jobs. In a higher dimension, it is also possible to get a streaming $1+\varepsilon$-approximation, by the rounding introduced by Bansal et al. [8]. However, the memory required for this algorithm is exponential in $d$, precisely of size $\mathcal{O}\left(\left(\frac{1}{\varepsilon}\log\frac{d}{\varepsilon}\right)^{d}\right)$, and thus only practical when $d$ is a very small constant. Moreover, such a huge amount of memory is needed even if the number $m$ of machines (and hence, of big jobs) is small as the algorithm rounds small jobs into exponentially many types. See Section 4.2 for more details.

In case $m$ and $d$ make this feasible, we design a new streaming $\left(2-\frac{1}{m}+\varepsilon\right)$-approximation with $\mathcal{O}\left(\frac{1}{\varepsilon^{2}}\cdot d^{2}\cdot m\cdot\log\frac{d}{\varepsilon}\right)$ memory, which implies a $2$-approximation streaming algorithm running in space $\mathcal{O}(d^{2}\cdot m^{3}\cdot\log dm)$. We thus obtain a much better approximation than for Vector Bin Packing with a reasonable amount of memory (although to compute the actual makespan from our input summary, it takes time doubly exponential in $d$ [8]). Our algorithm is not based on rounding, as in the aforementioned algorithms, but on combining small jobs into containers, and the approximation guarantee of this approach is at least $2-\frac{1}{m}$, which we demonstrate by an example. We describe the algorithm for Vector Scheduling in Section 4.

2 Related Work

We give an overview of related work in offline, online, and sublinear algorithms, and highlight the differences between online and streaming algorithms. Recent surveys of Christensen et al. [13] and Coffman et al. [14] have a more comprehensive overview.

2.1 Bin Packing

Offline approximation algorithms.

Bin Packing is an NP-complete problem and indeed it is NP-hard even to decide whether two bins are sufficient or at least three bins are necessary. This follows by a simple reduction from the Partition problem and presents the strongest inapproximability to date. Most work in the offline model focused on providing asymptotic $R$-approximation algorithms, which use at most $R\cdot\textsf{OPT}+o(\textsf{OPT})$ bins. In the following, when we refer to an approximation for Bin Packing we implicitly mean the asymptotic approximation. The first polynomial-time approximation scheme (PTAS), that is, a $1+\varepsilon$-approximation for any $\varepsilon>0$, was given by Fernandez de la Vega and Lueker [18]. Karmarkar and Karp [33] provided an algorithm which returns a solution with $\textsf{OPT}+\mathcal{O}(\log^{2}\textsf{OPT})$ bins. Recently, Hoberg and Rothvoß [28] proved it is possible to find a solution with $\textsf{OPT}+\mathcal{O}(\log\textsf{OPT})$ bins in polynomial time.

The input for Bin Packing can be described by $N$ numbers, corresponding to item sizes. While in general these sizes may be distinct, in some cases the input description can be compressed significantly by specifying the number of items of each size in the input. Namely, in the High-Multiplicity Bin Packing problem, the input is a set of pairs $(a_{1},s_{1}),\dots,(a_{\sigma},s_{\sigma})$, where for $i=1,\dots,\sigma$, $a_{i}$ is the number of items of size $s_{i}$ (and all $s_{i}$’s are distinct). Thus, $\sigma$ encodes the number of item sizes, and hence the size of the description. The goal is again to pack these items into bins, using as few bins as possible. For constant number of sizes, $\sigma$, Goemans and Rothvoß [24] recently gave an exact algorithm for the case of rational item sizes running in time $\displaystyle{(\log\Delta)^{2^{\mathcal{O}(\sigma)}}}$, where $\Delta$ is the largest multiplicity of an item or the largest denominator of an item size, whichever is the greater.

While these algorithms provide satisfying theoretical guarantees, simple heuristics are often adopted in practice to provide a “good-enough” performance. First Fit [32], which puts each incoming item into the first bin where it fits and opens a new bin only when the item does not fit anywhere else achieves $1.7$-approximation [16]. For the high-multiplicity variant, using an LP-based Gilmore-Gomory cutting stock heuristic [22, 23] gives a good running time in practice [2] and produces a solution with at most $\textsf{OPT}+\sigma$ bins. However, neither of these algorithms adapts well to the streaming setting with possibly distinct item sizes. For example, First Fit has to remember the remaining capacity of each open bin, which in general can require space proportional to OPT.

Vector Bin Packing proves to be substantially harder to approximate, even in a constant dimension. For fixed $d$, Bansal, Eliáš, and Khan [7] showed an approximation factor of $\approx 0.807+\ln(d+1)+\varepsilon$. For general $d$, a relatively simple algorithm based on an LP relaxation, due to Chekuri and Khanna [11], remains the best known, with an approximation guarantee of $1+\varepsilon d+\mathcal{O}(\log\frac{1}{\varepsilon})$. The problem is APX-hard even for $d=2$ [40], and cannot be approximated within a factor better than $d^{1-\varepsilon}$ for any fixed $\varepsilon>0$ [13] if $d$ is arbitrarily large. Hence, our streaming $d+\varepsilon$-approximation for Vector Bin Packing asymptotically achieves the offline lower bound.

Sampling-based algorithms.

Sublinear-time approximation schemes constitute a model related to, but distinct from, streaming algorithms. Batu, Berenbrink, and Sohler [9] provide an algorithm that takes $\widetilde{\mathcal{O}}\left(\sqrt{N}\cdot\operatorname{poly}(\frac{1}{\varepsilon})\right)$ weighted samples, meaning that the probability of sampling an item is proportional to its size. It outputs an asymptotic $1+\varepsilon$-approximation of OPT. If uniform samples are also available, then sampling $\widetilde{\mathcal{O}}\left(N^{1/3}\cdot\operatorname{poly}(\frac{1}{\varepsilon})\right)$ items is sufficient. These results are tight, up to a $\operatorname{poly}(\frac{1}{\varepsilon},\log N)$ factor. Later, Beigel and Fu [10] focused on uniform sampling of items, proving that $\widetilde{\Theta}(N/\textsf{SIZE})$ samples are sufficient and necessary, where SIZE is the total size of all items. Their approach implies a streaming approximation scheme by uniform sampling of the substream of big items. However, the space complexity in terms of $\frac{1}{\varepsilon}$ is not stated in the paper, but we calculate this to be $\Omega\left(\varepsilon^{-c}\right)$ for a constant $c\geq 10$. Moreover, $\Omega(\frac{1}{\varepsilon^{2}})$ samples are clearly needed to estimate the number of items with size close to $1$. Note that our approach is deterministic and substantially different than taking a random sample from the stream.

Online algorithms.

Online and streaming algorithms are similar in the sense that they are required to process items one by one. However, an online algorithm must make all its decisions immediately — it must fix the placement of each incoming item on arrival.222Relaxations which allow a limited amount of “repacking” have also been considered [17]. A streaming algorithm can postpone such decisions to the very end, but is required to keep its memory small, whereas an online algorithm may remember all items that have arrived so far. Hence, online algorithms apply in the streaming setting only when they have small space cost, including the space needed to store the solution constructed so far. The approximation ratio of online algorithms is quantified by the competitive ratio.

For Bin Packing, the best possible competitive ratio is substantially worse than what we can achieve offline or even in the streaming setting. Balogh et al. [5] designed an asymptotically $1.5783$-competitive algorithm, while the current lower bound on the asymptotic competitive ratio is $1.5403$ [6]. This (relatively complicated) online algorithm is based on the Harmonic algorithm [35], which for some integer $K$ classifies items into size groups $(0,\frac{1}{K}],(\frac{1}{K},\frac{1}{K-1}],\dots,(\frac{1}{2},1]$. It packs each group separately by Next Fit, keeping just one bin open, which is closed whenever the next item does not fit. Thus Harmonic can run in memory of size $K$, unlike most other online algorithms which require maintaining the levels of all bins opened so far. Its competitive ratio tends to approximately $1.691$ as $K$ goes to infinity. Surprisingly, this is also the best possible ratio if only a bounded number of bins is allowed to be open for an online algorithm [35], which can be seen as the intersection of online and streaming algorithms.

For Vector Bin Packing, the best known competitive ratio of $d+0.7$ [20] is achieved by First Fit. A lower bound of $\Omega(d^{1-\varepsilon})$ on the competitive ratio was shown by Azar et al. [3]. It is thus currently unknown whether or not online algorithms outperform streaming algorithms in the vector setting.

2.2 Scheduling

Offline approximation algorithms.

Makespan Scheduling is strongly NP-complete [21], which in particular rules out the possibility of a PTAS with time complexity $\operatorname{poly}(\frac{1}{\varepsilon},n)$. After a sequence of improvements, Jansen, Klein, and Verschae [31] gave a PTAS with time complexity $2^{\widetilde{\mathcal{O}}(1/\varepsilon)}+\mathcal{O}(n\log n)$, which is essentially tight under the Exponential Time Hypothesis (ETH) [12].

For constant dimension $d$, Vector Scheduling also admits a PTAS, as shown by Chekuri and Khanna [11]. However, the running time is of order $n^{(1/\varepsilon)^{\widetilde{\mathcal{O}}(d)}}$. The approximation scheme for a fixed $d$ was improved to an efficient PTAS, namely to an algorithm running in time $2^{(1/\varepsilon)^{\widetilde{\mathcal{O}}(d)}}+\mathcal{O}(dn)$, by Bansal et al. [8], who also showed that the running time cannot be significantly improved under ETH. In contrast our streaming $\operatorname{poly}(d,m)$-space algorithm computes an input summary maintaining $2$-approximation of the original input. This respects the lower bound, since to compute the actual makespan from the summary, we still need to execute an offline algorithm, with running time doubly exponential in $d$. The best known approximation ratio for large $d$ is $\mathcal{O}(\log d/(\log\log d))$ [27, 30], while $\alpha$-approximation is not possible in polynomial time for any constant $\alpha>1$ and arbitrary $d$, unless NP = ZPP.

Online algorithms.

For the scalar problem, the optimal competitive ratio is known to lie in the interval $(1.88,1.9201)$ [1, 25, 29, 19], which is substantially worse than what can be done by a simple streaming $1+\varepsilon$-approximation in space $\mathcal{O}(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon})$. Interestingly, for Vector Scheduling, the algorithm by Im et al. [30] with ratio $\mathcal{O}(\log d/(\log\log d))$ actually works in the online setting as well and needs space $\mathcal{O}(d\cdot m)$ only during its execution (if the solution itself is not stored), which makes it possible to implement it in the streaming setting. This online ratio cannot be improved as there is a lower bound of $\Omega(\log d/(\log\log d))$ [30, 4], whereas in the streaming setting we can achieve a $2$-approximation with a reasonable memory (or even $1+\varepsilon$ for a fixed $d$). If all jobs have sufficiently small size, we improve the analysis in [30] and show that the online algorithm achieves $1+\varepsilon$-approximation; see Section 4.

3 Bin Packing

Notation.

For an instance $I$, let $N(I)$ be the number of items in $I$, let $\textsf{SIZE}(I)$ be the total size of all items in $I$, and let $\textsf{OPT}(I)$ be the number of bins used in an optimal solution for $I$. Clearly, $\textsf{SIZE}(I)\leq\textsf{OPT}(I)$. For a bin $B$, let $s(B)$ be the total size of items in $B$. For a given $\varepsilon>0$, we use $\widetilde{\mathcal{O}}(f(\frac{1}{\varepsilon}))$ to hide factors logarithmic in $\frac{1}{\varepsilon}$ and $\textsf{OPT}(I)$, i.e., to denote \mathcal{O}\big{(}f(\frac{1}{\varepsilon})\cdot\operatorname{polylog}\frac{1}{\varepsilon}\cdot\operatorname{polylog}\textsf{OPT}(I)\big{)}.

Overview.

We first briefly describe the approximation scheme of Fernandez de la Vega and Lueker [18], whose structure we follow in outline. Let $I$ be an instance of Bin Packing. Given a precision requirement $\varepsilon>0$, we say that an item is small if its size is at most $\varepsilon$; otherwise, it is big. Note that there are at most $\frac{1}{\varepsilon}\textsf{SIZE}(I)$ big items. The rounding scheme in [18], called “linear grouping”, works as follows: We sort the big items by size non-increasingly and divide them into groups of $k=\lfloor\varepsilon\cdot\textsf{SIZE}(I)\rfloor$ items (the first group thus contains the $k$ biggest items). In each group, we round up the sizes of all items to the size of the biggest item in that group. It follows that the number of groups and thus the number of distinct item sizes (after rounding) is bounded by $\lceil\frac{1}{\varepsilon^{2}}\rceil$. Let $I_{\mathrm{R}}$ be the instance of High-Multiplicity Bin Packing consisting of the big items with rounded sizes. It can be shown that $\textsf{OPT}(I_{\mathrm{B}})\leq\textsf{OPT}(I_{\mathrm{R}})\leq(1+\varepsilon)\cdot\textsf{OPT}(I_{\mathrm{B}})$, where $I_{\mathrm{B}}$ is the set of big items in $I$ (we detail a similar argument in Section 3.1). Due to the bounded number of distinct item sizes, we can find a close-to-optimal solution for $I_{\mathrm{R}}$ efficiently. We then translate this solution into a packing for $I_{\mathrm{B}}$ in the natural way. Finally, small items are filled greedily (e.g., by First Fit) and it can be shown that the resulting complete solution for $I$ is a $1+\mathcal{O}(\varepsilon)$-approximation.

Karmarkar and Karp [33] proposed an improved rounding scheme, called “geometric grouping”. It is based on the observation that item sizes close to $1$ should be approximated substantially better than item sizes close to $\varepsilon$. We present a version of such a rounding scheme in Section 3.1.2.

Our algorithm follows a similar outline with two stages (rounding and finding a solution for the rounded instance), but working in the streaming model brings two challenges: First, in the rounding stage, we need to process the stream of items and output a rounded high-multiplicity instance with few item sizes that are not too small, while keeping only a small number of items in the memory. Second, the rounding of big items needs to be done carefully so that not much space is “wasted”, since in the case when the total size of small items is relatively large, we argue that our solution is close to optimal by showing that the bins are nearly full on average.

Input summary properties.

More precisely, we fix some $\varepsilon>0$ that is used to control the approximation guarantee. During the first stage, our algorithm has one variable which accumulates the total size of all small items in the input stream, i.e., those of size at most $\varepsilon$. Let $I_{\mathrm{B}}$ be the substream consisting of all big items. We process $I_{\mathrm{B}}$ and output a rounded high-multiplicity instance $I_{\mathrm{R}}$ with the following properties:

1. (P1)

There are at most $\sigma$ item sizes in $I_{\mathrm{R}}$, all of them larger than $\varepsilon$, and the memory required for processing $I_{\mathrm{B}}$ is $\mathcal{O}(\sigma)$. 2. (P2)

The $i$-th biggest item in $I_{\mathrm{R}}$ is at least as large as the $i$-th biggest item in $I_{\mathrm{B}}$ (and the number of items in $I_{\mathrm{R}}$ is the same as in $I_{\mathrm{B}}$). This immediately implies that

• •

Any packing of $I_{\mathrm{R}}$ can be used as a packing of $I_{\mathrm{B}}$ (in the same number of bins),

• •

$\textsf{OPT}(I_{\mathrm{B}})\leq\textsf{OPT}(I_{\mathrm{R}})$, and

• •

$\textsf{SIZE}(I_{\mathrm{B}})\leq\textsf{SIZE}(I_{\mathrm{R}})$. 3. (P3)

$\textsf{OPT}(I_{\mathrm{R}})\leq(1+\varepsilon)\cdot\textsf{OPT}(I_{\mathrm{B}})+\mathcal{O}(\log\frac{1}{\varepsilon})$. 4. (P4)

$\textsf{SIZE}(I_{\mathrm{R}})\leq(1+\varepsilon)\cdot\textsf{SIZE}(I_{\mathrm{B}})$.

In words, (P2) means that we are rounding item sizes up and, together with (P3), it implies that the optimal solution for the rounded instance approximates $\textsf{OPT}(I_{\mathrm{B}})$ well. The last property is used in the case when the total size of small items constitutes a large fraction of the total size of all items. Note that $\textsf{SIZE}(I_{\mathrm{R}})-\textsf{SIZE}(I_{\mathrm{B}})$ can be thought of as bin space “wasted” by rounding.

Observe that the succinctness of the rounded instance depends on $\sigma$. First, we show a streaming algorithm for rounding with $\sigma=\widetilde{\mathcal{O}}(\frac{1}{\varepsilon^{2}})$. Then we improve upon it and give an algorithm with $\sigma=\widetilde{\mathcal{O}}(\frac{1}{\varepsilon})$, which is essentially the best possible, while guaranteeing an error of $\varepsilon\cdot\textsf{OPT}(I_{\mathrm{B}})$ introduced by rounding (elaborated on in Section 3.2). More precisely, we show the following:

Lemma 1**.**

Given a steam $I_{\mathrm{B}}$ of big items, there is a deterministic streaming algorithm that outputs a High-Multiplicity Bin Packing instance satisfying (P1)-(P4) with $\sigma=\mathcal{O}\left(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon}\cdot\log\textsf{OPT}(I_{\mathrm{B}})\right)$.

Before describing the rounding itself and proving Lemma 1, we explain how to use it to calculate an accurate estimate of the number of bins.

Calculating a bound on the number of bins after rounding.

First, we obtain a solution $\mathcal{S}$ of the rounded instance $I_{\mathrm{R}}$. For instance, we may round the solution of the linear program introduced by Gilmore and Gomory [22, 23], and get a solution with at most $\textsf{OPT}(I_{\mathrm{R}})+\sigma$ bins. Or, if item sizes are rational numbers, we may compute an optimal solution for $I_{\mathrm{R}}$ by the algorithm of Goemans and Rothvoß [24]; however, the former approach appears to be more efficient and more general. In the following, we thus assume that $\mathcal{S}$ uses at most $\textsf{OPT}(I_{\mathrm{R}})+\sigma$ bins.

We now calculate a bound on the number of bins in the original instance. Let $W$ be the total free space in the bins of $\mathcal{S}$ that can be used for small items. To be precise, $W$ equals the sum over all bins $B$ in $\mathcal{S}$ of $\max(0,1-\varepsilon-s(B))$. Note that the capacity of bins is capped at $1-\varepsilon$, because it may happen that all small items are of size $\varepsilon$ while the packing leaves space of just under $\varepsilon$ in any bin. Then we would not be able to pack small items into these bins. Reducing the capacity by $\varepsilon$ removes this issue. On the other hand, if a small item does not fit into a bin, then the remaining space in the bin is smaller than $\varepsilon$.

Let $s$ be the total size of all small items in the input stream. If $s\leq W$, then all small items surely fit into the free space of bins in $\mathcal{S}$ (and can be assigned there greedily by First Fit). Consequently, we output that the number of bins needed for the stream of items is at most $|\mathcal{S}|$, i.e., the number of bins in solution $\mathcal{S}$ for $I_{\mathrm{R}}$. Otherwise, we need to place small items of total size at most $s^{\prime}=s-W$ into new bins and it is easy to see that opening at most $\lceil s^{\prime}/(1-\varepsilon)\rceil\leq(1+\mathcal{O}(\varepsilon))\cdot s^{\prime}+1$ bins for these small items suffices. Hence, in the case $s>W$, we output that $|\mathcal{S}|+\lceil s^{\prime}/(1-\varepsilon)\rceil$ bins are sufficient to pack all items in the stream.

We prove that the number of bins that we output in either case is a good approximation of the optimal number of bins, provided that $\mathcal{S}$ is a good solution for $I_{\mathrm{R}}$.

Lemma 2**.**

Let $I$ be given as a stream of items. Suppose that $0<\varepsilon\leq\frac{1}{3}$, that the rounded instance $I_{\mathrm{R}}$, created from $I$, satisfies properties (P1)-(P4), and that the solution $\mathcal{S}$ of $I_{\mathrm{R}}$ uses at most $\textsf{OPT}(I_{\mathrm{R}})+\sigma$ bins. Let $\textsf{ALG}(I)$ be the number of bins that our algorithm outputs. Then, it holds that $\textsf{OPT}(I)\leq\textsf{ALG}(I)\leq(1+3\varepsilon)\cdot\textsf{OPT}(I)+\sigma+\mathcal{O}\left(\log\frac{1}{\varepsilon}\right)$.

Proof.

We analyze the two cases of the algorithm:

Case $s\leq W$: In this case, small items fit into the bins of $\mathcal{S}$ and $\textsf{ALG}(I)=|\mathcal{S}|$. For the inequality $\textsf{OPT}(I)\leq\textsf{ALG}(I)$, observe that the packing $\mathcal{S}$ can be used as a packing of items in $I_{\mathrm{B}}$ (in a straightforward way) with no less free space for small items by property (P2). Thus $\textsf{OPT}(I)\leq|\mathcal{S}|$.

To upper bound $\textsf{ALG}(I)$, note that

[TABLE]

where the second inequality follows from property (P3) and the third inequality holds as $I_{\mathrm{B}}$ is a subinstance of $I$.

Case $s>W$: Recall that $\textsf{ALG}(I)=|\mathcal{S}|+\lceil s^{\prime}/(1-\varepsilon)\rceil$. We again have that $\mathcal{S}$ can be used as a packing of $I_{\mathrm{B}}$ with no less free space for small items. Thus, the total size of small items that do not fit into bins in $\mathcal{S}$ is at most $s^{\prime}$ and these items clearly fit into $\lceil s^{\prime}/(1-\varepsilon)\rceil$ bins. Hence, $\textsf{OPT}(I)\leq|\mathcal{S}|+\lceil s^{\prime}/(1-\varepsilon)\rceil$.

For the other inequality, consider starting with solution $\mathcal{S}$ for $I_{\mathrm{R}}$, first to (almost) fill up the bins of $\mathcal{S}$ with small items of total size $W$, then using $\lceil s^{\prime}/(1-\varepsilon)\rceil$ additional bins for the remaining small items. Note that in each bin, except the last one, the unused space is less than $\varepsilon$, thus the total size of items in $I_{\mathrm{R}}$ and small items is more than $(\textsf{ALG}(I)-1)\cdot(1-\varepsilon)$. Finally, we replace items in $I_{\mathrm{R}}$ by items in $I_{\mathrm{B}}$ and the total size of items decreases by $\textsf{SIZE}(I_{\mathrm{R}})-\textsf{SIZE}(I_{\mathrm{B}})\leq\varepsilon\cdot\textsf{SIZE}(I_{\mathrm{B}})\leq\varepsilon\cdot\textsf{SIZE}(I)$ by property (P4). Hence, $\textsf{SIZE}(I)\geq(\textsf{ALG}(I)-1)\cdot(1-\varepsilon)-\varepsilon\cdot\textsf{SIZE}(I)$. Rearranging and using $\varepsilon\leq\frac{1}{3}$, we get

[TABLE]

Considered together, these two cases both meet the claimed bound. ∎

3.1 Processing the Stream and Rounding

The streaming algorithm of the rounding stage makes use of the deterministic quantile summary of Greenwald and Khanna [26]. Given a precision $\delta>0$ and an input stream of numbers $s_{1},\dots,s_{N}$, their algorithm computes a data structure $Q(\delta)$ which is able to answer a quantile query with precision $\delta N$. Namely, for any $0\leq\phi\leq 1$, it returns an element $s$ of the input stream such that the rank of $s$ is $[(\phi-\delta)N,(\phi+\delta)N]$, where the rank of $s$ is the position of $s$ in the non-increasing ordering of the input stream.333Note that if $s$ appears more times in the stream, its rank is an interval rather than a single number. Also, unlike in [26], we order numbers non-increasingly, which is more convenient for Bin Packing. The data structure stores an ordered sequence of tuples, each consisting of an input number $s_{i}$ and valid lower and upper bounds on the true rank of $s_{i}$ in the input sequence.444More precisely, valid lower and upper bounds on the rank of $s_{i}$ can be computed easily from the set of tuples. The first and last stored items correspond to the maximum and minimum numbers in the stream, respectively. Note that the lower and upper bounds on the rank of any stored number differ by at most $\lfloor 2\delta N\rfloor$ and upper (or lower) bounds on the rank of two consecutive stored numbers differ by at most $\lfloor 2\delta N\rfloor$ as well. The space requirement of $Q(\delta)$ is $\mathcal{O}(\frac{1}{\delta}\cdot\log\delta N)$, however, in practice the space used is observed to scale linearly with $\frac{1}{\delta}$ [36]. (Note that an offline optimal data structure for $\delta$-approximate quantiles uses space $\mathcal{O}\left(\frac{1}{\delta}\right)$.) We use data structure $Q(\delta)$ to construct our algorithm for processing the stream $I_{\mathrm{B}}$ of big items.

3.1.1 Simple Rounding Algorithm

We begin by describing a simpler solution with $\delta=\frac{1}{4}\varepsilon^{2}$, resulting in a rounded instance with $\widetilde{\mathcal{O}}(\frac{1}{\varepsilon^{2}})$ item sizes. Subsequently, we introduce a more involved solution with smaller space cost. The algorithm uses a quantile summary structure to determine the rounding scheme. Given a (big) item $s_{i}$ from the input, we insert it into $Q(\delta)$. After processing all items, we extract from $Q(\delta)$ the set of stored input items (i.e., their sizes) together with upper bounds on their rank (where the largest size has highest rank 1, and the smallest size has least rank $N$). Note that the number $N_{\mathrm{B}}$ of big items in $I_{\mathrm{B}}$ is less than $\frac{1}{\varepsilon}\textsf{SIZE}(I_{\mathrm{B}})\leq\frac{1}{\varepsilon}\textsf{OPT}(I_{\mathrm{B}})$ as each is of size more than $\varepsilon$. Let $q$ be the number of items (or tuples) extracted from $Q(\delta)$; we get that q=\mathcal{O}(\frac{1}{\delta}\cdot\log\delta N_{\mathrm{B}})=\mathcal{O}\big{(}\frac{1}{\varepsilon^{2}}\cdot\log(\varepsilon\cdot\textsf{OPT}(I_{\mathrm{B}}))\big{)}. Let $(a_{1},u_{1}=1),(a_{2},u_{2}),\dots,(a_{q},u_{q}=N_{\mathrm{B}})$ be the output pairs of an item size and the bound on its rank, sorted so that $a_{1}\geq a_{2}\geq\cdots\geq a_{q}$. We define the rounded instance $I_{\mathrm{R}}$ with at most $q$ item sizes as follows: $I_{\mathrm{R}}$ contains $(u_{j+1}-u_{j})$ items of size $a_{j}$ for each $j=1,\dots,q-1$, plus one item of size $a_{q}$. See Figure 1 for an illustration.

We show that the desired properties (P1)-(P4) hold with $\sigma=q$. Property (P1) follows easily from the definition of $I_{\mathrm{R}}$ and the design of data structure $Q(\delta)$. Note that the number of items is preserved. To show (P2), suppose for a contradiction that the $i$-th biggest item in $I_{\mathrm{B}}$ is bigger than the $i$-th biggest item in $I_{\mathrm{R}}$, whose size is $a_{j}$ for $j=1,\dots,q-1$, i.e., $i\in[u_{j},u_{j+1})$ (note that $j<q$ as $a_{q}$ is the smallest item in $I_{\mathrm{B}}$ and is present only once in $I_{\mathrm{R}}$). We get that the rank of item $a_{j}$ in $I_{\mathrm{B}}$ is strictly more than $i$, and as $i\geq u_{j}$, we get a contradiction with the fact that $u_{j}$ is a valid upper bound on the rank of $a_{j}$ in $I_{\mathrm{B}}$.

Next, we give bounds for $\textsf{OPT}(I_{\mathrm{R}})$ and $\textsf{SIZE}(I_{\mathrm{R}})$, which are required by properties (P3) and (P4). We pack the $\lfloor 4\delta N_{\mathrm{B}}\rfloor$ biggest items in $I_{\mathrm{R}}$ separately into “extra” bins. Using the choice of $\delta=\frac{1}{4}\varepsilon^{2}$ and $N_{\mathrm{B}}\leq\frac{1}{\varepsilon}\textsf{SIZE}(I_{\mathrm{B}})$, we bound the number of these items and thus extra bins by $4\delta N_{\mathrm{B}}\leq\varepsilon\cdot\textsf{SIZE}(I_{\mathrm{B}})\leq\varepsilon\cdot\textsf{OPT}(I_{\mathrm{B}})$. Let $I_{\mathrm{R}}^{\prime}$ be the remaining items in $I_{\mathrm{R}}$. We claim that that the $i$-th biggest item $b_{i}$ in $I_{\mathrm{B}}$ is bigger than the $i$-th biggest item in $I_{\mathrm{R}}^{\prime}$ with size equal to $a_{j}$ for $j=1,\dots,q$. For a contradiction, suppose that $b_{i}<a_{j}$, which implies that the rank $r_{j}$ of $a_{j}$ in $I_{\mathrm{B}}$ is less than $i$. Note that $j<q$ as $a_{q}$ is the smallest item in $I_{\mathrm{B}}$. Since we packed the $\lfloor 4\delta N_{\mathrm{B}}\rfloor$ biggest items from $I_{\mathrm{R}}$ separately, one of the positions of $a_{j}$ in the ordering of $I_{\mathrm{R}}$ is $i+\lfloor 4\delta N_{\mathrm{B}}\rfloor$ and so we have $i+\lfloor 4\delta N_{\mathrm{B}}\rfloor<u_{j+1}\leq u_{j}+\lfloor 2\delta N_{\mathrm{B}}\rfloor$, where the first inequality holds by the construction of $I_{\mathrm{R}}$ and the second inequality is by the design of data structure $Q(\delta)$. It follows that $i<u_{j}-\lfloor 2\delta N_{\mathrm{B}}\rfloor$. Combining this with $r_{j}<i$, we obtain that the rank of $a_{j}$ in $I_{\mathrm{B}}$ is less than $u_{j}-\lfloor 2\delta N_{\mathrm{B}}\rfloor$, which contradicts that $u_{j}-\lfloor 2\delta N_{\mathrm{B}}\rfloor$ is a valid lower bound on the rank of $a_{j}$.

The claim implies $\textsf{OPT}(I_{\mathrm{R}}^{\prime})\leq\textsf{OPT}(I_{\mathrm{B}})$ and $\textsf{SIZE}(I_{\mathrm{R}}^{\prime})\leq\textsf{SIZE}(I_{\mathrm{B}})$. We thus get that $\textsf{OPT}(I_{\mathrm{R}})\leq\textsf{OPT}(I_{\mathrm{R}}^{\prime})+\lfloor 4\delta N_{\mathrm{B}}\rfloor\leq\textsf{OPT}(I_{\mathrm{B}})+\varepsilon\cdot\textsf{OPT}(I_{\mathrm{B}})$, proving property (P3). Similarly, $\textsf{SIZE}(I_{\mathrm{R}})\leq\textsf{SIZE}(I_{\mathrm{R}}^{\prime})+\lfloor 4\delta N_{\mathrm{B}}\rfloor\leq\textsf{SIZE}(I_{\mathrm{B}})+\varepsilon\cdot\textsf{SIZE}(I_{\mathrm{B}})$, showing (P4) and concluding the analysis of our simple rounding algorithm.

3.1.2 Improved Rounding Algorithm

Our improved rounding algorithm reduces the number of sizes in the rounded instance (and also the memory requirement) from $\widetilde{\mathcal{O}}(\frac{1}{\varepsilon^{2}})$ to $\widetilde{\mathcal{O}}(\frac{1}{\varepsilon})$. It is based on the observation that the number of items of sizes close to $\varepsilon$ can be approximated with much lower accuracy than the number of items with sizes close to 1, without affecting the quality of the overall approximation. This was observed already by Karmarkar and Karp [33].

Proof of Lemma 1.

Let $k=\lceil\log_{2}\frac{1}{\varepsilon}\rceil$. We first group big items in $k$ groups $0,\dots,k-1$ by size such that in group $j$ there are items with sizes in $(2^{-j-1},2^{-j}]$. That is, the size intervals for groups are $(0.5,1],(0.25,0.5]$, etc. Let $N_{j}$, $j=0,\dots,k-1$, be the number of big items in group $j$; clearly, $N_{j}<2^{j+1}\textsf{SIZE}(I_{\mathrm{B}})\leq 2^{j+1}\textsf{OPT}(I_{\mathrm{B}})$. Note that the total size of items in group $j$ is in $(2^{-j-1}\cdot N_{j},2^{-j}\cdot N_{j}]$. Summing over all groups, we get in particular that

[TABLE]

For each group $j$, we use a separate data structure $Q_{j}:=Q(\delta)$ with $\delta=\frac{1}{8}\varepsilon$, where $Q(\delta)$ is the quantile summary from [26] with precision $\delta$. So when a big item of size $s_{i}$ arrives, we find $j$ such that $s_{i}\in(2^{-j-1},2^{-j}]$ and insert $s_{i}$ into $Q_{j}$. After processing all items, for each group $j$, we do the following: We extract from $Q_{j}$ the set of stored input items (i.e., their sizes) together with upper bounds on their rank. Let $(a^{j}_{1},u^{j}_{1}=1),(a^{j}_{2},u^{j}_{2}),\dots,(a^{j}_{q_{j}},u^{j}_{q_{j}}=N_{j})$ be the pairs of an item size and the upper bound on its rank in group $j$, ordered as in the simpler algorithm so that $a^{j}_{1}\geq a^{j}_{2}\geq\cdots\geq a^{j}_{q_{j}}$. We have

[TABLE]

since $\varepsilon 2^{j}\leq\varepsilon 2^{k}\leq 1$.

An auxiliary instance $I_{\mathrm{R}}^{j}$ is formed by $(u^{j}_{i+1}-u^{j}_{i})$ items of size $a_{i}$ for $i=1,\dots,q_{j}-1$ plus one item of size $a_{q_{j}}$. To create the rounded instance $I_{\mathrm{R}}$, we take the union of all auxiliary instances $I_{\mathrm{R}}^{j}$, $j=0,\dots,k-1$. Note that the number of item sizes in $I_{\mathrm{R}}$ is

[TABLE]

We show that the desired properties (P1)-(P4) are satisfied. Property (P1) follows easily from the definition of $I_{\mathrm{R}}$ as the union of instances $I_{\mathrm{R}}^{j}$ and the design of data structures $Q_{j}$. To see property (P2), for every group $j$, it holds that the $i$-th biggest item in group $j$ in $I_{\mathrm{R}}$ is at least as large as the $i$-th biggest item in group $j$ in $I_{\mathrm{B}}$. Indeed, for any $p=0,\dots,q_{j}$, $u^{j}_{p}$ is a valid upper bound on the rank of $a^{j}_{p}$ in group $j$ in $I_{\mathrm{B}}$ and ranks of items of size $a^{j}_{p}$ in group $j$ in $I_{\mathrm{R}}$ are at least $u^{j}_{p}$. Moreover, the number of items is preserved in every group. Hence, overall, the $i$-th biggest item in $I_{\mathrm{R}}$ cannot be smaller than the $i$-th biggest item in $I_{\mathrm{B}}$.

Next, we prove properties (P3) and (P4), i.e., the bounds on $\textsf{OPT}(I_{\mathrm{R}})$ and on $\textsf{SIZE}(I_{\mathrm{R}})$. For each group $j$, we pack the $\lfloor 4\delta N_{j}\rfloor$ biggest items in $I_{\mathrm{R}}$ with size in group $j$ into “extra” bins, each containing $2^{j}$ items, except for at most one extra bin which may contain fewer than $2^{j}$ items. This is possible as any item in group $j$ has size at most $2^{-j}$. Using the choice of $\delta=\frac{1}{8}\varepsilon$ and (1), we bound the total number of extra bins by

[TABLE]

Let $I_{\mathrm{R}}^{\prime}$ be the remaining items in $I_{\mathrm{R}}$. Consider group $j$ and let $I_{\mathrm{B}}(j)$ and $I_{\mathrm{R}}^{\prime}(j)$ be the items with sizes in $(2^{-j-1},2^{-j}]$ in $I_{\mathrm{B}}$ and in $I_{\mathrm{R}}^{\prime}$, respectively. We claim that the $i$-th biggest item $b_{i}$ in $I_{\mathrm{B}}(j)$ is at least as large as the $i$-th biggest item in $I_{\mathrm{R}}^{\prime}(j)$ with size equal to $a_{p}$ for $p=1,\dots,q_{j}$. For a contradiction, suppose that $b_{i}<a_{p}$, which implies that the rank $r_{p}$ of $a_{p}$ in $I_{\mathrm{B}}(j)$ is less than $i$. Note that $p<q_{j}$ as $a_{q_{j}}$ is the smallest item in $I_{\mathrm{B}}(j)$. Since we packed the largest $\lfloor 4\delta N_{j}\rfloor$ items from $I_{\mathrm{R}}(j)$ separately, we have $i+\lfloor 4\delta N_{j}\rfloor<u_{p+1}\leq u_{p}+\lfloor 2\delta N_{j}\rfloor$, where the last inequality is by the design of data structure $Q_{j}$. It follows that $i<u_{p}-\lfloor 2\delta N_{j}\rfloor$. Combining it with $r_{p}<i$, we obtain that the rank of $a_{p}$ in $I_{\mathrm{B}}(j)$ is less than $u_{p}-\lfloor 2\delta N_{j}\rfloor$, which contradicts that $u_{p}-\lfloor 2\delta N_{j}\rfloor$ is a valid lower bound on the rank of $a_{p}$. Hence, the claim holds for any group and it immediately implies $\textsf{OPT}(I_{\mathrm{R}}^{\prime})\leq\textsf{OPT}(I_{\mathrm{B}})$ and $\textsf{SIZE}(I_{\mathrm{R}}^{\prime})\leq\textsf{SIZE}(I_{\mathrm{B}})$.

Combining with (2), we get that $\textsf{OPT}(I_{\mathrm{R}})\leq\textsf{OPT}(I_{\mathrm{R}}^{\prime})+\varepsilon\cdot\textsf{OPT}(I_{\mathrm{B}})+k\leq(1+\varepsilon)\cdot\textsf{OPT}(I_{\mathrm{B}})+k,$ thus (P3) holds. Similarly, to bound the total wasted space, observe that the total size of items of $I_{\mathrm{R}}$ that are not in $I_{\mathrm{R}}^{\prime}$ is bounded by

[TABLE]

where we use (1) in the last inequality. We obtain that $\textsf{SIZE}(I_{\mathrm{R}})\leq\textsf{SIZE}(I_{\mathrm{R}}^{\prime})+\varepsilon\cdot\textsf{SIZE}(I_{\mathrm{B}})\leq(1+\varepsilon)\cdot\textsf{SIZE}(I_{\mathrm{B}}).$ We conclude that properties (P1)-(P4) hold for the rounded instance $I_{\mathrm{R}}$. ∎

3.2 Bin Packing and Quantile Summaries

In the previous section, the deterministic quantile summary data structure from [26] allows us to obtain a streaming approximation scheme for Bin Packing. We argue that this connection runs deeper.

We start with different scenarios for which there exist better quantile summaries. First, if all big item sizes belong to a universe $U\subset(\varepsilon,1]$, then it can be better to use the quantile summary of Shrivastava et al. [39], which provides a guarantee of $\mathcal{O}(\frac{1}{\delta}\cdot\log|U|)$ on the space complexity, where $\delta$ is the precision requirement. Thus, by using $k$ copies of this quantile summary in the same way as in Section 3.1.2, we get a streaming $1+\varepsilon$-approximation algorithm for Bin Packing that runs in space $\mathcal{O}(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon}\cdot\log|U|)$.

Second, if we allow the algorithm to use randomization and fail with probability $\gamma$, we can employ the optimal randomized quantile summary of Karnin, Lang, and Liberty [34], which, for a given precision $\delta$ and failure probability $\eta$, uses space $\mathcal{O}(\frac{1}{\delta}\cdot\log\log\frac{1}{\eta})$ and does not provide a $\delta$-approximate quantile for some quantile query with probability at most $\eta$. In particular, using $k$ copies of their data structure with precision $\delta=\Theta(\varepsilon)$ and failure probability $\eta=\gamma/k$ in the same way as in Section 3.1.2 gives a streaming $1+\varepsilon$-approximation algorithm for Bin Packing which fails with probability at most $\gamma$ and runs in space $\mathcal{O}\left(\frac{1}{\varepsilon}\cdot\log\frac{1}{\varepsilon}\cdot\log\log(\log\frac{1}{\varepsilon}/\gamma)\right)$.

More intriguingly, the connection between quantile summaries and Bin Packing also goes in the other direction. Namely, we show that a streaming $1+\varepsilon$-approximation algorithm for Bin Packing with space bounded by $S(\varepsilon,\textsf{OPT})$ (or $S(\varepsilon,N)$) implies a data structure of size $S(\varepsilon,N)$ for the following Estimating Rank problem: Create a summary of a stream of $N$ numbers which is able to provide a $\delta$-approximate rank of any query $q$, i.e., the number of items in the stream which are larger than $q$, up to an additive error of $\pm\delta N$. Observe that a summary for Estimating Rank is essentially a quantile summary and we can actually use it to find an approximate quantile by doing a binary search over possible item names. However, this approach does not guarantee that the item name returned will correspond to one of the items present in the stream.

The reduction from Estimating Rank to Bin Packing goes as follows: Suppose that all numbers in the input stream for Estimating Rank are from interval $(\frac{1}{2},\frac{2}{3})$ (this is without loss of generality by scaling) and let $q$ be a query in $(\frac{1}{2},\frac{2}{3})$. For each such $a_{i}$ (in the Estimating Rank instance), we introduce two items of size $a_{i}$ (in the Bin Packing instance). In the stream for Bin Packing, after the $2N$ items (two copies each of $a_{1},\dots,a_{N}$) are inserted in the same order as in the stream for Estimating Rank, we then insert a further $2N$ items, all of size $1-q$. Observe first that no pair of the first $2N$ items can be placed in the same bin, so we must open at least $2N$ bins, two for each of $a_{1},\ldots,a_{N}$. Since $\frac{1}{2}>(1-q)>\frac{1}{3}$, and $a_{i}>\frac{1}{2}$, we can place at most one of the $2N$ items of size $(1-q)$ in a bin with $a_{i}$ in it, provided $a_{i}+(1-q)\leq 1$, i.e. $a_{i}\leq q$. Thus, we can pack a number of the $(1-q)$-sized items, equivalent to $2(N-\operatorname{rank}(q))$, in the first $2N$ bins. This leaves $2\operatorname{rank}(q)$ items, all of size $(1-q)$. We pack these optimally into $\operatorname{rank}(q)$ additional bins, for a total of $2N+\operatorname{rank}(q)$ bins.

We claim that a $1+\varepsilon$-approximation of the optimum number of bins provides a $4\varepsilon$-approximate rank of $q$. Indeed, let $m$ be the number of bins returned by the algorithm and let $r=m-2N$ be the estimate of $\operatorname{rank}(q)$. We have that the optimal number of bins equals $2N+\operatorname{rank}(q)$ and thus $2N+\operatorname{rank}(q)\leq m\leq(1+\varepsilon)\cdot(2N+\operatorname{rank}(q))+o(N)$. By using $r=m-2N$ and rearranging, we get

[TABLE]

Since the right-hand side can be upper bounded by $\operatorname{rank}(q)+4\varepsilon N$ (provided that $o(N)<\varepsilon N$), $r$ is a $4\varepsilon$-approximate rank of $q$. Hence, the memory state of an algorithm for Bin Packing after processing the first $2N$ items (of sizes $a_{1},\dots,a_{N}$) can be used as a data structure for Estimating Rank.

In [15] we show a space lower bound of $\Omega(\frac{1}{\varepsilon}\cdot\log\varepsilon N)$ for comparison-based data structures for Estimating Rank (and for quantile summaries as well).

Theorem 3** (Theorem 13 in [15]).**

For any $0<\varepsilon<\frac{1}{16}$, there is no deterministic comparison-based data structure for Estimating Rank which stores $o\left(\frac{1}{\varepsilon}\cdot\log\varepsilon N\right)$ items on any input stream of length $N$.

We conclude that there is no comparison-based streaming algorithm for Bin Packing which stores $o(\frac{1}{\varepsilon}\cdot\log\textsf{OPT})$ items on any input stream (recall that $N=\mathcal{O}(\textsf{OPT})$ in our reduction). Note that our algorithm is comparison-based if we employ the comparison-based quantile summary of Greenwald and Khanna [26], except that it needs to determine the size group for each item, which can be done by comparisons with $2^{-j}$ for integer values of $j$. Nevertheless, comparisons with a fixed set of constants does not affect the reduction from Estimating Rank (i.e., the reduction can choose an interval to avoid all constants fixed in the algorithm), thus the lower bound of $\Omega\left(\frac{1}{\varepsilon}\cdot\log\varepsilon N\right)$ applies to our algorithm as well. This yields near optimality of our approach, up to a factor of $\mathcal{O}\left(\log\frac{1}{\varepsilon}\right)$. Finally, we remark that the lower bound of $\Omega(\frac{1}{\varepsilon}\cdot\log\log\frac{1}{\delta})$ for randomized comparison-based quantiles summaries [34] translates to Bin Packing as well.

3.3 Vector Bin Packing

As already observed by Fernandez de la Vega and Lueker [18], a $1+\varepsilon$-approximation algorithm for (scalar) Bin Packing implies a $d\cdot(1+\varepsilon)$-approximation algorithm for Vector Bin Packing, where items are $d$-dimensional vectors and bins have capacity $d$ in every dimension. Indeed, we split the vectors into $d$ groups according to the largest dimension (chosen arbitrarily among dimensions that have the largest value) and in each group we apply the approximation scheme for Bin Packing, packing just according to the largest dimension. Finally, we take the union of opened bins over all groups. Since the optimum of the Bin Packing instance for each group is a lower bound on the optimum of Vector Bin Packing, we get that that the solution is a $d\cdot(1+\varepsilon)$-approximation.

This can be done in the same way in the streaming model. Hence there is a streaming algorithm for Vector Bin Packing which outputs a $d\cdot(1+\varepsilon)$-approximation of OPT, the offline optimal number of bins, using $\mathcal{O}\left(\frac{d}{\varepsilon}\cdot\log\frac{1}{\varepsilon}\cdot\log\textsf{OPT}\right)$ memory. By scaling $\varepsilon$, there is a $d+\varepsilon$-approximation algorithm with $\widetilde{\mathcal{O}}(\frac{d^{2}}{\varepsilon})$ memory. We can, however, do better by one factor of $d$.

Theorem 4**.**

There is a streaming $d+\varepsilon$-approximation for Vector Bin Packing algorithm that uses $\mathcal{O}\left(\frac{d}{\varepsilon}\cdot\log\frac{d}{\varepsilon}\cdot\log\textsf{OPT}\right)$ memory.

Proof.

Given an input stream $I$ of vectors, we create an input stream $I^{\prime}$ for Bin Packing by replacing each vector $\mathbf{v}$ by a single (scalar) item $a$ of size $\|\mathbf{v}\|_{\infty}$. We use our streaming algorithm for Bin Packing with precision $\delta=\frac{\varepsilon}{d}$ which uses $\mathcal{O}\left(\frac{1}{\delta}\cdot\log\frac{1}{\delta}\cdot\log\textsf{OPT}\right)$ memory and returns a solution with at most $B=(1+\delta)\cdot\textsf{OPT}(I^{\prime})+\widetilde{\mathcal{O}}(\frac{1}{\delta})$ scalar bins. Clearly, $B$ bins are sufficient for the stream $I$ of vectors, since in the solution for $I^{\prime}$ we replace each item by the corresponding vector and obtain a valid solution for $I$.

Finally, we show that $(1+\delta)\cdot\textsf{OPT}(I^{\prime})+\mathcal{O}_{\delta}(1)\leq(d+\varepsilon)\cdot\textsf{OPT}(I)+\widetilde{\mathcal{O}}(\frac{d}{\varepsilon})$ for which it is sufficient to prove that $\textsf{OPT}(I^{\prime})\leq d\cdot\textsf{OPT}(I)$ as $\delta=\frac{\varepsilon}{d}$. Namely, from an optimal solution $\mathcal{S}$ for $I$, we create a solution for $I^{\prime}$ with at most $d\cdot\textsf{OPT}(I)$ bins. For each bin $B$ in $\mathcal{S}$, we split the vectors assigned to $B$ into $d$ groups according to the largest dimension (chosen arbitrarily among those with the largest value) and for each group $i$ we create bin $B_{i}$ with vectors in group $i$. Then we just replace each vector $v$ by an item of size $\|v\|_{\infty}$ and obtain a valid solution for $I^{\prime}$ with at most $d\cdot\textsf{OPT}(I)$ bins. ∎

Interestingly, a better than $d$-approximation using sublinear memory, which is rounding-based, is not possible, due to the following result in [7]. (Note that the result requires that the numbers in the input vectors can take arbitrary values in $[0,1]$, i.e., vectors do not belong to a bounded universe.)

Theorem 5** (Implied by the proof of Theorem 2.2 in [7]).**

Any algorithm for Vector Bin Packing that rounds up large coordinates of vectors to $o(N/d)$ types cannot achieve better than $d$-approximation, where $N$ is the number of vectors.

It is an interesting open question whether or not we can design a streaming $d+\varepsilon$-approximation with $o(\frac{d}{\varepsilon})$ memory or even with $\widetilde{\mathcal{O}}\left(d+\frac{1}{\varepsilon}\right)$ memory.

4 Vector Scheduling

4.1 Streaming Algorithm by Combining Small Jobs

We provide a novel approach for creating an input summary for Vector Scheduling (and hence also Makespan Scheduling by inclusion), based on combining small items into containers, which works well even in a large dimension. Our streaming algorithm stores all big jobs and all containers, created from small items, that are relatively big as well. Thus, there is a bounded number of big jobs and containers, and the space used is bounded as well. We show that this simple summarization preserves the optimal makespan up to a factor of $2-\frac{1}{m}+\varepsilon$ for any $0<\varepsilon\leq 1$. Take $m\geq 2$, since for $m=1$ there is a trivial streaming algorithm that just sums up the vectors of all jobs to get the optimal makespan. We assume that the algorithm knows (an upper bound on) $m$ in advance.

Algorithm description.

For $0<\varepsilon\leq 1$ and $m\geq 2$, the algorithms works as follows: For each $k=1,\dots,d$, it keeps track of the total load of all jobs in dimension $k$, denoted $L_{k}$. Note that the optimal makespan satisfies $\textsf{OPT}\geq\max_{k}\frac{1}{m}\cdot L_{k}$. Assume for simplicity that when a new job arrives, $\max_{k}\frac{1}{m}\cdot L_{k}=1$; if not, we rescale every quantity by this maximum. Hence, the optimum makespan for jobs that arrived so far is at least one, while $L_{k}\leq m$ for any $k=1,\dots,d$ (an alternative lower bound on OPT is the maximum $\ell_{\infty}$ norm of a job seen so far, but our algorithm does not use this).

Let $\gamma=\Theta\left(\varepsilon^{2}/\log\frac{d^{2}}{\varepsilon}\right)$; the constant hidden in $\Theta$ follows from the analysis below. We also ensure that $\gamma\leq\frac{1}{4}\varepsilon$. We say that a job with vector $\mathbf{v}$ is big if $\|\mathbf{v}\|_{\infty}>\gamma$; otherwise it is small. The algorithm stores all big jobs (i.e., the full vector of each big job), while it aggregates small jobs into containers, and does not store any small job directly. A container is simply a vector $\mathbf{c}$ that equals the sum of vectors for small jobs assigned to this container, and we ensure that $\|\mathbf{c}\|_{\infty}\leq 2\gamma$. Furthermore, container $\mathbf{c}$ is closed if $\|\mathbf{c}\|_{\infty}>\gamma$, otherwise, it is open. As two open containers can be combined into one (open or closed) container, we maintain only one open container. We execute a variant of the Next Fit algorithm to pack the containers, adding the incoming small job into the open container, where it always fits as any small vector $\mathbf{v}$ satisfies $\|\mathbf{v}\|_{\infty}\leq\gamma$. All containers are retained in the memory.

When a new small job arrives or when a big job becomes small, we assign it in the open container. If this container becomes closed, we open a new, empty one. Moreover, it may happen that a previously closed container becomes open again. In this case, we combine open containers as long as we have at least two of them. This completes the description of the algorithm.

For packing the containers, we may also use another algorithm, such as First Fit, which also packs small jobs into a closed container if it fits. This may lead to having a lower number of containers in some cases. However, our upper bound of $2-\frac{1}{m}+\varepsilon$ on the approximation factor lost by this summarization technique holds for any algorithm for packing the containers, as long as they do not exceed the capacity of containers, equal to $2\gamma$. Moreover, the space bound holds if there is a bounded number of containers with $\|\mathbf{c}\|_{\infty}\leq\gamma$.

Properties of the input summary.

After all jobs are processed, we assume again that $\max_{k}\frac{1}{m}\cdot L_{k}=1$, which implies that $\textsf{OPT}\geq 1$. Since any big job and any closed container, each characterized by a vector $\mathbf{v}$, satisfy $\|\mathbf{v}\|_{\infty}>\gamma$, it holds that there are at most $\frac{1}{\gamma}\cdot d\cdot m$ big jobs and closed containers. As at most one container remains open in the end and any job or container is described by $d$ numbers, the space cost is $\mathcal{O}\left(\frac{1}{\gamma}\cdot d^{2}\cdot m\right)=\mathcal{O}\left(\frac{1}{\varepsilon^{2}}\cdot d^{2}\cdot m\cdot\log\frac{d}{\varepsilon}\right)$.

We now analyze the maximum approximation factor that can be lost by this summarization. Let $I_{\mathrm{R}}$ be the resulting instance formed by big jobs and containers with small items (i.e., the input summary), and let $I$ be the original instance, consisting of jobs in the input stream. We show that $\textsf{OPT}(I_{\mathrm{R}})$ and $\textsf{OPT}(I)$ are close together, up to a factor of $2-\frac{1}{m}+\varepsilon$. Note, however, that we still need to execute an offline algorithm to get (an approximation of) $\textsf{OPT}(I_{\mathrm{R}})$, which is not an explicit part of the summary.

The crucial part of the proof is to show that containers for small items can be assigned to machines so that the loads of all machines are nearly balanced in every dimension, especially in the case when containers constitute a large fraction of the total load of all jobs. To capture this, let $L^{\mathrm{C}}_{k}$ be the total load of containers in dimension $k$ (equal to the total load of small jobs). Let $I_{\mathrm{C}}\subseteq I_{\mathrm{R}}$ be the instance consisting of all containers in $I_{\mathrm{R}}$. The following lemma establishes the approximation factor.

Lemma 6**.**

Supposing that $\max_{k}\frac{1}{m}\cdot L_{k}=1$, the following holds:

1. (i)

There is a solution for instance $I_{\mathrm{C}}$ with load at most $\max(\frac{1}{2},\frac{1}{m}\cdot L^{\mathrm{C}}_{k})+2\varepsilon+4\gamma$ in each dimension $k$ on every machine. 2. (ii)

$\textsf{OPT}(I)\leq\textsf{OPT}(I_{\mathrm{R}})\leq\left(2-\frac{1}{m}+3\varepsilon\right)\cdot\textsf{OPT}(I)$.

Proof.

(i) We obtain the solution from the randomized online algorithm by Im et al. [30]. Although this algorithm has ratio $\mathcal{O}(\log d/\log\log d)$ on general instances, we show that it behaves substantially better when jobs are small enough. In a nutshell, this algorithm works by first assigning each job $j$ to a uniformly random machine $i$ and if the load of machine $i$ exceeds a certain threshold, then the job is reassigned by Greedy. The online Greedy algorithm works by assigning jobs one by one, each to a machine so that the makespan increases as little as possible (breaking ties arbitrarily).

Let $L^{\prime}_{k}=\max(\frac{1}{2},\frac{1}{m}\cdot L^{\mathrm{C}}_{k})$. We assume that each machine has its capacity of $L^{\prime}_{k}+2\varepsilon+4\gamma$ in each dimension $k$ split into two parts: The first part has capacity $L^{\prime}_{k}+\varepsilon+2\gamma$ in dimension $k$ for the containers assigned randomly, and the second part has capacity $\varepsilon+2\gamma$ in all dimensions for the containers assigned by Greedy. Note that Greedy cares about the load in the second part only.

The algorithm assigns containers one by one as follows: For each container $\mathbf{c}$, it first chooses a machine $i$ uniformly and independently at random. If the load of the first part of machine $i$ already exceeds $L^{\prime}_{k}+\varepsilon$ in some dimension $k$, then $\mathbf{c}$ is passed to Greedy, which assigns it according to the loads in the second part. Otherwise, the algorithm assigns $\mathbf{c}$ to machine $i$.

As each container $\mathbf{c}$ satisfies $\|\mathbf{c}\|_{\infty}\leq 2\gamma$, it holds that randomly assigned containers fit into capacity $L^{\prime}_{k}+\varepsilon+2\gamma$ in any dimension $k$ on any machine. We show that the expected amount of containers assigned by Greedy is small enough so that they fit into machines with capacity of $\varepsilon+2\gamma$, which in turn implies that there is a choice of random bits for the assignment so that the capacity for Greedy is not exceeded. The existence of a solution with capacity $L^{\prime}_{k}+2\varepsilon+4\gamma$ in each dimension $k$ will follow.

Consider a container $\mathbf{c}$ and let $i$ be the machine chosen randomly for $\mathbf{c}$. We claim that for any dimension $k$, the load on machine $i$ in dimension $k$, assigned before processing $\mathbf{c}$, exceeds $L^{\prime}_{k}+\varepsilon$ with probability of at most $\frac{\varepsilon}{d^{2}}$. To show the claim, we use the following Chernoff-Hoeffding bound:

Fact 7**.**

Let $X_{1},\dots,X_{n}$ be independent binary random variables and let $a_{1},\dots,a_{n}$ be coefficients in $[0,1]$. Let $X=\sum_{i}a_{i}X_{i}$. Then, for any $0<\delta\leq 1$ and any $\mu\geq\mathbb{E}[X]$, it holds that $\Pr[X>(1+\delta)\cdot\mu]\leq\exp\left(-\frac{1}{3}\cdot\varepsilon^{2}\cdot\mu\right)$.

We use this bound with variable $X_{\mathbf{c^{\prime}}}$ for each vector $\mathbf{c^{\prime}}$ assigned randomly before vector $\mathbf{c}$ and not reassigned by Greedy. We have $X_{\mathbf{c^{\prime}}}=1$ if $\mathbf{c^{\prime}}$ is assigned on machine $i$. Let $a_{\mathbf{c^{\prime}}}=\frac{1}{2\gamma}\cdot\mathbf{c^{\prime}}_{k}\leq 1$. Let $X=\sum_{\mathbf{c^{\prime}}}a_{\mathbf{c^{\prime}}}X_{\mathbf{c^{\prime}}}$ be the random variable equal to the load on machine $i$ in dimension $k$, scaled by $\frac{1}{2\gamma}$. It holds that $\mathbb{E}[X]\leq\frac{1}{m}\cdot\frac{1}{2\gamma}\cdot L^{\prime}_{k}\cdot m=\frac{1}{2\gamma}\cdot L^{\prime}_{k}$, since each container $\mathbf{c^{\prime}}$ is assigned to machine $i$ with probability $\frac{1}{m}$ and $L^{\prime}_{k}\cdot m$ is the upper bound on the total load of containers in dimension $k$. Using the Chernoff-Hoeffding bound with $\mu=\frac{1}{2\gamma}\cdot L^{\prime}_{k}$ and $\delta=\varepsilon\leq 1$, we get that

[TABLE]

Using $\gamma=\mathcal{O}\left(\varepsilon^{2}/\log\frac{d^{2}}{\varepsilon}\right)$ and $L^{\prime}_{k}\geq\frac{1}{2}$, we obtain

[TABLE]

where the last inequality holds for a suitable choice of the multiplicative constant in the definition of $\gamma$. This is sufficient to show the claim as $X>(1+\varepsilon)\cdot\frac{1}{2\gamma}\cdot L^{\prime}_{k}$ if and only if the load on machine $i$ in dimension $k$, assigned randomly before $\mathbf{c}$, exceeds $(1+\varepsilon)\cdot L^{\prime}_{k}$.

By the union bound, the claim implies that each container $\mathbf{c}$ is reassigned by Greedy with probability at most $\frac{\varepsilon}{d}$. Let $G$ be the random variable equal to the sum of the $\ell_{1}$ norms (where $\|\mathbf{c}\|_{1}=\sum_{k=1}^{d}\mathbf{c}_{k}$) of containers assigned by Greedy. Using the linearity of expectation and the claim, we have

[TABLE]

where the second inequality uses that the total load of containers in each dimension is at most $m$. Let $\mu_{\mathbf{G}}$ be the makespan of the containers created by Greedy. Observe that each machine has a dimension with load at least $\mu_{\mathbf{G}}-2\gamma$. Indeed, otherwise, if there is a machine $i$ with load less than $\mu_{\mathbf{G}}-2\gamma$ in all coordinates, the last container $\mathbf{c}$ assigned by Greedy that caused the increase of the makespan to $\mu_{\mathbf{G}}$ would be assigned to machine $i$, and the makespan after assigning $\mathbf{c}$ would be smaller than $\mu_{\mathbf{G}}$ (using $\|\mathbf{c}\|_{\infty}\leq 2\gamma$). It follows that $\mu_{\mathbf{G}}-2\gamma\leq\frac{1}{m}\cdot G$ and, using $\mathbb{E}[G]\leq\varepsilon\cdot m$, we get that $\mathbb{E}[\mu_{\mathbf{G}}]-2\gamma\leq\varepsilon$. This concludes the proof that (i) holds.

(ii) The first inequality is straightforward as any solution for $I_{\mathrm{R}}$ can be used as a solution for $I$, just packing small items first in containers that the algorithm created and then the containers according to the solution for $I_{\mathrm{R}}$.

To show the upper bound, we create a solution of $I_{\mathrm{R}}$ of makespan at most $\left(2-\frac{1}{m}+3\varepsilon\right)\cdot\textsf{OPT}(I)$ as follows: We take an optimal solution $\mathcal{S}_{\mathrm{B}}$ for instance $I_{\mathrm{R}}\setminus I_{\mathrm{C}}$, i.e., for big jobs only, and combine it with solution $\mathcal{S}_{\mathrm{C}}$ for containers from (i), to obtain a solution $\mathcal{S}$ for $I_{\mathrm{R}}$ (interestingly, the machine loads from $\mathcal{S}_{\mathrm{B}}$ and $\mathcal{S}_{\mathrm{C}}$ can be combined in an arbitrary way). Let $\mu_{k}$ be the largest load assigned to a machine in dimension $k$ in solution $\mathcal{S}_{\mathrm{B}}$; we have $\mu_{k}\leq\textsf{OPT}(I)$. Note that $L^{\mathrm{C}}_{k}\leq m-\mu_{k}$, since the total load of big jobs and containers together is at most $m$. Consider the load on machine $i$ in dimension $k$ in solution $\mathcal{S}$. If $\frac{1}{m}\cdot L^{\mathrm{C}}_{k}\geq\frac{1}{2}$, then this load is bounded by $\mu_{k}+\frac{1}{m}\cdot L^{\mathrm{C}}_{k}+2\varepsilon+4\gamma\leq\mu_{k}+\frac{1}{m}\cdot(m-\mu_{k})+3\varepsilon=\left(1-\frac{1}{m}\right)\cdot\mu_{k}+1+3\varepsilon\leq\left(2-\frac{1}{m}+3\varepsilon\right)\cdot\textsf{OPT}(I),$ where the first inequality uses $L^{\mathrm{C}}_{k}\leq m-\mu_{k}$ and $\gamma\leq\frac{1}{4}\varepsilon$ (ensured by the definition of $\gamma$), and the last inequality holds by $\mu_{k}\leq\textsf{OPT}(I)$.

Otherwise, $\frac{1}{m}\cdot L^{\mathrm{C}}_{k}<\frac{1}{2}$, in which case the load on machine $i$ in dimension $k$ is at most $\mu_{k}+\frac{1}{2}+2\varepsilon+4\gamma\leq(1.5+3\varepsilon)\cdot\textsf{OPT}(I)\leq(2-\frac{1}{m}+3\varepsilon)\cdot\textsf{OPT}(I)$, using similar arguments as in the previous case and $m\geq 2$. ∎

It remains open whether or not the above algorithm with $\gamma=\Theta(\varepsilon)$ also gives $(2-\frac{1}{m}+\varepsilon)$-approximation, which would imply a better space bound of $\mathcal{O}(\frac{1}{\varepsilon}\cdot d^{2}\cdot m)$. On the other hand, we now give an example showing that the approximation guarantee is at least $2-\frac{1}{m}$ for this approach.

Tight example for the algorithm.

For any $m\geq 2$, we present an instance $I$ in $d=m+1$ dimensions such that $\textsf{OPT}(I)=1$, but $\textsf{OPT}(I_{\mathrm{R}})\geq 2-\frac{1}{m}$, where $I_{\mathrm{R}}$ is the instance created by our algorithm.

Let $\gamma$ be as in the algorithm and assume for simplicity that $\frac{1}{\gamma}$ is an integer. First, $m$ big jobs with vectors $\mathbf{v^{1}},\dots,\mathbf{v^{m}}$ arrive, where $\mathbf{v^{i}}$ is a vector with dimensions $i$ and $m+1$ equal to $1$ and with zeros in the other dimensions (that is, $\mathbf{v^{i}_{\mathit{i}}}=1$ and $\mathbf{v^{i}_{\mathit{m+1}}}=1$, while $\mathbf{v^{i}_{\mathit{k}}}=0$ for $k\notin\{i,m+1\}$). Then, small jobs arrive in groups of $d-1=m$ jobs and there are $(m-1)\cdot\frac{1}{\gamma}$ groups. Each group consists of items $(\gamma,0,\dots,0,0),(0,\gamma,\dots,0,0),\dots,(0,0,\dots,\gamma,0)$, i.e, for each $i=1,\dots,d-1$, it contains one item with value $\gamma$ in coordinate $i$ and with zeros in other dimensions. The groups arrive one by one, with an arbitrary ordering inside the group. Note, however, that these jobs with $\ell_{\infty}$ norm equal to $\gamma$ become small for the algorithm only once the first job from the last group arrives as they are compared to the total load in each dimension, which increases gradually. When they become small, the algorithm will combine each group into one container $(\gamma,\gamma,\dots,\gamma,0)$, which can be achieved by processing the jobs in their arrival order and by having the last vector of the group larger by an infinitesimal amount (we do not take these infinitesimals into account in further calculations). Thus, $I_{\mathrm{R}}$ consists of $m$ big jobs and $(m-1)\cdot\frac{1}{\gamma}$ containers $(\gamma,\gamma,\dots,\gamma,0)$.

Observe that $\textsf{OPT}(I)=1$, since in the optimal solution, each machine $i$ is assigned big job $\mathbf{v^{i}}$ and $\frac{1}{\gamma}$ small jobs with $\gamma$ in dimension $k$ for each $k\in\{1,\dots,d-1\}\setminus\{i\}$. Thus the load equals one on any machine and dimension.

We claim that $\textsf{OPT}(I_{\mathrm{R}})\geq 2-\frac{1}{m}$. Indeed, only one big job can be assigned on one machine, as all of them have value one in dimension $m+1$, so each machine contains one big job. Observe that some machine gets at least $\frac{m-1}{m}\cdot\frac{1}{\gamma}$ containers and thus, it has load of at least $2-\frac{1}{m}$ in one of the $d-1$ first dimensions, which shows the claim.

Note that for this instance to show ratio $2-\frac{1}{m}$ it suffices that the algorithms creates $(m-1)\cdot\frac{1}{\gamma}$ containers $(\gamma,\gamma,\dots,\gamma,0)$. This can be enforced for various greedy algorithms used for packing the small jobs into containers. We conclude that we need a different approach for input summarization to get a ratio below $2-\frac{1}{m}$.

4.2 Rounding Algorithms for Constant Dimension

Makespan Scheduling.

We start by outlining a simple streaming algorithm for $d=1$ based on rounding. Here, each job $j$ on input is characterized by its processing time $p_{j}$ only. The algorithm uses the size of the largest job seen so far, denoted $p_{\mathrm{max}}$, as a lower bound on the optimum makespan. This makes the rounding procedure (and hence, the input summary) oblivious of $m$, the number of machines, which is in contrast with the algorithm in Section 4 that uses just the sum of job sizes as the lower bound.

The rounding works as follows: Let $q$ be an integer such that $p_{\mathrm{max}}\in((1+\varepsilon)^{q},(1+\varepsilon)^{q+1}]$, and let $k=\lceil\log_{1+\varepsilon}\frac{1}{\varepsilon}\rceil=\mathcal{O}(\frac{1}{\varepsilon}\log\frac{1}{\varepsilon})$. A job is big if its size exceeds $(1+\varepsilon)^{q-k}$; note that any big job is larger than $\varepsilon\cdot p_{\mathrm{max}}/(1+\varepsilon)^{2}$. All other jobs are small and have size less than $\varepsilon\cdot p_{\mathrm{max}}$. The algorithm maintains one variable $s$ for the total size of all small jobs and variables $L_{i}$, $i=q-k,\dots,q$, for the number of big jobs with size in $((1+\varepsilon)^{i},(1+\varepsilon)^{i+1}]$ (note that this interval is not scaled by $p_{\mathrm{max}}$, i.e., increasing $p_{\mathrm{max}}$ slightly does not move the intervals).

Maintaining these variables when a new job arrives can be done in a straightforward way. In particular, when an increase of $p_{\mathrm{max}}$ causes that $q$ increases (by $1$ or more as it is integral), we discard all variables $L_{i}$ that do not correspond to big jobs any more, and account for previously big jobs that are now small in variable $s$. However, as the size of these jobs was rounded to a power of $1+\varepsilon$, variable $s$ can differ from the exact total size of small jobs by a factor of at most $1+\varepsilon$.

The created input summary, consisting of $\mathcal{O}(\frac{1}{\varepsilon}\log\frac{1}{\varepsilon})$ variables $L_{i}$ and variable $s$, preserves the optimal value up to a factor of $1+\mathcal{O}(\varepsilon)$. This follows, since big jobs are stored with size rounded up to the nearest power of $1+\varepsilon$, and, although we just know the approximate total size of small jobs, they can be taken into account similarly as when calculating a bound on the number of bins in our algorithm for Bin Packing.

Vector Scheduling.

We describe the rounding introduced by Bansal et al. [8], which we can adjust into a streaming $1+\varepsilon$-approximation for Vector Scheduling in constant dimension. The downside of this approach is that it requires memory exceeding $\left(\frac{2}{\varepsilon}\right)^{d}$, which becomes unfeasible even for $\varepsilon=1$ and $d$ being a relatively small constant. Moreover, such an amount of memory may be needed also in the case of a small number of machines.

We first use the following lemma by Chekuri and Khanna [11], where $\delta=\frac{\varepsilon}{d}$:

Lemma 8** (Lemma 2.1 in [11]).**

Let $I$ be an instance of Vector Scheduling. Let $I^{\prime}$ be a modified instance where we replace each vector $\mathbf{v}$ by vector $\mathbf{v^{\prime}}$ as follows: For each $1\leq i\leq d$, if $\mathbf{v}_{i}>\delta\|\mathbf{v}\|_{\infty}$, then $\mathbf{v^{\prime}}_{i}=\mathbf{v}_{i}$; otherwise, $\mathbf{v^{\prime}}_{i}=0$. Let $\mathcal{S}^{\prime}$ be any solution for $I^{\prime}$. Then, if we replace each vector $\mathbf{v^{\prime}}$ in $\mathcal{S}^{\prime}$ by its counterpart in $I$, we get a solution of $I$ with makespan at most $1+\varepsilon$ times the makespan of $\mathcal{S}^{\prime}$.

In the following, we assume that the algorithms receives vectors from instance $I^{\prime}$, created as in Lemma 8. Let $p_{\mathrm{max}}$ be the maximum $\ell_{\infty}$ norm over all vectors that arrived so far; we use it as a lower bound on OPT. We again do not use the total volume in each dimension as a lower bound, which makes the input summarization oblivious of $m$. A job, characterized by vector $\mathbf{v}$, is said to be big if $\|\mathbf{v}\|_{\infty}>\delta\cdot p_{\mathrm{max}}$; otherwise, $\mathbf{v}$ is small.

We round all values in big jobs to the powers of $1+\varepsilon$. By Lemma 8, we have that either $\mathbf{v}_{k}>\delta^{2}\cdot p_{\mathrm{max}}$ or $\mathbf{v}_{k}=0$ for any big $\mathbf{v}$ and dimension $k$, thus there are $\left\lceil\log_{1+\varepsilon}\frac{1}{\delta^{2}}\right\rceil^{d}=\mathcal{O}\left(\left(\frac{2}{\varepsilon}\log\frac{d}{\varepsilon}\right)^{d}\right)$ types of big jobs at any time. We have one variable $L_{\mathbf{t}}$ counting the number of jobs for each big type $\mathbf{t}$, where $\mathbf{t}$ is an integer vector consisting of the exponents, i.e., if $\mathbf{v}$ is a big vector of type $\mathbf{t}$, then $\mathbf{v}_{i}\in\left((1+\varepsilon)^{\mathbf{t}_{i}},(1+\varepsilon)^{\mathbf{t}_{i}+1}\right]$ (we set $\mathbf{t}_{i}=-\infty$ if $\mathbf{v}_{i}=0$). As in the 1-dimensional case, big types change over time, when $p_{\mathrm{max}}$ (sufficiently) increases.

Note that small jobs cannot be rounded to powers of $1+\varepsilon$ directly. Instead, they are rounded relative to their $\ell_{\infty}$ norms. More precisely, consider a small vector $\mathbf{v}$ and let $\gamma=\|\mathbf{v}\|_{\infty}$. For each dimension $k$, if $\mathbf{v}_{k}>0$, let $\mathbf{t}_{k}\geq 0$ be the largest integer such that $\mathbf{v}_{k}\leq\gamma\cdot(1+\varepsilon)^{-\mathbf{t}_{i}}$, and if $\mathbf{v}_{i}=0$, we set $\mathbf{t}_{i}$ to $\infty$. Then $(\mathbf{t}_{1},\dots,\mathbf{t}_{d})$ is the type of small vector $\mathbf{v}$. Observe that small types do not change over time and there are at most $\mathcal{O}\left(\left(\frac{1}{\varepsilon}\log\frac{d}{\varepsilon}\right)^{d}\right)$ of them. For each small type $\mathbf{t}$, we have one variable $s_{\mathbf{t}}$ counting the sum of the $\ell_{\infty}$ norms of all small jobs of that type.

The variables can be maintained in an online fashion. Namely, when $p_{\mathrm{max}}$ increases, the types for previously big jobs that are now small are discarded, while the jobs that become small are accounted for in small types. For each such former big type $\mathbf{t}$, we compute the corresponding small type as follows: Let $\delta=\|\mathbf{t}\|_{\infty}$ be the maximum value in $\mathbf{t}$ (which is not $-\infty$). The corresponding small type $\mathbf{\hat{t}}$ has then $\mathbf{\hat{t}}_{i}=\delta-\mathbf{t}_{i}$ if $\mathbf{t}_{i}\neq-\infty$, and $\mathbf{\hat{t}}_{i}=\infty$ otherwise. Then we increase $s_{\mathbf{\hat{t}}}$ by $L_{\mathbf{t}}\cdot(1+\varepsilon)^{\delta+1}$.

There are two types of errors introduced due to maintaining variables in the streaming scenario and not offline, where we know the final value of $p_{\mathrm{max}}$ in advance. First, it may happen that a vector $\mathbf{v}$ that was big upon its arrival becomes small, and the small type of $\mathbf{v}$ is different than the small type computed for the former big type of $\mathbf{v}$ (i.e., the small type of $\mathbf{v}$ with values rounded to powers of $1+\varepsilon$). Second, the sum of $\ell_{\infty}$ norms of small vectors of a small type $\mathbf{t}$ is in \big{(}s_{\mathbf{t}}/(1+\varepsilon),s_{\mathbf{t}}], and moreover, the error in some dimension $i$ with $\mathbf{t}_{i}>0$ (i.e., not the largest one for this type) may be of factor up to $(1+\varepsilon)^{2}$, since we may round such a dimension two times for some jobs. Note, however, that by giving up a factor of $1+\mathcal{O}(\varepsilon)$, we may disregard both issues.

The offline algorithm of Bansal et al. [8] implies that such an input summary, consisting of variables for both small and big types, is sufficient for computing $1+\varepsilon$-approximation.

Acknowledgments.

The work is supported by European Research Council grant ERC-2014-CoG 647557. The authors wish to thank Michael Shekelyan for fruitful discussions.