I/O Efficient Algorithms

Problem Data is often too massive to fit in the internal memory The I/O communication between internal memory (fast) and external memory (slower) can be a major performance bottleneck

Goal Design algorithms and data structures for external memory to exploit locality and parallelism in order to reduce I/O costs

Fundamental I/O operations Scanning Sorting Searching Outputting

Bounds N = problem size (in units of data items) B = block transfer size (in units of data items) D = number of independent disk drives Z = number of items of an answer OperationI/O bound, D = 1I/O bound, general D ≥ 1 Scan(N)Θ(N/B) = Θ(n)Θ(N/DB) = Θ(n/D) Sort(N)Θ(N/B log M/B N/B) = Θ(n log m n)Θ(N/DB log M/B N/B) = Θ(n/D log m n) Search(N)Θ(log B N)Θ(log DB N) Output(Z)Θ(max {1, Z/B}) = Θ(max {1,z})Θ(max {1, Z/DB}) = Θ(max {1,z/D})

Types of problems Batched – Scan and Sort Online – Search and Output

External Hashing for Online Dictionary Search Insert O(1) Delete O(1) LookupO(Output(Z))

Statically allocated tables Most commonly/traditionally used Can handle only a fixed range of N Goal is to develop dinamic external memory structures that can easily handle different sizes of data

Extendible Hashing R. Fagin, J. Nievergelt, N. Pippinger, and H. R. Strong assume that the size K of the range of the hash function is sufficiently large directory consists of an array of 2 d pointersfor a given d ≥ 0 (d is the global depth) each item is assigned to the table location corresponding to the d least signifcant bits of its hash address d is set to the smallest value for which each table location has at most B items assigned to it each table location contains a pointer to a block where its items are stored a lookup takes two I/Os: one to access the directory and one to access the block storing the item (only one I/O if the directory fits in internal memory)

Minimizing Storage Utilization a table location may hold fewer than B items, therefore they can share the same disk block for storing their items a table location shares a disk block with all the other table locations having the same k least significant bits in their address k is chosen to be as small as possible so that the pooled items t into a single disk block each disk block has its own local depth

Inserting New Items when a new item is inserted, and its disk block overflows, the global depth d and the block's local depth k are recalculated so that the invariants on d and k once again hold this is done by splitting the block that overflows and redistributing its items global depth d is incremented by 1, the directory doubles in size (this is how the hash is able to adapt to the growing N) pointers in the new directory are set to the appropriate disk blocks the disk blocks themselves do not need to be changed during doubling, except for the one block where the overflow has occured

Inserting New Items when a new item is inserted, and its disk block overflows, the global depth d and the block's local depth k are recalculated so that the invariants on d and k once again hold this is done by splitting the block that overflows and redistributing its items global depth d is incremented by 1, the directory doubles in size (this is how the hash is able to adapt to the growing N) pointers in the new directory are set to the appropriate disk blocks the disk blocks themselves do not need to be changed during doubling, except for the one block where the overflow has occured

Inserting New Items contd. let hash d be the hash function corresponding to the d least significant bits of hash (hash d (x) = hash(x) % 2 d initially a single disk block is created to store the data items, and all the slots in the directory are initialized to point to the block the local depth k of the block is set to 0 when a new item with key value x is inserted, it is stored in the disk block pointed to by directory slot hash d (x) if as a result block b overflows, then b is split into two blocks - the original block b and a new block b’ and its items are redistributed based upon the (b.k + 1)st least signicant bit of hash(x) (b.k = b’s local depth) b.k is incremented by 1 and that value alsostored in in b’.k if the blocks are still overflowing the blocks are split and their sizes are incremented until overflow no longer occurs

after all splits are done, if b.k ≤ d, we just update those directory pointers originally pointing to b that need to be changed if b.k > d then the directory is not large enough to accommodate hash addresses with b.k bits, so we repeatedly double the directory size and increment the global depth d by 1 until d = b.k once again: - pointers in the new directory are initialized to point to the appropriate disk blocks - the disk blocks do not need to be modified during doubling, except for the block that overflows Inserting New Items contd.

deletion is handled very similarly to insertion when two blocks with the same local depth k contain items whose hash addresses share the same k-1 least significant bits and can fit together into a single block, then their items are merged into a single block with a decremented value of k the combined size of the blocks being merged must be sufficiently less than B to prevent immediate splitting after a subsequent insertion the directory shrinks by half and the global depth d is decremented by 1, when all the local depths are less than the current value of d Deleting Items

Some Numbers the expected number of disk blocks required to store the data items is n/ ln 2, therefore the blocks tend to be about 69% full at least Ω(n/B) blocks are needed to store the directory P. Flajolet showed that on the average the directory uses Ѳ(N 1/B n/B) = Ѳ(N 1+1/B /B 2 ) blocks, which can be superlinear in N asymptotically for practical values of N and B, the N 1/B term is a small constant, typically less than 2, and the directory size is within a constant factor of the optimum

So... the resulting directory is equivalent to the leaves of a perfectly balanced tree, in which the search path for each item is determined by its hash address, except that hashing allows the leaves of the tree to be accessed directly in a single I/O therefore any item can be retrieved in a total of two I/Os if the directory ts in internal memory, only one I/O is needed

The End Jeff Vitter's survey paper: