General Caching Is Hard: Even with Small Pages

Abstract

Caching (also known as paging) is a classical problem concerning page replacement policies in two-level memory systems. General caching is the variant with pages of different sizes and fault costs. The strong NP-hardness of its two important cases, the fault model (each page has unit fault cost) and the bit model (each page has the same fault cost as size) has been established, but under the assumption that there are pages as large as half of the cache size. We prove that this already holds when page sizes are bounded by a small constant: The bit and fault models are strongly NP-complete even when page sizes are limited to $\{1, 2, 3\}$. Considering only the decision versions of the problems, general caching is equivalent to the unsplittable flow on a path problem and therefore our results also improve the hardness results about this problem.

Appendix: The Simple Proof

In this appendix, we present a simple variant of the proof for the almost-fault model with two distinct costs. This completes the sketch of the proof presented at the end of Sect. 2. We present it with a complete description of the simplified reduction, so that it can be read independently of the rest of the paper. This appendix can therefore serve as a short proof of the hardness of general caching.

Theorem 6.1

General caching is strongly NP-hard, even in the case when page sizes are limited to 1, 2, 3 and there are only two distinct fault costs.

We prove the theorem for the optional policy. It is easy to obtain the theorem also for the forced policy the same way as in the proof of Theorem 5.1.

1.1 The Reduction

The reduction described here will be equivalent to Reduction 2.1 with $H = 1$ and the fault cost of each vertex-page set to $1/(n+1)$.

Suppose we have a graph $G=(V,E)$ with n nodes and m edges. We construct an instance of general caching whose optimal solution encodes a maximum independent set in G. Fix an arbitrary numbering of edges $e_1, \ldots , e_m$.

The cache size is $C=2m+1$. For each vertex v, we have a vertex-page $p_v$ with size one and cost $1/(n+1)$. For each edge e, we have six associated edge-pages $a^e, \bar{a}^e, \alpha ^e, b^e, \bar{b}^e, \beta ^e$; all have cost one, pages $\alpha ^e,\beta ^e$ have size three and the remaining pages have size two.

The request sequence is organized in phases and blocks. There is one phase for each vertex. In each phase, there are two adjacent blocks associated with every edge e incident with v; the incident edges are processed in an arbitrary order. In addition, there is one initial block I before all phases and one final block F after all phases. Altogether, there are $d=4m+2$ blocks. There are four blocks associated with each edge e; denote them $B^e_1$, $B^e_2$, $B^e_3$, $B^e_4$, in the order as they appear in the request sequence.

For each $v\in V$, the associated page $p_v$ is requested exactly twice, right before the beginning of the v-phase and right after the end of the v-phase; these requests do not belong to any phase. An example of the structure of phases and blocks is given in Fig. 6.

Fig. 6

An example of phases, blocks and requests on vertex-pages for a graph with three vertices u, v, w and two edges $e_1 = \{u, w\}$, $e_2 = \{v, w\}$ when $H = 2$

Even though each block is associated with some fixed edge, it contains one or more requests to the associated pages for every edge e. In each block, we process the edges $e_1,\ldots ,e_m$ in this order. For each edge e, we make one or more requests to the associated pages according to Table 3.

Table 3 Requests associated with an edge e

Figure 7 shows an example of the requests on edge-pages associated with one particular edge.

Fig. 7

Requests on all pages associated with the edge e. Each column represents some block(s). The four labeled columns represent the blocks in the heading, the first column represents every block before $B^e_1$, the middle column represents every block between $B^e_3$ and $B^e_4$, and the last column represents every block after $B^e_4$. The requests in one column are ordered from top to bottom

1.2 Proof of Correctness

Instead of minimizing the service cost, we maximize the saving compared to the service which does not use the cache at all. This is clearly equivalent when considering the decision version of the problem.

Without loss of generality, we assume that any page is brought into the cache only immediately before a request to that page and removed from the cache only immediately after a request to that page; furthermore, at the beginning and at the end the cache is empty. I.e., a page may be in the cache only between two consecutive requests to this page, and either it is in the cache for the whole interval or not at all.

Each page of size three is requested only twice in two consecutive blocks, and these blocks are distinct for all pages of size three. Thus, a service of edge-pages is valid if and only if at each time, at most m edge-pages are in the cache. It is thus convenient to think of the cache as of m slots for edge-pages.

Each vertex-page is requested twice. Thus, the saving on the n vertex-pages is at most $n/(n+1)<1$. Since all edge-pages have cost one, the optimal service must serve them optimally. Furthermore, a vertex-page can be cached if and only if during the phase it never happens that at the same time all slots for edge-pages are full and a page of size three is cached.

