Contiguous allocation in Operating Systems - Mini Project: Build & Apply

Understanding Contiguous Allocation in Operating Systems

📖 Scenario: You are learning how operating systems manage files on a disk using contiguous allocation. This method stores each file in one continuous block of disk space.Imagine a simple disk divided into blocks, and files stored in these blocks without gaps.

🎯 Goal: Build a simple representation of disk blocks and files using contiguous allocation. You will create a data structure to represent files and their starting block and length, then write logic to check if a new file can fit contiguously on the disk.

📋 What You'll Learn

Create a dictionary called disk_files with file names as keys and a tuple of (start_block, length) as values

Create a variable called disk_size representing total disk blocks

Write a function can_allocate_contiguous that checks if a new file can fit contiguously given a start block and length

Add a final check to see if a new file named 'FileC' starting at block 5 with length 3 can be allocated

💡 Why This Matters

🌍 Real World

Contiguous allocation is a basic method used in file systems to store files efficiently and quickly access them.

💼 Career

Understanding file allocation methods helps in roles related to system administration, software development, and operating system design.

1

Create the initial disk files dictionary

Create a dictionary called disk_files with these exact entries: 'FileA': (0, 4) and 'FileB': (4, 3) representing files and their start block and length on the disk.

Operating Systems

# Create the disk_files dictionary with FileA and FileB
# Your code here

Need a hint?

Use a dictionary with file names as keys and tuples for (start_block, length) as values.

2

Set the total disk size

Create a variable called disk_size and set it to 10 representing the total number of blocks on the disk.

Operating Systems

disk_files = {'FileA': (0, 4), 'FileB': (4, 3)}
# Set disk_size to 10
# Your code here

Need a hint?

Just assign the number 10 to the variable disk_size.

3

Write the allocation check function

Write a function called can_allocate_contiguous that takes start_block and length as parameters and returns True if the file fits contiguously on the disk without overlapping existing files, otherwise False. Use the disk_files and disk_size variables.

Operating Systems

disk_files = {'FileA': (0, 4), 'FileB': (4, 3)}
disk_size = 10
# Define can_allocate_contiguous function
# Your code here

Need a hint?

Check if the requested block range overlaps with any existing file's block range.

4

Check allocation for a new file

Add a variable called file_c_can_allocate that stores the result of calling can_allocate_contiguous with start_block=5 and length=3 to check if 'FileC' can be allocated contiguously.

Operating Systems

disk_files = {'FileA': (0, 4), 'FileB': (4, 3)}
disk_size = 10

def can_allocate_contiguous(start_block, length):
    if start_block  disk_size:
        return False
    for _, (s, l) in disk_files.items():
        if not (start_block + length = s + l):
            return False
    return True

# Check if FileC can be allocated starting at block 5 with length 3
# Your code here

Need a hint?

Call the function with the given start block and length, and assign the result to file_c_can_allocate.