U. Glaeser

that we refer to as aggressive prefetching.
In each I/O, the next block required from each disk is fetched
provided there is enough free buffer space; if not then only the block demanded immediately by the
computation is read. Such an aggressive prefetching scheme, while intuitively attractive, can be shown
to have poor worst-case as well as average-case performance. There exist worst-case reference strings for
which aggressive prefetching can perform Θ(
D)
times as many I/Os as the optimal scheduling strategy [11].
In the average case, when the accesses are assumed to be randomly distributed across the disks with
independent uniform probability, it has been shown that reading a reference string of length N requires
2
Θ(
N/
D)
I/Os using a buffer of size Ω(
D ) blocks [48].
The problem with aggressive prefetching is that it prefetches too deep on some disks, holding up buffer
space that could better be used in fetching more immediately required blocks. A simple heuristic to
correct for this is to place a bound on the depth of prefetching. One such attractive policy is to always
give priority to a block that is required earlier in the reference string over one that is accessed later,
whenever there is insufficient buffer space to hold both blocks. Intuitively this scheme tries to keep all
disks busy by fetching greedily, but prevents blocks that are prefetched very much earlier than their time
of usage from holding up buffer space that can be used by other more urgently needed blocks. This
greedy algorithm is referred to as earliest required first (ERF) prefetching.
Consider the following example of an I/O system with three disks and an I/O buffer of capacity 6. Let
the blocks labeled a
i
© 2002 by CRC Press LLC
(respectively b
i
a
1
a
2
a
3
a
4
, c ) be placed on disk A (respectively B, C), and the reference string be
i
b
1
c
1
a5
b2
c
2
Figure 33.1(a) shows the I/O schedule constructed by the ERF algorithm described above. In the first
step blocks a1,
b1,
and c1
are fetched concurrently in one I/O. When block a2
is requested, blocks a2,
b2,
and c2
are fetched in parallel in step 2. Subsequently the buffer contains five blocks: a2,
b1,
b2,
c1,
and c2.
Next when a3
is requested, an I/O needs to be done to fetch it; however, there is buffer space for only one
additional block besides a3,
and the choice is between fetching b3,
c3,
or neither. Fetching greedily in the
order of the reference string means that we fetch b3.
Continuing in this manner we obtain a schedule of
length 9. Figure 33.1(b) presents an alternative schedule for the same reference string. The first two steps
in the schedule are identical to the previous case. In step 3, c3
that occurs after b3
is prefetched; and in
step 4, c4
is fetched by evicting b2
even though c4
is referenced only after b4;
however, by doing so the
overall length of the schedule is reduced to 7, better than the previous schedule.
FIGURE 33.1
Disk A a
1
Disk B b
1
Disk C c
1
Disk A a
1
Disk B b
1
Disk C c
1
a
2
b
2
c
2
a
2
a
3
b
3
b 2
c
2
a
4
(a)
a
3
c
3
(b)
a
6
(a) Greedy ERF schedule. (b) Optimal schedule.
b
3
a
5
b
4
c
3
a
4
c
4
c
3
a
7
a
6
c
4
b
4
a
5
b
2
c
5
a
7
c
5
c
4
c
5
a
6
b
3
c
6
c
6
c6
c7
c
7
a
7
b
4
c
7