Memory-mapped files in Operating Systems - Step-by-Step Execution

Concept Flow - Memory-mapped files

Process requests file data

↓

OS maps file into memory

↓

Process accesses memory address

↓

If page in RAM: data returned immediately

No↓

Page fault triggers disk read

↓

Data loaded into RAM page

↓

Process continues with data

↓

Changes in memory can be synced back to file

The process asks for file data, OS maps the file into memory, process accesses memory addresses. If data is not in RAM, a page fault loads it from disk. Changes can be saved back to the file.

Execution Sample

Operating Systems

1. Open file
2. Map file to memory
3. Read data via memory
4. Modify data in memory
5. Sync changes to file

This sequence shows how a file is opened, mapped into memory, accessed and modified through memory, then changes are saved back.

Analysis Table

Step	Action	Memory State	Disk Access	Result
1	Open file	No mapping yet	No	File descriptor ready
2	Map file to memory	Mapping created, no pages loaded	No	Memory addresses linked to file
3	Read data at address	Page not in RAM	Yes	Page fault triggers disk read
4	Load page into RAM	Page loaded in RAM	Yes	Data available in memory
5	Process reads data	Page in RAM	No	Data returned immediately
6	Modify data in memory	Page modified in RAM	No	Changes in memory only
7	Sync changes to file	Page in RAM	Yes	Changes written back to disk
8	Close file	Mapping removed	No	Resources freed

💡 File closed and memory mapping removed, process ends

State Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	After Step 7	Final
File Descriptor	None	Open	Open	Open	Open	Closed
Memory Mapping	None	Created	Page Loaded	Page Modified	Page Modified	Removed
RAM Page	Empty	Empty	Loaded with data	Modified data	Modified data	Empty

Key Insights - 3 Insights

Why does accessing a memory address sometimes cause a disk read?

Because the page is not yet loaded into RAM, causing a page fault that triggers the OS to read the data from disk (see execution_table step 3).

Are changes made in memory immediately saved to the file?

No, changes are first made in RAM and only saved back to the file when syncing occurs (see execution_table step 7).

What happens when the file is closed?

The memory mapping is removed and resources like file descriptors are freed (see execution_table step 8).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the page fault occur?

A Step 7

B Step 5

C Step 3

D Step 2

💡 Hint

Check the 'Disk Access' column where it says 'Page fault triggers disk read' at step 3.

According to the variable tracker, what is the state of the RAM page after step 6?

A Loaded with data

B Modified data

C Empty

D Removed

💡 Hint

Look at the 'RAM Page' row under 'After Step 6' in the variable tracker.

If the process never modifies data, which step in the execution table would be skipped?

A Step 7

B Step 4

C Step 6

D Step 8

💡 Hint

Refer to the 'Action' column where 'Sync changes to file' happens only if data was modified.

Concept Snapshot

Memory-mapped files let a process access file data via memory addresses.
OS maps file pages into RAM on demand (page faults trigger disk reads).
Process reads/writes memory directly; changes can be synced back to disk.
This improves performance by avoiding explicit read/write calls.
Mapping is removed when file is closed.

Full Transcript

Memory-mapped files allow a program to treat file contents as if they are part of its memory. When a file is opened and mapped, the operating system links the file's data to memory addresses. When the program accesses these addresses, if the data is not already in RAM, a page fault occurs, and the OS loads the needed data from disk into RAM. The program can then read or modify the data directly in memory. Changes made in memory are not immediately saved to the file; they are written back when syncing occurs. Finally, when the file is closed, the memory mapping is removed and resources are freed.

Practice

1. What is the main advantage of using memory-mapped files in an operating system?

easy

A. They allow programs to access file data as if it were in memory, improving speed.

B. They compress files automatically to save disk space.

C. They encrypt files for security purposes.

D. They convert files into executable programs.

Solution

1. Step 1: Understand what memory-mapped files do

   Memory-mapped files let programs treat file contents like part of the computer's memory.