Let $S_B$ denote the set of all edge-pages cached at the beginning of the block B and let $s_B = |S_B|$. Now observe that each edge-page is requested only in a contiguous segment of blocks, once in each block. It follows that the total saving on edge-pages is equal to $\sum _B s_B$ where the sum is over all blocks. In particular, the maximal possible saving on the edge-pages is $(d-1)m$, using the fact that $S_I$ is empty.

We prove that there is a service with the total saving at least $(d-1)m+K/(n+1)$ if and only if there is an independent set of size K in G. First the easy direction.

Lemma 6.2

Suppose that G has an independent set W of size K. Then there exists a service with the total saving $(d-1)m+K/(n+1)$.

Proof

For any e, denote $e=\{u, v\}$ so that u precedes v in the ordering of phases. If $u\in W$, we keep $\bar{a}^e, b^e, \bar{b}^e$ and $\beta ^e$ in the cache from the first to the last request on each page, and we do not cache $a^e$ and $\alpha ^e$ at any time. Otherwise we cache $\bar{b}^e, a^e, \bar{a}^e$ and $\alpha ^e$, and do not cache $b^e$ and $\beta ^e$ at any time. In both cases, at each time at most one page associated with e is in the cache and the saving on those pages is $(d-1)m$. See Fig. 8 for an illustration.

Fig. 8

The two ways of caching in Lemma 6.2

For any $v\in W$, we cache $p_v$ between its two requests. To check that this is a valid service, observe that if $v\in W$, then during the corresponding phase no page of size three is cached. Thus the page $p_v$ always fits in the cache together with at most m pages of size two. $\square$

Now we prove the converse in a sequence of claims. Fix a valid service with saving at least $(d-1)m$. For a block B, let $B^{\prime }$ denote the following block.

Claim 6.3

For any block B, with the exception of $B=I$, we have $s_B=m$.

Proof

For each $B\ne I$ we have $s_B\le m$. Because $s_I = 0$, the total saving on edge-pages is $\sum _B s_B\le (d-1)m$. We need an equality. $\square$

We now prove that each edge occupies exactly one slot during the service.

Claim 6.4

For any block $B\ne I$ and for any e, $S_B$ contains exactly one page associated with e.

Proof

Let us use the notation $S_B^{\le k} = S_B^{e_1} \cup \cdots \cup S_B^{e_k}$ and $s_B^{\le k} = \left| S_B^{\le k}\right|$. First, we shall prove for each $k \le m$

$$\begin{aligned} s_B^{\le k} = k. \end{aligned}$$

(8)

This is true for $B=F$, as only the m edge-pages $\bar{b}^e$ can be cached there, and by the previous claim all of them are indeed cached. Similarly for $B=I^{\prime }$ (i.e., immediately following the initial block).

If (8) is not true, then for some k and $B\not \in \{I,F\}$ we have $s_B^{\le k}<s_{B^{\prime }}^{\le k}$. Then after processing the edge $e_k$ in the block B we have in the cache all the pages in $(S_B{\setminus }S_B^{\le k})\cup S_{B^{\prime }}^{\le k}$. Their number is $(m-s_B^{\le k})+s_{B^{\prime }}^{\le k}>m$, a contradiction.

The statement of the claim is an immediate consequence of (8). $\square$

Claim 6.5

For any edge e, at least one of the pages $\alpha ^e$ and $\beta ^e$ is cached between its two requests.

Proof

Assume that none of the two pages is cached. It follows from the previous claim that $b^e\in S_{B^e_2}$, as at this point $\alpha ^e$ and $b^e$ are the only pages associated with e that can be cached. Similarly, $a^e\in S_{B^e_4}$.

It follows that there exists a block B between $B^e_1$ and $B^e_4$ such that $S_B$ contains the page $b^e$ and $S_{B^{\prime }}$ contains the page $a^e$. However, in B, the page $a^e$ is requested before the page $b^e$. Thus at the point between the two requests, the cache contains two pages associated with e, plus one page associated with every other edge, the total of $m+1$ pages, a contradiction. $\square$

Now we are ready to complete this direction.

Lemma 6.6

Suppose that there exists a valid service with the total saving $(d-1)m+K/(n+1)$. Then G has an independent set W of size K.

Proof

Let W be the set of all v such that $p_v$ is cached between its two requests. The total saving implies that $|W|=K$.

Now we claim that W is independent. Suppose not, let $e=uv$ be an edge with $u,v\in W$. Then $p_u$ and $p_v$ are cached in the corresponding phases. Thus neither $\alpha ^e$ nor $\beta ^e$ can be cached, since together with other $m-1$ requests of size 2 associated with the remaining edges, the cache size needed would be $2m+2$. However, this contradicts the last claim. $\square$

Lemmas 6.2 and 6.6 together show that we constructed a valid polynomial-time reduction from the problem of independent set to general caching. Therefore, Theorem 6.1 is proven.