🌟 Operating System Concepts - Interview Guide

1. 🖥️ Operating System (OS) & Types

Definition: Software that manages computer hardware and software resources and provides common services for applications.

Types:

• 📦 Batch OS: Processes batches of jobs without interaction.

• ⏰ Time-Sharing OS: Allows multiple users to interact with programs simultaneously.

• 🌐 Distributed OS: Manages a group of separate computers and makes them act as one system.

2. 🎯 Purpose of an OS

• 🔧 Resource Management: Allocates CPU, memory, and I/O devices to processes.

• ⚙️ Task Management: Manages tasks like process scheduling, multitasking, and resource sharing.

• 🖱️ User Interface: Provides a user-friendly way to interact with the system (GUI or command-line).

3. ⏱️ Real-Time Operating System (RTOS) & Types

Definition: An OS designed for real-time applications where responses are needed within a specific time.

4. 💻 Program, Process, and Thread

• 🔹 Program: A set of instructions designed to complete a specific task. It is a passive entity residing in secondary memory.

• 🔸 Process: An active entity created during execution, loaded into main memory. It exists for a limited time, terminating after task completion.

• 🧵 Thread: A single sequence of execution within a process, often called a lightweight process. Threads improve application performance through parallelism.

Key Points:

• Processes are isolated and considered heavyweight, requiring OS intervention for switching.
• Threads share memory within the same process and are lightweight, allowing efficient communication.

5. 🛠️ PCB, Socket, Shell, Kernel, and Monolithic Kernel

• 📝 Process Control Block (PCB): Tracks the execution status of a process, containing information like registers, priority, and execution state.

• 🔌 Socket: An endpoint for sending/receiving data over a network.

• 🖥️ Shell: Interface to access OS services, either via command-line or GUI.

• 🧠 Kernel: The core component of an OS, managing memory, CPU time, and hardware operations. Acts as a bridge between applications and hardware.

Monolithic Kernel:

• 💪 Monolithic Kernel: Manages system resources and implements user and kernel services in the same address space, making OS execution faster but increasing its size.

6. 🔄 Multitasking vs. Multithreading

Multithreading

• 🔀 Multiple threads are executed simultaneously within the same or different parts of a program.
• 💨 Lightweight process, involving parts of a single process.
• 🔄 CPU switches between multiple threads.
• 🔗 Shares computing resources among threads of a single process.

Multitasking

• 🔀 Several programs (or tasks) are executed concurrently.
• 💪 Heavyweight process, involving multiple processes.
• 🔄 CPU switches between multiple tasks or processes.
• 🔗 Shares computing resources (CPU, memory, devices) among multiple processes.

7. 🔀 Multitasking vs. Multiprocessing

Multitasking

• 🔢 Performs multiple tasks using a single processor.
• 🧮 Has only one CPU.
• 💰 More economical.
• ⚡ Allows fast switching between tasks.

Multiprocessing

• 🔢 Performs multiple tasks using multiple processors.
• 🧮 Has more than one CPU.
• 💸 Less economical.
• ⚡ Allows smooth simultaneous task processing.

8. 🔄 Process States and Queues

Process States:

Different states that a process goes through include:

• 🆕 New State: The process is just created.

• 🏃 Running: The CPU is actively executing the process's instructions.

• ⏳ Waiting: The process is paused, waiting for an event to occur.

• ✅ Ready: The process has all necessary resources and is waiting for CPU assignment.

• 🛑 Terminate: The process has completed execution and is finished.

Process Queues:

• 🚀 Ready Queue: Holds processes that are ready for CPU time.

• 🕒 Waiting Queue: Holds processes that are waiting for I/O operations.

9. 🔗 Inter-Process Communication (IPC)

• 🎯 Purpose: Allows processes to communicate and share data.

• 🛠️ Techniques: Includes pipes, message queues, shared memory, and semaphores.

10. 🔄 Dynamic Binding

• 📖 Definition: Linking a function or variable at runtime rather than at compile-time.

• ✅ Advantage: Flexibility in program behavior and memory use.

11. 🔄 Swapping

• 📖 Definition: Moving processes between main memory and disk storage.

• 🎯 Purpose: Frees up memory for active processes, improving system performance.

12. 🔄 Context Switching

• 📖 Definition: Involves saving the state of a currently running process and loading the saved state of a new process. The process state is stored in the Process Control Block (PCB), allowing the old process to resume from where it left off.

