GATE 2026 OS PYQs | MEMORY MANAGEMENT AND VIRTUAL MEMORY (JavaScript)

Title: GATE 2026 OS PYQs | Memory Management and Virtual Memory (JavaScript)

Why This Matters

Understanding memory management and virtual memory is crucial for the GATE Operating System paper. These concepts are essential to grasp the inner workings of an operating system, which is vital in designing and developing efficient systems. Moreover, real-world programming often involves managing memory effectively to prevent bugs and improve performance.

In this lesson, we will delve into memory management and virtual memory as they apply to JavaScript, focusing on heap and stack memory, memory leaks, and the concept of virtual memory in a browser environment. We'll also discuss important topics like garbage collection, event listeners, closures, circular references, and optimization techniques.

Prerequisites

Before diving into memory management and virtual memory, you should have a good understanding of:

1. Basic JavaScript syntax and control structures (loops, conditionals)
2. Data structures like arrays and objects
3. Callback functions and event-driven programming
4. Understanding the browser environment and its limitations
5. Familiarity with common JavaScript algorithms and data structures such as sorting algorithms and hash tables
6. Basic understanding of operating systems and their memory management techniques (optional but beneficial)
7. Knowledge of object-oriented programming concepts like classes, objects, and inheritance (optional but helpful)

Core Concept

Memory Management in JavaScript

JavaScript manages memory using a garbage collector that automatically frees up memory occupied by objects that are no longer being used. The garbage collector runs periodically to identify and free unused memory. However, it's essential to write efficient code to minimize the impact on performance.

Heap vs Stack Memory

JavaScript has two types of memory: heap and stack.

• Heap: Stores objects created using new or by assigning values to variables. The garbage collector manages the heap. When an object is no longer referenced, it becomes eligible for garbage collection.
• Stack: Used for function calls, arguments, and local variables. When a function is called, a new activation record is pushed onto the stack, and it's popped off when the function returns. Stack memory is managed automatically by the JavaScript engine.

Garbage Collection

The garbage collector in JavaScript runs periodically to identify and free unused objects in the heap. It uses various algorithms like mark-and-sweep or generational collection to achieve this. However, the exact algorithm used may vary between different JavaScript engines.

Memory Leaks

Memory leaks occur when memory that should be freed by the garbage collector remains occupied by unused objects. This can lead to poor performance or even crashes in your application. Common causes of memory leaks include:

1. Global variables: Declaring global variables can lead to memory leaks, as they are never garbage collected. Instead, use let or const for local variables whenever possible.
2. Event listeners: Attaching event listeners to elements that are no longer used can cause memory leaks. Make sure to remove event listeners when they're no longer needed using the removeEventListener method.
3. Infinite loops: Infinite loops can consume a significant amount of memory and lead to performance issues or crashes. Ensure your code doesn't have any infinite loops.
4. Closures: Using closures can create references to variables outside their scope, which may not be garbage collected as expected. Be mindful of how you use closures in your code.
5. Circular references: Circular references between objects prevent them from being garbage collected because each object still has a reference to the other. Breaking these circular references can help avoid memory leaks.
6. Large objects: Creating large objects or arrays can consume a significant amount of memory and lead to performance issues if not handled properly.
7. Long-lived DOM elements: Keeping DOM elements in memory for an extended period can cause memory leaks, especially when these elements are not needed anymore. Make sure to remove unnecessary elements from the DOM.
8. Caching: Improper caching strategies can lead to memory leaks, as cached data may not be garbage collected when it's no longer needed. Use efficient caching techniques like LRU (Least Recently Used) cache to avoid such issues.

Virtual Memory

Virtual memory allows an operating system to use more memory than physically available by temporarily swapping data between the RAM (random access memory) and secondary storage (like hard drives). This is crucial for handling large programs that require more memory than what's available in the system.

In JavaScript, there isn't a direct way to implement virtual memory due to its single-threaded nature and the fact that it runs inside a browser environment. However, modern browsers employ various techniques like background garbage collection, compaction, and tiered caching to optimize memory usage and simulate some aspects of virtual memory.

Worked Example

Let's create a simple JavaScript application that demonstrates memory leaks and how to avoid them.

// Create a global variable, which causes a memory leak
let globalVar = "Global Variable";

function createObject() {
// Create an object that will be garbage collected eventually
let obj = {};

// Attach an event listener to the document body, causing a memory leak
document.body.addEventListener("click", function () {
console.log(obj);
});

// Return the object for further use
return obj;
}

