The optimal structure of algorithms for α-paging

Highlights

• Structure of the optimal offline algorithm OPT for an existing paging model for Flash memory devices.

• An online characterization of OPT is provided.

• OPTMark, a class of online algorithms based on OPT is proposed.

• Empirical results show that algorithms from OPTMark can outperform LRU.

Abstract

Paging is an important part of data management between two memory hierarchies, a fast cache and a slow disk. Its main application areas are modern operating systems and databases. Paging algorithms need to take decisions without precisely knowing the future behavior of the system, therefore paging is one of the most studied problems in the field of online-algorithms. In this paper we consider α-paging [13], a variation of the classical paging problem. It models the asymmetry between reading and writing data when the slow disk is implemented by means of flash memory. We develop an online structure that keeps track of the cache contents of the optimal offline algorithm. Based on this structure we design the algorithm class OPTMark which has the best possible competitive ratio and performs well on real-world traces.

Introduction

Flash memory combines the advantages of semiconductor-based memory and non-volatile data storage devices: it allows fast random read access and no power supply is needed for archiving data. Compared to mechanical hard-disks flash memory devices are lighter, more shock-resistant and consume less power. Due to their decreasing price they have become an economically competitive alternative in many areas (in particular for mobile computing). Like most other storage technologies, flash memory works block-based. However, modifying a block on flash memory typically requires rewriting a number of neighboring blocks as well. Therefore, best writing performance is achieved by sequentially writing several neighboring blocks at once, whereas reading can be done efficiently by reading only a single block at once [2]. We consider this read/write asymmetry for the paging problem on two-level memory hierarchies. Paging strategies decide which memory pages reside in the fast and small cache (e.g. RAM) and which have to be loaded upon access from a slower and larger disk (e.g. a flash memory device).

Provided with a cache of fixed size k and a disk of infinite size we have to serve a sequence of requests to memory pages of equal size. If the currently requested page is in the cache we are done; otherwise the requested page needs to be loaded from the disk into the cache, and we say that a page fault occurs. Upon a page fault the paging algorithm needs to decide which page to replace, if the cache is full. In the classical paging problem the goal is to minimize the number of page faults. There exist many variations of this simple core problem, e.g. using page weights [9], varying the cache size [14] or requesting sets of pages instead of single pages [8].

In the α-paging model [13] it is assumed that pages evicted from the cache need to be written back to disk and that this is more efficient if done in bundles. Upon one eviction the algorithm is allowed to write out up to α arbitrary pages in order to make room for new ones. In contrast to the classical model the cost for α-paging is given by the number of evictions.

More precise, upon request of page p the algorithm pays cost 0 for loading p into the cache if needed. Since the cache size is bounded by k the algorithm may need to perform evictions to make room for new pages. In each step an arbitrary number of bundles $B_1,B_2,\dots ,B_l$, each containing at most α pages can be evicted at the cost of l (number of bundles). Although the model permits evictions at every page request, it was shown that it suffices to consider only lazy algorithms [13]. Lazy algorithms evict at most one bundle, and they do so iff the cache is full and the requested page is not in the cache.

Simple algorithms like LRU can be adapted in a straightforward way, e.g. α-LRU evicts the α least-recently requested pages instead of the least recently requested page. Note that for $\alpha =1$ the model is equivalent to the classical paging model (up to a constant additive cost factor due to the different cost measure).

Note that α-paging captures some but not all characteristics of flash memory devices in paging scenarios. An important aspect concerns the degree of freedom to choose a set of α jointly evicted pages. If those were to be written back to their original positions on flash memory, improved writing behavior would only occur if these positions happen to be adjacent on the device. In practice, however, so-called flash translation layers like the ones used in EasyCo [7] or ExtremeFFS [17] efficiently overcome this issue by re-mapping the logical positions of those α flash pages so that they can be physically written in neighboring device positions whereas their old positions are internally marked to be invalid. Occasional compaction phases rearrange invalid slots so that they can be reused in consecutive fashion. Another issue not captured by this model is that reading pages from flash memory is not for free in practice.

The most prominent way to analyze online algorithms is competitive analysis [11], [18], where the cost of the online algorithm is compared to the cost of the optimal offline solution, i.e. an algorithm having full knowledge about the input sequence. A deterministic online algorithm A is c-competitive if for any input sequence it holds that

$$\mathit{cost}(A)\le c\cdot \mathit{cost}(\mathit{OPT})+b,$$

where $\mathit{cost}(A)$ and $\mathit{cost}(\mathit{OPT})$ denote the cost of A and the optimal offline cost respectively, and b is a constant. For deterministic algorithms the lower bound on the competitive ratio is k [18]. Three of the most prominent k-competitive paging algorithms are LRU (Least Recently Used), FIFO (First In First Out) and FWF (Flush When Full) [18]. For relevant results on online algorithms, we refer the reader to comprehensive surveys in [3], [5]. In the α-paging model it was shown that $k/\alpha$ is a lower bound on the competitive ratio [13]. The lower bound is matched by the $k/\alpha$-competitive algorithm α-LRU.

For classical paging a simple optimal offline algorithm MIN is known [4], and works by evicting, upon a cache miss, the page in cache which is re-requested farthest in the future. Its adaptation α-MIN [13] evicts the α farthest distinct pages and was shown to be optimal in the α-paging model. An online characterization of the optimal offline algorithm describes precisely OPT's possible cache contents given only the sequence seen so far. The first online characterizations of MIN were provided in [15] for the design and analysis of the first strongly competitive algorithm and in [12] in order to prove that LRU is optimal in the diffuse adversary model. Alternative descriptions were provided in [1] and [6] for the purpose of space-efficient strongly competitive randomized algorithms.

In [16] the characterization from [6] was used for designing deterministic online algorithms which always cache all revealed pages, these are pages which are for sure in MIN's cache independent of the future requests. This approach always leads to k-competitive algorithms. More important is the observation that most requests in real-word inputs are requests to revealed pages.

We provide an online characterization of the optimal offline algorithm for α-paging and prove its correctness. It is an adaptation of the characterization from [6]. After each request it splits the page-set in three categories:

• revealed pages, contained in the optimal cache for all possible future requests

• pages which are not in the optimal cache for all possible future requests

• pages, where both possible scenarios for the future exist, one where they belong to the optimal cache and one where they do not.

Using this structure, we propose a new priority-based marking class, which is $k/\alpha$ competitive and caches preferentially revealed pages. We combine our algorithm class with the future prediction strategy RDM [16] and perform trace-driven simulations. We conclude that the resulting algorithm can outperform adaptations of FIFO and LRU.