• ⚖️ Overhead: Increases CPU load but allows multitasking.

13. 👻 Zombie Process & 👶 Orphan Process

• 🧟‍♂️ Zombie Process: A terminated process still occupying memory until the parent acknowledges it.

• 🍼 Orphan Process: A child process without a parent, often adopted by the init system in Unix-based OS.

14. 💾 RAID (Redundant Array of Independent Disks)

• 📖 Definition: A method of storing data across multiple disks for redundancy or performance.

• 🔢 Types: Includes RAID 0 (striping), RAID 1 (mirroring), RAID 5 (striping with parity), etc.

15. 🍽️ Starvation and ⏳ Aging

• 🌑 Starvation: When a process does not get the resources it needs for a long time because other processes are prioritized.

• ⏳ Aging: Gradually increases priority of waiting processes to prevent starvation.

16. 📅 Scheduling Algorithms

• 🎯 Purpose: Determines the order in which processes access the CPU.

• 🔢 Types: Includes FCFS (First-Come, First-Serve), Round Robin, Priority Scheduling, etc.

17. 🔄 Preemptive vs. Non-Preemptive Scheduling

Preemptive Scheduling

• ⚡ OS can interrupt and reassign CPU from a running process.

Non-Preemptive Scheduling

• Once a process starts, it runs until completion or voluntary release of CPU.

18. 🥇 FCFS & Convoy Effect

• 🏁 FCFS (First-Come, First-Serve): Schedules jobs in the order they arrive in the ready queue. It is non-preemptive, meaning a process holds the CPU until it terminates or performs I/O, causing longer jobs to delay shorter ones.

• 🚗 Convoy Effect: Occurs in FCFS when a long process delays others behind it.

19. 🔄 Round Robin Scheduling

• 📖 Definition: Schedules processes in a time slice or quantum, rotating through processes to ensure fair allocation of CPU time and preventing starvation. It is cyclic and does not prioritize any process.

• ✅ Advantage: Fair and efficient for time-sharing systems.

20. 🎖️ Priority Scheduling

• 📖 Definition: Processes are assigned CPU based on priority levels.

• ⚠️ Challenge: Risk of starvation for lower-priority processes.

21. 🔀 Concurrency

• 📖 Definition: Multiple processes appear to run simultaneously.

• 🚀 Achieved By: Multithreading or multitasking within a single CPU.

22. ⚔️ Race Condition

• 📖 Definition: Two processes access shared data simultaneously, leading to unexpected results.

• 🛡️ Solution: Use locks or synchronization mechanisms.

23. 🔒 Critical Section

• 📖 Definition: A part of code that accesses shared resources and must not be executed by more than one process at a time.

24. 🔄 Synchronization Techniques

• 🔐 Mutexes: Only allows one process at a time, preventing concurrent access.

• 📍 Condition Variables: A variable used to control access in multithreading, allowing threads to wait until certain conditions are met.

• 🔗 Semaphores: Allows multiple processes to access resources up to a limit.

• 📂 File Locks: Restricts access to files to prevent conflicts.

25. 🔄 Semaphore in OS

• 📖 Definition: A Semaphore is a synchronization tool used in operating systems to manage access to shared resources in multi-threaded or multi-process systems. It keeps a count of available resources and uses two atomic operations, wait() and signal(), to control access.

Types of Semaphores:

• 🔘 Binary Semaphore:

  • Has values 0 or 1.
  • Signals availability of a single resource.

• 🔢 Counting Semaphore:

  • Can have values greater than 1.
  • Controls access to multiple instances of a resource, like a pool of connections.

Binary Semaphore vs. Mutex:

• 🔘 Binary Semaphore:

  • Signals availability of a shared resource (0 or 1).
  • Uses signaling mechanisms.
  • Faster in some cases with multiple processes.
  • Integer variable holding 0 or 1.

• 🔒 Mutex:

  • Allows mutual exclusion with a single lock.
  • Uses a locking mechanism.
  • Slower when frequently contended.
  • Object holding lock state and lock owner info.

26. 🔀 Binary vs. Counting Semaphores

Binary Semaphore

• 🔢 Only two values: 0 or 1, similar to a lock.
• 🔒 Usage: Signals availability of a single resource.
• ⚡ Efficiency: Faster in scenarios with multiple processes.
• 🔄 Mechanism: Uses signaling mechanisms.

Counting Semaphore

