Working with the Unix OS

Buffer Cache
algorithm breada /* block read and read ahead */
input: (1) file system block number for immediate read
(2) file system block number for asynchronous read
output: buffer containing data for immediate read
{
if (first block not in cache)
{
get buffer for first block (algorithm getblk);
if (buffer data not valid)
initiate disk read;
}
if (second block not in cache)
{
get buffer for second block (algorithm getblk);
if (buffer data valid)
release buffer (algorithm brelse);
else
initiate disk read;
}
if (first block was originally in cache)
{
read first block (algorithm bread);
return buffer;
}
sleep(event first buffer contains valid data);
return buffer;
}
Figure 74. Algorithm for Block
"breada".
Read Ahead
If the second block is not in buffer cache, the
kernel instructs the disk driver to read it
asynchronously.
algorithm bwrite /* block write * /
input: buffer
output: none
{
initiate disk write;
if (I/O synchronous)
{
sleep(event I/O complete);
release buffer (algorithm brelse);
}
else
if (buffer marked for delayed write)
mark buffer to put at head of free list;
}
Figure 75. Writing a Disk Block Bach, "bwrite".
If the write as asynchronous, the kernel starts the disk write but does not wait for the write to complete. The kernel
will release the buffer when I/O completes.
The kernel marks the buffer "delayed-write" and releases the buffer using "brelse". The kernel writes the block to
disk before another process can reallocate the buffer.
Advantages and Disadvantages of Buffer Cache
- use of buffers allows uniform disk access, (data is part of a file, an inode, or a super block) (simpler system
design).
- system places no data alignment restrictions on user processes doing I/O (because the kernel aligns data
internally).
- use of buffer cache can reduce the amount of disk traffic (increasing throughput and decreasing response time)
("delayed write" avoids unnecessary disk writes) (amount of memory available for buffers).
- buffer algorithms help insure file system integrity (serialize process access - preventing data corruption).
- reduction of disk traffic (vulnerable to crashes that leave disk in an incorrect state).
- use of buffer cache requires an extra data copy when reading and writing to and from user processes (for large
amounts of data - slows down performance) (small amounts - improves performance - cache, delayed write).
Summary
The kernel uses least recently used replacement to keep blocks in buffer cache, assuming that blocks that were
recently accessed are likely to be accessed again soon.
The hash function and hash queues enable the kernel to find particular blocks quickly, and use of doubly linked
lists makes it easy to remove buffers from the lists.
The kernel identifies the block it needs by logical device and block number. "getblk" searches buffer cache for a
block, if present and free, locks the buffer and returns it.
If the buffer is locked, the requesting process sleeps until it becomes free.
If the block is not in the cache, the kernel reassigns a free buffer to the block, locks it and returns.
If kernel determines that is not necessary to copy data immediately to disk, it marks the buffer "delayed-write". A
process is not sure when the data is physically on disk.
186