B for every approximately concave function f cache

(b) For every approximately concave function f , cache size k ≥ 2 , and page request
sequence that conforms to f , the page fault rate of the LRU policy is at most
α
f
( k ) plus an additive term that goes to 0 with the sequence length.
(c) There exists a choice of an approximately concave function f , a cache size k ≥ 2 ,
and an arbitrarily long page request sequence that conforms to f , such that the
page fault rate of the FIFO policy is bounded away from α
f
( k ) .
Parts (a) and (b) prove the worst-case optimality of the LRU policy in a strong
and fine-grained sense, f -by- f and k -by- k . Part (c) differentiates LRU from FIFO,
as the latter is suboptimal for some (in fact, many) choices of f and k .
The guarantees in Theorem 1.1 are so good that they are meaningful even when
taken at face value—for strongly sublinear f ’s, α
f
( k ) goes to 0 reasonably quickly
with k . The precise definition of α
f
( k ) for k ≥ 2 is
α
f
( k ) =
k - 1
f - 1 ( k + 1) - 2
, (1.1)
where we abuse notation and interpret f - 1 ( y ) as the smallest value of x such that
f ( x ) = y . That is, f
- 1
( y ) denotes the smallest window length in which page requests
for y distinct pages might appear. As expected, for the function f ( n ) = n we have
α
f
( k ) = 1 for all k . (With no restriction on the input sequence, an adversary can
force a 100% fault rate.) If f ( n ) = d
√
n e , however, then α
f
( k ) scales with 1 /
√
k .
Thus with a cache size of 10,000, the page fault rate is always at most 1%. If
f ( n ) = d 1 + log
2
n e , then α
f
( k ) goes to 0 even faster with k , roughly as k/ 2
k
.
1.3.2 Proof of Theorem 1.1
This section proves the first two parts of Theorem 1.1; part (c) is left as Exercise 1.4.
Part (a). To prove the lower bound in part (a), fix an approximately concave func-
tion f and a cache size k ≥ 2. Fix a deterministic cache replacement policy A .
We construct a page sequence σ that uses only k +1 distinct pages, so at any given
time step there is exactly one page missing from the algorithm’s cache. (Assume that
the algorithm begins with the first k pages in its cache.) The sequence comprises
k - 1 blocks, where the j th block consists of m
j +1
consecutive requests for the same
page p
j
, where p
j
is the unique page missing from the algorithm A ’s cache at the
start of the block. (Recall that m
y
is the number of values of x such that f ( x ) = y .)
This sequence conforms to f (Exercise 1.3).
By the choice of the p
j
’s, A incurs a page fault on the first request of a block,

14 T. Roughgarden
Figure 1.4 Blocks of k - 1 faults, for k = 3.
and not on any of the other (duplicate) requests of that block. Thus, algorithm A
suffers exactly k - 1 page faults.
The length of the page request sequence is m
2
+ m
3
+ · · · + m
k
. Because m
1
= 1,
this sum equals (
∑
k
j =1
m
j
) - 1 which, using the definition of the m
j
’s, equals
( f
- 1
( k +1) - 1) - 1 = f
- 1
( k +1) - 2. The algorithm’s page fault rate on this sequence
matches the definition (1.1) of α
f
( k ), as required. More generally, repeating the
construction over and over again produces arbitrarily long page request sequences
for which the algorithm has page fault rate α
f
( k ).