• 🔢 Range of values: Allows values greater than 1.
• 🔄 Flexibility: Manages multiple resources effectively.
• ⚙️ Usage: Controls access to multiple instances of a resource, like a pool of connections.
• 🔗 Mechanism: Uses counting to manage resource allocation.

27. 🏭 Producer-Consumer Problem

• 📖 Definition: A synchronization issue where producer and consumer processes access shared data.

• 🔧 Solution: Use semaphores or mutexes to control access and prevent race conditions.

28. 📉 Belady’s Anomaly

• 📖 Definition: An increase in page faults despite increasing memory pages in certain page replacement algorithms.

• 🔍 Occurs In: FIFO (First-In, First-Out) page replacement algorithm.

29. ☠️ What is a Deadlock in OS?

• 📖 Definition: A deadlock is a situation where a set of processes are blocked because each process holds resources and waits to acquire additional resources held by another process.

• 🔄 Scenario: Two or more processes are unable to proceed because they are waiting for each other to release resources.

• ⚠️ Common Occurrence: In multiprocessing environments, leading to the system becoming unresponsive.

Necessary Conditions for Deadlock

1. 🔒 Mutual Exclusion: Resources cannot be shared; at least one resource must be held in a non-shareable mode.

2. 🤝 Hold and Wait: Processes holding resources are allowed to wait for additional resources.

3. ✋ No Pre-emption: Resources cannot be forcibly taken from a process; they must be voluntarily released.

4. 🔄 Circular Wait: A set of processes exists such that each process is waiting for a resource held by the next process in the cycle.

30. 🎲 Banker’s Algorithm

• 🎯 Purpose: A deadlock avoidance algorithm used in resource allocation.

• 🛠️ Method: Checks if resources can be safely allocated without causing a deadlock by ensuring the system remains in a safe state.

31. 🚧 Methods for Handling Deadlock

Deadlock Prevention

• 🔒 Ensure at least one necessary condition for deadlock cannot hold.
  • 🤝 Mutual Exclusion: Allow resource sharing where possible.
  • ✋ Hold and Wait: Require all resources to be requested upfront.
  • ✋ No Pre-emption: Permit resource preemption.
  • 🔄 Circular Wait: Impose a strict order for resource allocation.

Deadlock Avoidance

• 🔍 Dynamically examine resource allocation to prevent circular wait.
• 🎲 Use the Banker’s Algorithm to determine safe states; deny requests that would lead to an unsafe state.

Deadlock Detection

• 🔍 Allow the system to enter a deadlock state, then detect it.
• 📈 Use a Wait-for Graph to represent wait-for relationships; a cycle indicates a deadlock.
• 🔗 Employ a Resource Allocation Graph to check for cycles and determine the presence of deadlock.

Deadlock Recovery

• 🛑 Terminate one or more processes involved in the deadlock (abruptly or gracefully).
• 🔄 Use resource preemption to take resources from processes and allocate them to others to break the deadlock.

32. 🧩 Logical vs. Physical Address Space

| Parameter | Logical Address | Physical Address | |--------------------|------------------------------------------|---------------------------------------------| | 🔍 Basic | Generated by the CPU. | Located in a memory unit. | | 📦 Address Space | Set of all logical addresses generated by the CPU. | Set of all physical addresses corresponding to logical addresses. | | 👀 Visibility | Visible to the user. | Not visible to the user. | | ⚙️ Generation | Created by the CPU. | Computed by the Memory Management Unit (MMU). |

33. 🧮 Memory Management Unit (MMU)

• 📖 Definition: Hardware that translates logical addresses to physical addresses.

34. 🖥️ Main vs. Secondary Memory

Primary Memory

• 💾 Usage: Used for temporary data storage while the computer is running.

• ⚡ Access Speed: Faster as it is directly accessible by the CPU.

• 💨 Nature: Volatile; data is lost when power is turned off.

• 💰 Cost: More expensive due to the use of semiconductor technology.

• 📊 Capacity: Ranges from 16 to 32 GB, suitable for active tasks.

• 🔍 Examples: RAM, ROM, and Cache memory.

Secondary Memory

• 💾 Usage: Used for permanent data storage, retaining information long-term.

• ⚡ Access Speed: Slower; not directly accessible by the CPU.

• 💨 Nature: Non-volatile; retains data even when power is off.

• 💰 Cost: Less expensive, often using magnetic or optical technology.

