GATE 2026 OS PYQs | File System and IO Scheduling (JavaScript)

Title: GATE 2026 OS PYQs | File System and IO Scheduling (JavaScript)

Why This Matters

In the realm of computer operating systems, understanding file system and I/O scheduling is crucial for managing system resources efficiently. This knowledge is essential for various exams, including the Graduate Aptitude Test in Engineering (GATE), where it forms part of the Operating System paper. Moreover, mastery of these concepts can help you avoid real-world programming issues that may arise during your career as a software developer or system administrator.

Importance of File System and I/O Scheduling

File systems and I/O scheduling play a significant role in managing the efficient use of disk resources by optimizing the order in which read and write requests are processed. This process is essential because hard drives have a limited number of read-write heads, and seeking to different locations on the disk can be time-consuming. Efficient I/O scheduling can lead to improved system performance, reduced seek times, and overall better user experience.

In JavaScript, we don't directly interact with file system scheduling. However, Node.js uses various I/O scheduling algorithms under the hood when performing file operations using the built-in fs module. The exact algorithm used depends on the operating system and may not be configurable in user-space applications like Node.js.

Prerequisites

Before diving into file system and I/O scheduling, ensure you have a solid understanding of the following topics:

1. JavaScript basics (variables, functions, arrays, objects)
2. Asynchronous programming in JavaScript (promises, async/await)
3. Node.js and its built-in fs module for file system operations
4. Understanding of processes and threads in operating systems
5. Basic understanding of computer architecture, including disk seek times and head movement
6. Familiarity with common I/O scheduling algorithms (FIFO, SJN, RR, Deadline Scheduling, CFQ)

Core Concept

File system and I/O scheduling help manage the efficient use of disk resources by optimizing the order in which read and write requests are processed. This process is essential because hard drives have a limited number of read-write heads, and seeking to different locations on the disk can be time-consuming.

In JavaScript, we don't directly interact with file system scheduling. However, Node.js uses various I/O scheduling algorithms under the hood when performing file operations using the built-in fs module. The exact algorithm used depends on the operating system and may not be configurable in user-space applications like Node.js.

File System Operations

The fs module provides a simple way to perform various file system operations, such as reading, writing, and deleting files. Here's an example of reading a file:

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});

In this example, the readFile function is asynchronous and accepts a callback that will be executed once the file has been read. The first argument is the name of the file to read, the second argument specifies the encoding, and the third argument is the callback that receives the file content or an error object if something goes wrong.

I/O Scheduling Algorithms

While we can't configure the I/O scheduling algorithm in Node.js directly, it's still beneficial to understand some common algorithms used for I/O scheduling:

1. First-In-First-Out (FIFO): This simple algorithm processes requests in the order they arrive. It's easy to implement but can lead to poor performance when multiple large requests are queued.

1. Shortest Job Next (SJN): This algorithm prioritizes smaller I/O operations over larger ones, aiming to complete them quickly and free up resources for other tasks.

1. Round Robin (RR): In this approach, the operating system assigns a fixed time slice to each process in the queue, ensuring that no single process monopolizes the disk. After the time slice expires, the next process is selected.

1. Deadline Scheduling: This algorithm prioritizes requests with shorter deadlines and ensures that they are completed before their deadline. It's particularly useful for real-time systems where timely response is critical.

1. Complete Fair Queuing (CFQ): CFQ aims to provide a fair share of the disk bandwidth to each process by maintaining a per-process queue and distributing I/O requests evenly across all queues.

Worked Example

Let's create a simple Node.js script that reads multiple files concurrently using promises:

const fs = require('fs');
const readFiles = (files) => {
return new Promise((resolve, reject) => {
let results = [];
let processed = 0;

files.forEach(file => {
fs.readFile(file, 'utf8', (err, data) => {
if (err) {
return reject(err);
}
results.push(data);
processed++;
if (processed === files.length) {
resolve(results);
}
});
});
});
};

const files = ['file1.txt', 'file2.txt', 'file3.txt'];
readFiles(files)
.then((data) => console.log(data))
.catch((err) => console.error(err));

In this example, we define a readFiles function that accepts an array of file paths and returns a Promise that resolves with an array of file contents once all files have been read. The function uses asynchronous fs.readFile method to read each file and pushes the results into an array. Once all files have been read, it resolves the promise with the array of file contents.

Common Mistakes

1. Not handling errors: Forgetting to handle errors when performing I/O operations can lead to unexpected behavior or application crashes. Always include error-handling code in your Node.js scripts.

1. Blocking the event loop: Performing blocking I/O operations, such as reading a large file synchronously, can prevent other events from being processed and cause performance issues. Use asynchronous functions like fs.readFile to avoid this problem.

1. Not using promises or async/await: While it's possible to handle multiple concurrent I/O operations using callbacks, using promises or async/await can make your code cleaner and easier to read.

1. Ignoring the impact of I/O scheduling: Although we can't configure I/O scheduling in Node.js directly, understanding how it works can help you design more efficient systems and avoid common pitfalls.

1. Not optimizing for seek times: Seek times are a significant factor in hard drive performance. By organizing files intelligently (e.g., using contiguous allocation or indexing) and minimizing the number of seeks, you can improve overall system performance.

1. Using outdated I/O scheduling algorithms: Some older operating systems may use less efficient I/O scheduling algorithms by default. It's essential to understand the I/O scheduling options available on your specific platform and choose the most appropriate one for your needs.

Practice Questions

1. Write a script that reads the contents of multiple files concurrently using promises instead of callbacks (using async/await).
2. Implement a simple FIFO I/O scheduling algorithm in JavaScript for handling file operations (use a queue data structure to maintain the order of requests).
3. Explain how SJN, RR, and CFQ differ from each other and when they might be useful (provide examples or scenarios where each algorithm would be beneficial).
4. What are some common mistakes to avoid when working with I/O operations in Node.js? (Discuss the importance of error handling, non-blocking I/O, using promises or async/await, and optimizing for seek times.)
5. How can seek times impact the performance of a hard drive, and what strategies can be used to minimize their impact? (Explain the role of contiguous allocation, indexing, and caching in reducing seek times.)

FAQ

1. Why is I/O scheduling important for operating systems?

• I/O scheduling helps manage the efficient use of disk resources by optimizing the order in which read and write requests are processed, reducing seek times and improving overall system performance.

1. Can we configure I/O scheduling algorithms in Node.js?

• No, Node.js does not provide a way to change the I/O scheduling algorithm used under the hood. The exact algorithm used depends on the operating system.

1. What are some common I/O scheduling algorithms used by operating systems?

• Some common I/O scheduling algorithms include First-In-First-Out (FIFO), Shortest Job Next (SJN), Round Robin (RR), Deadline Scheduling, and Complete Fair Queuing (CFQ).

1. Why is it important to handle errors when performing I/O operations in Node.js?

• Handling errors helps ensure that your application can recover gracefully from unexpected situations, preventing crashes or other undesirable behavior.

1. What strategies can be used to minimize seek times on a hard drive?

• Strategies for minimizing seek times include organizing files using contiguous allocation or indexing, minimizing the number of seeks by grouping related data together, and using caching techniques to reduce the need for disk access.