Algorithms and Data Structures for External Memory

46 External Sorting and Related Problems
blocks of Σ in reverse order. In the case of the write-once problem, the
following natural greedy output algorithm is optimum: As the blocks
of Σ R are written, we put each block into an output buffer for its
designated disk. There are m output buffers, each capable of storing
one block, so the writing can proceed only as quickly as space is freed
up in the write buffers. In each parallel I/O step, we free up space by
outputting a queued block to each disk that has at least one block in
an output buffer. The schedule of I/O output steps is called the output
schedule, and it is easy to see that it is optimum in terms of the number
of parallel I/O steps required. Figure 5.6, when read right to left, shows
the output schedule for the reverse sequence Σ R .
When we run any output schedule for Σ R in reverse, we get a valid
prefetch schedule for the original sequence Σ, and vice versa. Therefore,
an optimum output schedule for Σ R , which is easy to compute in a
greedy fashion, can be reversed to get an optimum prefetch schedule
for Σ. Figure 5.6, when considered from right to left, shows an optimum
output schedule for sequence Σ R . When looked at left to right, it shows
an optimum prefetch schedule for sequence Σ.
The prefetch schedule of Figure 5.6 is “lazy” in the sense that the
input I/Os seem to be artificially delayed. For example, cannot block e
be input earlier than in step 4? Hutchinson et al. [202] give a prudent
prefetching algorithm that guarantees the same optimum prefetch
schedule length, but performs I/Os earlier when possible. It works by
redefining the priority of a block to be the order it appears in the input
step order of the lazy schedule (i.e., a, b, f, c, i, . . . in Figure 5.6).
Prefetch buffers are “reserved” for blocks in the same order of priority.
In the current I/O step, using the language of Section 5.3.1, we input
every block in P that has a reserved prefetch buffer. Figure 5.7 shows
the prudent version of the lazy schedule of Figure 5.6. In fact, if we
iterate the prudent algorithm, using as the block priorities the input
step order of the prudent schedule of Figure 5.7, we get an even more
prudent schedule, in which the e and n blocks move up one more I/O
step than in Figure 5.7. Further iteration in this particular example
will not yield additional improvement.