• 📊 Capacity: Can range from 200 GB to several terabytes for extensive storage.

• 🔍 Examples: Hard Disk Drives, Floppy Disks, and Magnetic Tapes.

35. 🗄️ Cache

• 📖 Definition: Small, fast memory located close to the CPU for quick access to frequently used data.

• ⚡ Caching: Involves using a smaller, faster memory to store copies of data from frequently used main memory locations. Various independent caches within a CPU store instructions and data, reducing the average time needed to access data from the main memory.

36. 🗂️ Direct Mapping vs. Associative Mapping

Direct Mapping

• 🔒 Fixed Location: Each block has a fixed cache location.

• ⚡ Simplicity: Simpler and faster due to the fixed placement.

Associative Mapping

• 🔄 Flexible Location: Any block can be placed into any cache line, providing more flexibility.

• ⚙️ Efficiency: Better cache utilization but more complex to implement.

37. 🧩 Fragmentation

Internal Fragmentation

• 🔹 Definition: Occurs when allocated memory blocks are larger than required by a process, leading to wasted space within the allocated memory.
• 🔒 Characteristics:
  • Fixed-sized memory blocks are allocated to processes.
  • Difference between allocated and required memory is wasted.
  • Arises when memory is divided into fixed-sized partitions.
• 🔧 Solution: Best-fit block allocation to minimize wasted space.

External Fragmentation

• 🔹 Definition: Happens when free memory is scattered in small, unusable fragments, preventing the allocation of large contiguous memory blocks.
• 🔒 Characteristics:
  • Variable-sized memory blocks are allocated to processes.
  • Unused spaces between allocated blocks are too small for new processes.
  • Arises when memory is divided into variable-sized partitions.
• 🔧 Solution: Compaction, paging, and segmentation to reorganize memory and reduce fragmentation.

38. 🧹 Defragmentation

• 📖 Definition: The process of rearranging memory to reduce fragmentation.

• 🛠️ Compaction: Collects fragments of available memory into contiguous blocks by moving programs and data in a computer's memory or disk, thereby optimizing memory usage.

39. 📤 Spooling

• 📖 Definition: Storing data temporarily for devices to access when they are ready, such as print jobs.

• 🔡 Meaning: Spooling stands for Simultaneous Peripheral Operations Online, which involves placing jobs in a buffer (either in memory or on a disk) where a device can access them when ready.

• 🔧 Purpose: Helps manage different data access rates of devices, ensuring efficient data processing.

40. 🔄 Overlays

• 📖 Definition: Loading only the required part of a program into memory, unloading it when done, and loading a new part as needed.

• 🔧 Purpose: Efficiently manages memory usage by ensuring that only necessary parts of a program are in memory at any given time, optimizing resource allocation.

41. 📑 Page Table, Frames, Pages

• 🗂️ Page Table: Maps logical pages to physical frames, enabling the memory management unit (MMU) to translate addresses.

• 🔲 Frame: Fixed-size physical memory blocks where pages are loaded.

• 📄 Page: Fixed-size blocks of logical memory that are mapped to frames in physical memory.

42. 📚 Paging

• 📖 Definition: A memory management technique for non-contiguous memory allocation, dividing both main and secondary memory into fixed-size partitions called pages and frames, respectively.

• 🎯 Purpose:

  • Avoids external fragmentation.
  • Simplifies memory management by using fixed-size blocks.

• 🔄 Operation: Fetches process pages into main memory frames as needed, ensuring efficient use of memory resources.

43. 🧱 Segmentation

• 📖 Definition: Dividing memory into segments based on logical units such as functions, objects, or data structures.

• 🔍 Features:

  • Segments are variable-sized, reflecting the logical structure of programs.
  • Provides a more natural view of memory for programmers.

• 🔧 Purpose: Enhances memory organization by grouping related data and code, improving access and management.

44. 🔀 Paging vs. Segmentation

Paging

• 🔒 Invisible to the Programmer: Memory management is handled by the OS and MMU, not directly visible in the programming model.

• 🔢 Fixed-Size Pages: Memory is divided into uniform page sizes, simplifying allocation.

• 🔄 Procedures and Data: Cannot be separated, as both are stored in fixed-size blocks.

• 📈 Virtual Address Space: Allows virtual address space to exceed physical memory, supporting virtual memory.

• ⚡ Performance: Faster memory access compared to segmentation.

• ⚠️ Fragmentation: Results in internal fragmentation due to fixed page sizes.

