Contiguous Allocation: Definition, Example, and Use Cases

Contiguous allocation is a method of storing files in consecutive blocks of memory or disk space. It keeps all parts of a file together in one continuous area, making access fast and simple.

How It Works

Imagine you have a row of parking spots, and you want to park a long bus. Contiguous allocation means you park the bus in spots that are next to each other without gaps. Similarly, in computers, files are stored in consecutive blocks on the disk.

This method makes reading files very fast because the system can quickly move from one block to the next without searching for scattered pieces. However, it requires knowing the file size in advance and can cause wasted space if files grow or shrink.

Example

This simple Python example simulates contiguous allocation by storing file blocks in a list representing disk blocks.

python

class Disk:
    def __init__(self, size):
        self.blocks = [None] * size  # None means free block

    def allocate_contiguous(self, file_name, file_size):
        for start in range(len(self.blocks) - file_size + 1):
            if all(block is None for block in self.blocks[start:start+file_size]):
                for i in range(start, start + file_size):
                    self.blocks[i] = file_name
                return start
        return -1  # No space

    def __str__(self):
        return str(self.blocks)

# Create disk with 10 blocks
my_disk = Disk(10)

# Allocate file 'A' with 3 blocks
start_A = my_disk.allocate_contiguous('A', 3)
print(f"File 'A' allocated starting at block {start_A}")

# Allocate file 'B' with 4 blocks
start_B = my_disk.allocate_contiguous('B', 4)
print(f"File 'B' allocated starting at block {start_B}")

# Show disk blocks
print(my_disk)

Output

File 'A' allocated starting at block 0
File 'B' allocated starting at block 3
['A', 'A', 'A', 'B', 'B', 'B', 'B', None, None, None]

When to Use

Contiguous allocation is best when files are mostly fixed in size and fast access is important, such as in simple file systems or embedded devices. It is easy to implement and provides quick sequential access.

However, it is less flexible for files that change size often, because finding a new contiguous space can be difficult, leading to fragmentation. Modern systems often use other methods like linked or indexed allocation for more flexibility.

Key Points

• Contiguous allocation stores files in consecutive blocks.
• It offers fast and simple file access.
• Requires knowing file size beforehand.
• Can cause fragmentation and wasted space.
• Best for fixed-size files and simple systems.

Key Takeaways

Contiguous allocation stores files in consecutive disk blocks for fast access.

It is simple but requires knowing file size in advance.

This method can cause fragmentation if files change size.

Best suited for fixed-size files and systems needing quick sequential reads.

Modern systems often prefer more flexible allocation methods.