2. Step 2: Identify the benefit of this approach

   This allows faster and easier access to file data without explicit read/write calls.

3. Final Answer:

   They allow programs to access file data as if it were in memory, improving speed. -> Option A

4. Quick Check:

   Memory-mapped files = fast file access [OK]

Hint: Memory-mapped files map files to memory for speed [OK]

Common Mistakes:

• Confusing memory-mapping with file compression
• Thinking memory-mapping encrypts files
• Assuming memory-mapping creates executables

2. Which system call is commonly used on Unix-like systems to create a memory-mapped file?

easy

A. open()

B. fork()

C. mmap()

D. exec()

Solution

1. Step 1: Recall Unix system calls related to memory mapping

   The mmap() system call is designed to map files or devices into memory.

2. Step 2: Differentiate from other system calls

   open() opens files, fork() creates processes, and exec() runs programs, none map files to memory.

3. Final Answer:

   mmap() -> Option C

4. Quick Check:

   Unix memory mapping = mmap() [OK]

Hint: Unix memory mapping uses mmap() call [OK]

Common Mistakes:

• Choosing open() instead of mmap()
• Confusing fork() with memory mapping
• Thinking exec() maps files

3. Consider this pseudocode using memory-mapped files:

map = mmap(file)
map[0] = 'A'
print(file.read(1))

What will be printed?

medium

A. Nothing, because mmap disables file reading

B. The first byte of the file before mapping

C. An error because file.read() conflicts with mmap

D. 'A', the updated first byte via memory mapping

Solution

1. Step 1: Understand memory-mapped file behavior

   Writing to the mapped memory changes the file content directly.

2. Step 2: Analyze the print statement

   Reading the first byte from the file after mapping reflects the change 'A'.

3. Final Answer:

   'A', the updated first byte via memory mapping -> Option D

4. Quick Check:

   Memory map write updates file content [OK]

Hint: Changes in mmap reflect in file reads immediately [OK]

Common Mistakes:

• Assuming file.read() shows old data
• Thinking mmap disables file reading
• Expecting an error from simultaneous access

4. Identify the error in this memory-mapped file usage snippet:

fd = open('data.txt', 'r')
map = mmap(fd, length=100)
map[0] = 'B'

medium

A. Length parameter must be zero for mmap

B. File opened in read-only mode but writing to map attempted

C. File descriptor should be closed before mmap

D. map[0] cannot be assigned a character

Solution

1. Step 1: Check file open mode

   The file is opened with 'r' (read-only), so writing to mapped memory is not allowed.

2. Step 2: Understand mmap write restrictions

   Writing to a read-only mapped area causes an error or undefined behavior.

3. Final Answer:

   File opened in read-only mode but writing to map attempted -> Option B

4. Quick Check:

   Read-only file + write mmap = error [OK]

Hint: Write to mmap needs writable file open mode [OK]

Common Mistakes:

• Ignoring file open mode when writing
• Thinking length=0 is required
• Believing file must be closed before mmap

5. You want to share data between two running processes efficiently. Which feature of memory-mapped files helps achieve this?

hard

A. Mapping the same file into both processes' memory spaces to share data

B. Compressing the file to reduce memory usage

C. Encrypting the file to secure shared data

D. Automatically syncing file changes to a remote server

Solution

1. Step 1: Understand inter-process communication needs

   Sharing data between processes requires a common memory area accessible to both.

2. Step 2: Identify memory-mapped file feature for sharing

   Mapping the same file into both processes' memory allows them to read/write shared data efficiently.

3. Final Answer:

   Mapping the same file into both processes' memory spaces to share data -> Option A

4. Quick Check:

   Memory-mapped files enable shared memory between processes [OK]

Hint: Shared mapping = shared data between processes [OK]

Common Mistakes:

• Confusing compression with sharing
• Assuming encryption shares data
• Thinking syncing to server shares memory