Segmentation

• 🔍 Visible to the Programmer: Programmers work with segments that correspond to logical units in the code.

• 📏 Variable-Size Segments: Segments can be of different sizes, matching the logical structure of the program.

• 🔄 Procedures and Data: Can be separated, allowing more flexible memory organization.

• 🔗 Address Spaces: Breaks programs, data, and code into independent spaces, enhancing modularity.

• ⚡ Performance: Slower memory access compared to paging due to variable sizes.

• ⚠️ Fragmentation: Results in external fragmentation as free memory becomes scattered.

45. 🕳️ Page Faults

• 📖 Definition: Occurs when a program accesses a page that is not currently in physical memory.

• 🔄 Handling: Triggers the OS to fetch the required page from secondary memory (e.g., disk) into physical memory, potentially causing a temporary pause in execution.

46. 🌀 Virtual Memory

• 🎯 Definition: A memory management technique in operating systems that creates the illusion of a large contiguous address space.

• 🔗 Features:

  • Extends physical memory using disk space.
  • Allows more programs to run simultaneously.
  • Stores data in pages for efficient memory use.
  • Provides memory protection to ensure process isolation.
  • Managed through methods like paging and segmentation.
  • Acts as temporary storage alongside RAM for processes.

• 🔧 Purpose: Enhances system performance by allowing efficient use of available memory and supporting multitasking.

47. 🎯 Objective of Multiprogramming

• 🔄 Multiple Programs: Allows multiple programs to run on a single processor.

• 🚀 Addresses Underutilization: Tackles underutilization of the CPU and main memory by keeping the CPU busy with multiple jobs.

• 🔧 Coordination: Coordinates the execution of several programs simultaneously.

• ⚡ Continuous Execution: Main objective is to have processes running at all times, improving CPU utilization by organizing multiple jobs for continuous execution.

48. ⏳ Demand Paging

• 📖 Definition: Loads pages into memory only when they are needed, which occurs when a page fault happens.

• 🔄 Operation:

  • Pages are fetched from secondary memory to physical memory on demand.
  • Reduces memory usage by loading only necessary pages.

• 🎯 Purpose: Optimizes memory usage and improves system performance by avoiding loading entire processes into memory upfront.

49. 📦 Page Replacement Algorithms

• 🎯 Purpose: Manage how pages are swapped in and out of physical memory when a page fault occurs.

1. Least Recently Used (LRU)

• 🔄 Replaces the page that has not been used for the longest time.
• 📈 Keeps track of page usage over time to make informed replacement decisions.

2. First-In, First-Out (FIFO)

• 🔄 Replaces the oldest page in memory.
• 🛠️ Simple to implement but can lead to suboptimal performance due to the Convoy Effect.

3. Optimal Page Replacement

• 🔮 Replaces the page that will not be used for the longest period in the future.
• 🏆 Provides the best performance but is impractical to implement since future requests are unknown.

4. Least Frequently Used (LFU)

• 🔄 Replaces the page with the lowest access frequency.
• 📊 Tracks pages based on the number of accesses over time to determine replacements.

50. 🌀 Thrashing

• 📖 Definition: Excessive swapping between memory and disk, leading to significant system slowdown.

• 🔄 Occurrence: Happens when a computer spends more time handling page faults than executing transactions, resulting in degraded performance.

• ⚠️ Cause: High page fault rate due to insufficient physical memory, causing frequent swapping.

• 🔧 Impact:

  • Longer service times.
  • Reduced system efficiency.
  • Potential system unresponsiveness.

🏅 Highlighted Takeaways:

• Fragmentation is a critical concept in memory management, with internal and external fragmentation requiring different solutions like best-fit allocation, compaction, and paging.
• Defragmentation and compaction are essential for optimizing memory usage, ensuring that memory is used efficiently.
• Spooling and overlays enhance resource management by buffering data and loading only necessary program parts.
• Understanding paging, segmentation, and their differences is vital for effective memory management and system performance.
• Virtual memory and demand paging enable efficient use of physical memory, supporting multitasking and large applications.
• Page replacement algorithms like LRU, FIFO, Optimal, and LFU are crucial for maintaining system performance by managing memory efficiently.
• Thrashing is a severe issue that occurs due to high page fault rates, emphasizing the importance of adequate memory management.
• Multiprogramming aims to maximize CPU utilization by running multiple programs simultaneously, addressing resource underutilization.