let leakedObj = createObject();

In this example, we create a global variable globalVar, which causes a memory leak because it's never garbage collected. We also create an object using the createObject function and attach an event listener to the document body, causing another memory leak. To avoid these leaks, we can refactor the code as follows:

let globalVar; // Declare globalVar but don't assign a value initially

function createObject() {
let obj = {};

// Detach event listeners when they're no longer needed
document.body.removeEventListener("click", function () {
console.log(obj);
});

return obj;
}

let leakedObj = createObject();

In the refactored code, we declare globalVar but don't assign a value initially, which avoids the global memory leak. We also detach the event listener when it's no longer needed, preventing another memory leak.

Common Mistakes

1. Ignoring Global Variables

Declaring global variables can lead to memory leaks and other issues. Use let and const for local variables instead of global variables.

2. Forgetting to Remove Event Listeners

Attaching event listeners to elements that are no longer used can cause memory leaks. Make sure to remove event listeners when they're no longer needed using the removeEventListener method.

3. Creating Unnecessary Objects

Creating unnecessary objects or arrays can consume a significant amount of memory. Be mindful of your code and optimize where possible.

Common Mistakes (Continued)

4. Misusing Closures

Closures can lead to memory leaks if not used carefully. Ensure that variables referenced in closures are only needed for the duration of the closure's execution.

5. Not Breaking Circular References

Circular references between objects can cause memory leaks. Break these circular references by removing one or both references when they're no longer needed.

6. Large Objects and Arrays

Creating large objects or arrays can consume a significant amount of memory and lead to performance issues if not handled properly. Consider breaking down large data structures into smaller, more manageable parts.

Common Mistakes (Continued)

7. Long-lived DOM elements

Keeping DOM elements in memory for an extended period can cause memory leaks, especially when these elements are not needed anymore. Make sure to remove unnecessary elements from the DOM.

8. Improper Caching Strategies

Improper caching strategies can lead to memory leaks, as cached data may not be garbage collected when it's no longer needed. Use efficient caching techniques like LRU (Least Recently Used) cache to avoid such issues.

Practice Questions

1. Write a JavaScript function that takes an array as input, sorts it in ascending order, and returns the sorted array without using any built-in sorting functions.
2. Implement a simple JavaScript implementation of LRU (Least Recently Used) cache with a fixed capacity of 4 items.
3. Explain how JavaScript's garbage collector works and list some common causes of memory leaks in JavaScript applications.
4. Write a function that finds all circular references in an object graph and breaks them to avoid memory leaks.
5. Implement a simple JavaScript memory profiler to identify memory-intensive parts of your application.
6. Create a JavaScript function that generates a large array and measures the time it takes to sort the array using different sorting algorithms (e.g., bubble sort, quick sort, merge sort). Compare their performance and discuss which algorithm is more efficient in this scenario.
7. Implement a simple JavaScript implementation of a binary search tree and demonstrate its use for efficient searching and insertion/deletion operations.
8. Write a JavaScript function that takes an object as input and returns a new object with only the properties that have non-null values.
9. Explain how event bubbling and capturing work in JavaScript, and provide an example demonstrating their differences.
10. Implement a simple JavaScript implementation of a depth-first search (DFS) algorithm for traversing graphs.

FAQ

What happens when the heap is full in JavaScript?

When the heap is full, the garbage collector runs to free up memory by identifying and deleting unused objects. If there isn't enough memory available for the garbage collector to run effectively, it may cause performance issues or even crashes.

Can I manually manage memory in JavaScript like C or Java?

No, JavaScript does not provide a way to manually manage memory like C or Java. Instead, it uses an automatic garbage collector that frees up unused memory periodically.

How can I optimize memory usage in my JavaScript application?

To optimize memory usage in your JavaScript application, follow these best practices:

1. Use let and const for local variables instead of global variables.
2. Remove event listeners when they're no longer needed.
3. Avoid creating unnecessary objects or arrays.
4. Be mindful of how you use closures in your code.
5. Break circular references between objects to avoid memory leaks.
6. Profile your application to identify memory-intensive parts and optimize them accordingly.
7. Use efficient data structures like binary search trees for specific use cases.
8. Implement caching strategies like LRU (Least Recently Used) cache to reduce the number of expensive operations.
9. Minimize the use of large objects or arrays, and break them down into smaller parts when necessary.
10. Remove long-lived DOM elements from memory when they're no longer needed.