{"pinia":{"ui":{"prefs":{"theme":"system","textScale":"md","fontFamily":"sans","reducedMotion":false,"highContrast":false}},"academy":{"universities":[],"universitySummaries":[{"slug":"rtu","name":"RTU","fullName":"Rajasthan Technical University","branches":[{"slug":"first-year-common","name":"First Year (Common)"},{"slug":"computer-science","name":"Computer Science"},{"slug":"mechanical","name":"Mechanical"},{"slug":"civil","name":"Civil"},{"slug":"ai-data-science","name":"AI & Data Science"},{"slug":"ee-ec-eee","name":"EE / EC / EEE"}]},{"slug":"aktu","name":"AKTU","fullName":"Dr. A. P. J. Abdul Kalam Technical University","branches":[{"slug":"first-year-common","name":"First Year (Common)"},{"slug":"computer-science","name":"Computer Science"}]}],"activePapers":[{"id":"operating-system-2023","title":"Operating System (2023)","subjectSlug":"operating-system","subjectName":"Operating System","universitySlug":"rtu","branchSlug":"computer-science","year":3,"semester":5,"examYear":2023,"paperCode":"5E1753","questions":[{"id":"v2-operating-system-2023-pA-q1","number":1,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Operating System."}],"answer":{"summary":"An Operating System is the master system software that physically manages computer hardware and software resources.","explanation":[{"type":"paragraph","content":"An Operating System (OS) is the absolute foundational system software that acts as an aggressive intermediary between the human user and the bare-metal computer hardware. It mathematically orchestrates CPU scheduling, RAM allocation, peripheral I/O, and file management, ensuring safe and efficient execution of application programs."}]}},{"id":"v2-operating-system-2023-pA-q2","number":2,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is a Process?"}],"answer":{"summary":"A Process is a program in active mathematical execution, possessing its own memory space and CPU state.","explanation":[{"type":"paragraph","content":"In OS architecture, a Process is fundamentally defined as a program currently in active execution. Unlike a static program resting on a hard drive, a process is a dynamic, living entity possessing a physical memory space (Text, Data, Heap, Stack) and a strictly tracked CPU architectural state (Program Counter and Registers)."}]}},{"id":"v2-operating-system-2023-pA-q3","number":3,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Deadlock."}],"answer":{"summary":"Deadlock is a catastrophic system state where processes are mathematically permanently blocked, waiting on each other.","explanation":[{"type":"paragraph","content":"Deadlock is a fatal architectural crisis in a multiprogramming environment. It occurs when two or more distinct processes are mathematically trapped in a permanent holding pattern, where each process fiercely holds a critical resource while simultaneously requesting a resource currently locked by the other, resulting in a total system freeze."}]}},{"id":"v2-operating-system-2023-pA-q4","number":4,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Virtual Memory?"}],"answer":{"summary":"Virtual Memory is an architectural technique that mathematically simulates a massive RAM space using the hard drive.","explanation":[{"type":"paragraph","content":"Virtual Memory is a highly advanced memory management architecture. It violently decouples logical memory from physical RAM, mathematically allowing the OS to execute processes that are physically larger than the available RAM by aggressively swapping fixed-size data blocks (Pages) between the fast RAM and the slow Hard Disk Drive."}]}},{"id":"v2-operating-system-2023-pA-q5","number":5,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Semaphore."}],"answer":{"summary":"A Semaphore is an integer-based synchronization tool utilized to prevent race conditions in concurrent programming.","explanation":[{"type":"paragraph","content":"A Semaphore is a rigorous mathematical signaling mechanism engineered by Edsger Dijkstra. It is fundamentally an integer variable accessed exclusively through two atomic, indivisible hardware operations (`wait()` and `signal()`). It is aggressively utilized to enforce strict mutual exclusion and synchronize multiple threads attempting to access a shared critical section."}]}},{"id":"v2-operating-system-2023-pA-q6","number":6,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Fragmentation?"}],"answer":{"summary":"Fragmentation is the catastrophic fracturing of physical memory into tiny, unusable blocks, preventing process allocation.","explanation":[{"type":"paragraph","content":"Fragmentation is a devastating memory allocation flaw. Internal Fragmentation occurs when a process is allocated a fixed memory block larger than its mathematical requirement, wasting the internal surplus. External Fragmentation occurs when total free RAM is mathematically sufficient, but physically shattered into non-contiguous microscopic holes, making massive contiguous allocation impossible."}]}},{"id":"v2-operating-system-2023-pA-q7","number":7,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Paging."}],"answer":{"summary":"Paging is a memory management architecture that violently eradicates external fragmentation by dividing memory into fixed-size blocks.","explanation":[{"type":"paragraph","content":"Paging is an aggressive non-contiguous memory management architecture. It mathematically shatters logical memory into fixed-size blocks called \"Pages,\" and physical RAM into identically sized blocks called \"Frames.\" This allows the OS to physically scatter a process's pages randomly across RAM, completely eradicating the catastrophic flaw of external fragmentation."}]}},{"id":"v2-operating-system-2023-pA-q8","number":8,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Thrashing?"}],"answer":{"summary":"Thrashing is a catastrophic system collapse where the OS spends all its CPU cycles paging rather than executing.","explanation":[{"type":"paragraph","content":"Thrashing is an absolute hardware meltdown state. It mathematically occurs when the OS is violently executing more page faults than actual instructions. The CPU is forced to spend 100% of its clock cycles aggressively swapping pages between RAM and the Hard Drive, dropping actual program execution throughput to near zero."}]}},{"id":"v2-operating-system-2023-pA-q9","number":9,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define File System."}],"answer":{"summary":"A File System is the architectural structure the OS utilizes to mathematically organize and retrieve data on storage disks.","explanation":[{"type":"paragraph","content":"A File System is the strict mathematical and logical architecture engineered by the OS to aggressively organize, store, retrieve, and secure raw binary data on physical non-volatile storage media (HDDs/SSDs). It manages critical metadata, hierarchical directories, and physical disk block allocation tables."}]}},{"id":"v2-operating-system-2023-pA-q10","number":10,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is a Shell?"}],"answer":{"summary":"A Shell is the command-line software interface allowing human users to mathematically communicate directly with the OS Kernel.","explanation":[{"type":"paragraph","content":"In operating system architecture, the Shell is the aggressive outermost software layer. It acts as a command-line interpreter, taking human-readable text commands from the user, mathematically translating them into strict system calls, and violently pushing them directly into the core Kernel for absolute hardware execution."}]}},{"id":"v2-operating-system-2023-pB-q1","number":1,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the different types of Operating Systems."}],"answer":{"summary":"A definitive architectural breakdown of Operating System variations, including Batch, Time-Sharing, Distributed, and Real-Time Systems, highlighting their distinct scheduling paradigms and hardware implementations.","explanation":[{"type":"heading","content":"Architectural Types of Operating Systems"},{"type":"paragraph","content":"Operating Systems are not monolithic entities; they are highly specialized software architectures engineered to violently optimize specific computing environments. The mathematical scheduling algorithms and memory management techniques differ drastically depending on the exact classification of the OS."},{"type":"subheading","content":"1. Batch Operating Systems"},{"type":"paragraph","content":"The absolute most primitive architecture, designed for archaic mainframe computers. There is strictly no direct interaction between the human user and the computer during execution. \n- **Mechanism:** Users submit their jobs (code and data) on punch cards to a human operator. The operator mathematically batches similar jobs together and feeds them to the CPU. \n- **Merit/Demerit:** Maximizes CPU utilization for massive, non-interactive mathematical calculations, but suffers from catastrophic latency and zero interactivity."},{"type":"subheading","content":"2. Time-Sharing (Multitasking) Operating Systems"},{"type":"paragraph","content":"This is the foundational architecture of all modern desktop systems (Windows, Linux). It is engineered to aggressively support multiple interactive users simultaneously.\n- **Mechanism:** It utilizes strict mathematical Time-Slicing (Round Robin scheduling). The CPU violently switches its execution context between multiple active processes every few milliseconds. \n- **Merit:** The switching is so blisteringly fast that it creates a flawless optical illusion that every single user possesses a dedicated CPU."},{"type":"subheading","content":"3. Distributed Operating Systems"},{"type":"paragraph","content":"A highly advanced, massively scaled architecture. It manages a massive cluster of physically independent, networked computers (Nodes), but mathematically presents them to the user as a single, unified supercomputer.\n- **Mechanism:** It aggressively distributes the computational load and RAM requirements across multiple independent motherboards, drastically increasing fault tolerance and processing velocity."},{"type":"subheading","content":"4. Real-Time Operating Systems (RTOS)"},{"type":"paragraph","content":"RTOS is the most rigorous and mathematically strict architecture, utilized exclusively in medical pacemakers, nuclear reactors, and missile guidance systems.\n- **Mechanism:** It operates on absolute, non-negotiable time constraints. If a calculation is mathematically scheduled to complete in 5 milliseconds, it MUST complete in 5 milliseconds. A delay of 1 microsecond is considered a catastrophic system failure resulting in physical destruction."}]}},{"id":"v2-operating-system-2023-pB-q2","number":2,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Describe the various CPU scheduling algorithms."}],"answer":{"summary":"An analytical review of CPU Scheduling algorithms, mathematically comparing First-Come First-Serve (FCFS), Shortest Job First (SJF), and the time-sliced Round Robin (RR) protocols.","explanation":[{"type":"heading","content":"CPU Scheduling Algorithms"},{"type":"paragraph","content":"In a multiprogramming architecture, the OS Kernel utilizes a highly aggressive component known as the Short-Term Scheduler (or CPU Scheduler). Its singular mathematical objective is to select the absolute most optimal process from the Ready Queue and violently inject it into the CPU for execution, maximizing CPU utilization and minimizing wait times."},{"type":"subheading","content":"1. First-Come, First-Served (FCFS)"},{"type":"paragraph","content":"The most primitive, non-preemptive scheduling architecture.\n- **Mechanism:** It operates on a strict FIFO (First-In, First-Out) mathematical queue. The process that arrives first is aggressively locked into the CPU and absolutely refuses to surrender control until it is completely finished.\n- **Demerit (The Convoy Effect):** If a massive, CPU-heavy process arrives first (taking 100 seconds), it will violently block 50 tiny processes (taking 1 second each) stuck behind it, causing catastrophic average wait times."},{"type":"subheading","content":"2. Shortest Job First (SJF)"},{"type":"paragraph","content":"The absolute mathematically optimal scheduling algorithm for minimizing average wait time.\n- **Mechanism:** The Scheduler aggressively scans the Ready Queue, evaluates the estimated execution time (Burst Time) of every process, and strictly selects the process with the shortest mathematical burst time.\n- **Demerit (Starvation):** If a massive process is waiting, and a continuous stream of tiny processes keeps arriving, the massive process will mathematically never receive CPU time. It will violently starve to death in the queue."},{"type":"subheading","content":"3. Round Robin (RR)"},{"type":"paragraph","content":"The foundational architecture for all modern Time-Sharing systems. It is aggressively preemptive.\n- **Mechanism:** The Kernel mathematically defines a strict Time Quantum (e.g., 10 milliseconds). The CPU executes a process for exactly one quantum. If the process is not finished, a hardware interrupt is violently triggered. The OS forcibly yanks the process out of the CPU, shoves it to the back of the queue, and loads the next process.\n- **Merit:** Guarantees absolute fairness and incredible responsiveness; no process can ever monopolize the CPU or starve."}]}},{"id":"v2-operating-system-2023-pB-q3","number":3,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the concept of Critical Section."}],"answer":{"summary":"A rigorous theoretical explanation of the Critical Section Problem in concurrent programming, detailing the strict mathematical requirements of Mutual Exclusion, Progress, and Bounded Waiting.","explanation":[{"type":"heading","content":"The Critical Section Problem in Concurrency"},{"type":"paragraph","content":"In modern multi-threaded operating system architecture, multiple independent processes or threads constantly attempt to execute simultaneously. A catastrophic hardware crisis occurs when two or more threads attempt to aggressively read and write to the exact same shared memory variable, database table, or physical file at the exact same millisecond. This collision physically corrupts the data, creating a massive \"Race Condition.\" The specific segment of source code where a process mathematically modifies these shared variables is definitively termed the **Critical Section**."},{"type":"subheading","content":"The Three Absolute Architectural Requirements"},{"type":"paragraph","content":"To safely engineer a multi-threaded OS, computer scientists must develop synchronization protocols (like Semaphores or Mutex Locks) to guard the Critical Section. Any valid protocol MUST mathematically satisfy three absolute, non-negotiable conditions:"},{"type":"list","items":["**1. Mutual Exclusion (The Primary Directive):** This is the absolute core law. If Process A is physically currently executing inside its Critical Section (modifying the shared data), then absolutely NO other process in the entire system is mathematically allowed to enter their Critical Section for that same data. They must be violently blocked at the entrance.","**2. Progress (Anti-Deadlock):** If absolutely no process is currently inside the Critical Section, and several processes are aggressively attempting to enter, the selection of the next process cannot be mathematically postponed indefinitely. The system must immediately and decisively grant access to one of the waiting processes.","**3. Bounded Waiting (Anti-Starvation):** There must exist a strict mathematical limit (a bound) on the total number of times other processes are allowed to bypass a waiting process and enter the Critical Section. A process cannot be forced to wait outside the Critical Section until the end of the universe; it must eventually be guaranteed entry."]}]}},{"id":"v2-operating-system-2023-pB-q4","number":4,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Discuss the Banker's Algorithm for Deadlock avoidance."}],"answer":{"summary":"An architectural breakdown of the Banker's Algorithm, explaining how it aggressively simulates mathematical resource allocation to guarantee the system never enters a catastrophic deadlock state.","explanation":[{"type":"heading","content":"Deadlock Avoidance: The Banker's Algorithm"},{"type":"paragraph","content":"Engineered by the legendary Edsger W. Dijkstra, the Banker's Algorithm is a highly complex, mathematically rigorous Deadlock Avoidance architecture. Unlike deadlock prevention (which restricts how processes request resources), the Banker's Algorithm allows free requests but aggressively simulates the entire future state of the OS before physically granting a single resource. It is mathematically modeled on a physical bank ensuring it never loans out more cash than it can safely recover."},{"type":"subheading","content":"The Core Mathematical Matrices"},{"type":"paragraph","content":"The OS Kernel must aggressively maintain four massive multidimensional matrices in RAM:"},{"type":"list","items":["**Available:** A 1D array mathematically tracking exactly how many instances of each hardware resource (Printers, Tape Drives, RAM blocks) are currently physically free.","**Max:** A 2D matrix where every process must declare, in advance, the absolute maximum number of each resource it will ever theoretically request.","**Allocation:** A 2D matrix tracking exactly how many resources are currently physically locked by each process.","**Need:** A 2D matrix dynamically calculated as: `Need[i][j] = Max[i][j] - Allocation[i][j]`. It represents the remaining resources a process requires to finish execution."]},{"type":"subheading","content":"The Safety Algorithm Execution"},{"type":"paragraph","content":"When Process P requests a resource, the OS does NOT grant it immediately. It executes a violent simulation:"},{"type":"list","items":["1. The OS hypothetically grants the resource, updating the matrices.","2. It aggressively scans the `Need` matrix to find any process whose total needs can be mathematically satisfied by the currently `Available` resources.","3. If found, the OS assumes that process will finish and violently return all its held resources to the `Available` pool.","4. The OS repeats this mathematical loop. If it can find a safe sequence to finish EVERY single process, the hypothetical state is declared **SAFE**, and the physical hardware is granted.","5. If the math fails (some processes cannot finish), the state is declared **UNSAFE** (a potential deadlock). The request is violently rejected, and the process is blocked."]}]}},{"id":"v2-operating-system-2023-pB-q5","number":5,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the concept of Page Replacement algorithms."}],"answer":{"summary":"A detailed exploration of Page Replacement algorithms, critically analyzing FIFO's simplicity and Belady's Anomaly against the strict mathematical superiority of the LRU algorithm.","explanation":[{"type":"heading","content":"Page Replacement Algorithms in Virtual Memory"},{"type":"paragraph","content":"In a Virtual Memory architecture, the OS aggressively executes programs larger than physical RAM by mapping logical Pages to physical RAM Frames. However, when physical RAM is 100% completely full, and the CPU violently demands a new page from the Hard Drive (a Page Fault), the OS must execute a catastrophic decision: It must select an existing, highly utilized page currently residing in RAM, rip it out, violently evict it back to the slow Hard Drive, and load the new page. The mathematical logic determining WHICH page gets evicted is the Page Replacement Algorithm."},{"type":"subheading","content":"1. First-In, First-Out (FIFO)"},{"type":"paragraph","content":"The most primitive, mathematically basic algorithm.\n- **Mechanism:** The OS maintains a strict queue. The page that physically entered the RAM the earliest (the oldest page) is the one violently evicted.\n- **Demerit (Belady's Anomaly):** FIFO suffers from a catastrophic mathematical paradox known as Belady's Anomaly. Logically, adding more physical RAM should decrease Page Faults. However, in specific FIFO scenarios, physically increasing the RAM size mathematically causes MORE Page Faults to occur, completely destroying performance."},{"type":"subheading","content":"2. Least Recently Used (LRU)"},{"type":"paragraph","content":"The absolute industry standard algorithm, relying on the mathematical principle of Temporal Locality.\n- **Mechanism:** The OS aggressively tracks the exact microsecond every single page was last read or written to by the CPU. When an eviction is mandatory, the OS violently hunts down the specific page that has not been touched for the longest period of time (the Least Recently Used) and evicts it.\n- **Merit:** It is mathematically immune to Belady's Anomaly and provides incredibly optimal performance because code executed recently is highly likely to be executed again."}]}},{"id":"v2-operating-system-2023-pB-q6","number":6,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Describe the file allocation methods."}],"answer":{"summary":"An architectural review of File Allocation methodologies, contrasting the massive fragmentation flaws of Contiguous Allocation against the optimized pointer architecture of Linked and Indexed Allocation.","explanation":[{"type":"heading","content":"File Allocation Methods in OS File Systems"},{"type":"paragraph","content":"When a user saves a 50MB file to a physical Hard Disk Drive, the File System does not just dump the data randomly. It must mathematically determine exactly which physical disk blocks (sectors) will store the binary data, and how the OS will track those blocks. This is dictated by three primary allocation architectures."},{"type":"subheading","content":"1. Contiguous Allocation"},{"type":"paragraph","content":"The most primitive architecture.\n- **Mechanism:** The file is violently forced to occupy a single, continuous, mathematically unbroken sequence of physical blocks on the disk (e.g., blocks 50 to 100).\n- **Merit:** Blisteringly fast read speeds because the HDD Read/Write head moves linearly without jumping.\n- **Demerit:** It suffers from catastrophic External Fragmentation. Over time, as files are deleted, the disk shatters into microscopic holes. You might have 100MB free, but if it is not completely contiguous, you cannot save a 10MB file."},{"type":"subheading","content":"2. Linked Allocation"},{"type":"paragraph","content":"Engineered to completely annihilate external fragmentation.\n- **Mechanism:** The file is violently shattered into independent blocks scattered completely randomly across the disk. Every single block contains a hidden architectural pointer (a physical disk address) mathematically pointing to the exact location of the *next* block in the chain.\n- **Demerit:** Catastrophic random-access speeds. To read block 50, the OS must physically traverse the first 49 blocks one by one to follow the pointer chain."},{"type":"subheading","content":"3. Indexed Allocation"},{"type":"paragraph","content":"The highly advanced architecture utilized in modern systems (like Unix i-nodes).\n- **Mechanism:** For every single file, the OS creates a dedicated \"Index Block.\" This massive array mathematically stores the exact physical disk addresses of every single block belonging to the file. To randomly access block 50, the OS simply reads array index 50 inside the Index Block and jumps directly to the physical disk location."}]}},{"id":"v2-operating-system-2023-pB-q7","number":7,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the concept of I/O management in Operating Systems."}],"answer":{"summary":"A detailed exploration of I/O Management in Operating Systems, explaining how the kernel violently isolates hardware complexity through Device Drivers and Interrupt handlers.","explanation":[{"type":"heading","content":"I/O Management Architecture in Operating Systems"},{"type":"paragraph","content":"A modern computer system is physically connected to wildly disparate hardware peripherals: blisteringly fast NVMe SSDs, archaic mechanical hard drives, unpredictable human keyboards, and massive gigabit network cards. The absolute primary responsibility of the OS I/O Management subsystem is to violently abstract away this catastrophic hardware chaos, presenting a unified, simple, mathematical interface to the user applications."},{"type":"subheading","content":"The I/O Software Subsystem Architecture"},{"type":"list","items":["**1. Interrupt Handlers:** At the absolute lowest bare-metal level, hardware devices aggressively fire electrical Interrupts to demand CPU attention. The OS must possess highly optimized Interrupt Service Routines (ISRs) that instantly pause the CPU, acknowledge the hardware, and securely transfer the binary data.","**2. Device Drivers:** A generic OS kernel cannot mathematically understand the specific circuitry of a random Nvidia GPU or an HP Printer. Therefore, the architecture relies on \"Device Drivers\"—highly specialized, third-party software modules that physically plug into the kernel. The driver acts as a translator, converting abstract OS commands (like `write()`) into the exact physical electrical signals required by that specific hardware controller.","**3. Device-Independent OS Software:** This layer sits above the drivers. It aggressively enforces universal standards. It provides uniform naming conventions (like treating every device as a file in Linux under `/dev`), manages physical memory Buffering (storing data temporarily in RAM to match the speed disparity between a fast CPU and a slow HDD), and handles Spooling (queuing print jobs)."]},{"type":"paragraph","content":"Through this strict hierarchy, user applications can blindly issue a generic `printf()` command, completely ignorant of whether the output is mathematically destined for a 4K monitor, a physical printer, or a network socket."}]}},{"id":"v2-operating-system-2023-pC-q1","number":1,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"(a) Explain the architecture of Operating System in detail. (b) Discuss the different types of system calls with examples."}],"answer":{"summary":"An exhaustive architectural analysis of Operating System design, detailing the Monolithic and Microkernel structures, followed by a rigorous breakdown of how System Calls facilitate the mathematical transition from User Mode to Kernel Mode.","explanation":[{"type":"heading","content":"(a) Architecture of the Operating System"},{"type":"paragraph","content":"The internal architecture of an Operating System is arguably the most complex software engineering feat in existence. It is not a single script, but a massively layered ecosystem designed to violently protect the physical hardware from malicious software while mathematically allocating resources. OS architecture is fundamentally dictated by how it organizes its core engine: The Kernel."},{"type":"subheading","content":"1. Monolithic Architecture"},{"type":"paragraph","content":"This is the classic, highly aggressive architecture (utilized by early Unix and MS-DOS)."},{"type":"list","items":["**Structure:** Every single OS component—CPU scheduling, RAM management, File Systems, and hundreds of Device Drivers—is compiled into one single, massive, contiguous binary file. The entire OS operates strictly in highly privileged \"Kernel Mode\".","**Merits:** Blisteringly fast execution. Because everything is in the same memory space, internal components communicate using direct memory pointers with zero mathematical overhead.","**Catastrophic Demerits:** A single line of faulty code in a random audio driver can violently crash the entire Kernel, triggering a total system failure (Blue Screen of Death). It is extremely difficult to maintain and mathematically impossible to secure completely."]},{"type":"subheading","content":"2. Microkernel Architecture"},{"type":"paragraph","content":"Engineered specifically to solve the fatal flaws of the Monolithic approach (utilized by macOS/Mach and QNX)."},{"type":"list","items":["**Structure:** The Kernel is violently stripped down to its absolute bare minimum mathematical components (just basic CPU scheduling and IPC - Inter-Process Communication). Everything else (File Systems, Drivers) is physically ripped out of the Kernel and forced to run in unprivileged \"User Mode\" as separate, isolated services.","**Merits:** Absolute, unbreakable stability. If a Graphics Driver crashes, it only kills the User Mode graphics process; the core Microkernel survives, and simply restarts the driver. The system mathematically cannot crash.","**Demerits:** Extreme performance degradation. Because services are isolated, they must communicate by continuously passing messages back and forth through the Microkernel, generating catastrophic CPU latency."]},{"type":"heading","content":"(b) System Calls: The Gateway to the Kernel"},{"type":"paragraph","content":"Modern CPUs operate in two strict hardware states: User Mode (restricted) and Kernel Mode (absolute power). User applications (like a web browser or a C program) are physically trapped in User Mode. They are mathematically forbidden from directly accessing the Hard Drive, RAM, or CPU registers. To perform any physical I/O, the application must aggressively beg the OS for help using a **System Call**."},{"type":"paragraph","content":"A System Call is a highly secure, mathematically verified software interrupt (a Trap) that forces the CPU to switch from User Mode to Kernel Mode, execute the privileged OS code, and then violently drop back to User Mode."},{"type":"subheading","content":"Types of System Calls"},{"type":"list","items":["**1. Process Control:** Used to violently create or terminate running programs. \n*Examples:* `fork()` (clones a process mathematically perfectly), `exec()` (loads a new binary), `exit()`, `wait()`.","**2. File Management:** Used to mathematically manipulate the data on the Hard Drive. \n*Examples:* `open()` (requests access to a file), `read()`, `write()`, `close()`.","**3. Device Management:** Used to aggressively interact with physical hardware peripherals. \n*Examples:* `ioctl()` (sends control signals to a physical device driver), `read()`, `write()`.","**4. Information Maintenance:** Used to query the OS Kernel for system data. \n*Examples:* `getpid()` (fetches the process ID), `time()`, `date()`.","**5. Communications:** Used for Inter-Process Communication (IPC) across networks or locally. \n*Examples:* `pipe()` (creates a data tunnel between processes), `shmget()` (requests shared RAM), `socket()` (opens a network connection)."]}]}},{"id":"v2-operating-system-2023-pC-q2","number":2,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the various process scheduling algorithms with examples and compare them."}],"answer":{"summary":"A definitive mathematical comparison of Process Scheduling algorithms (FCFS, SJF, SRTF, Round Robin), detailing their exact execution mechanics, wait time calculations, and the severe implications of Starvation and the Convoy Effect.","explanation":[{"type":"heading","content":"Advanced Process Scheduling Algorithms"},{"type":"paragraph","content":"In a modern multiprogramming OS, the Ready Queue is constantly flooded with dozens of processes demanding CPU time. The Short-Term Scheduler is the mathematical engine that dictates exactly which process gets the CPU next. The algorithms are strictly classified into two paradigms: **Non-Preemptive** (once a process enters the CPU, it violently holds it until completion) and **Preemptive** (the OS can aggressively rip the CPU away from a running process)."},{"type":"subheading","content":"1. First-Come, First-Served (FCFS) [Non-Preemptive]"},{"type":"paragraph","content":"The absolute simplest architecture. It uses a strict FIFO mathematical queue. \n- **Example:** P1 arrives at 0ms (Burst 24ms). P2 arrives at 1ms (Burst 3ms). P3 arrives at 2ms (Burst 3ms). \n- **Execution:** P1 executes from 0 to 24. P2 executes from 24 to 27. P3 executes from 27 to 30. \n- **Flaw:** P2 and P3 are tiny, but they are violently blocked for 24 milliseconds waiting for P1. This catastrophic bottleneck is mathematically known as the **Convoy Effect**, resulting in horrific Average Wait Times."},{"type":"subheading","content":"2. Shortest Job First (SJF) [Non-Preemptive]"},{"type":"paragraph","content":"The mathematically optimal algorithm for minimizing Average Wait Time. The Scheduler aggressively scans the queue and selects the process with the smallest exact Burst Time. \n- **Example:** P1(6ms), P2(8ms), P3(7ms), P4(3ms) all in queue. \n- **Execution:** P4(3) executes first, then P1(6), then P3(7), then P2(8). \n- **Flaw:** It mathematically guarantees **Starvation**. If a 100ms process is in the queue, and a continuous stream of 2ms processes arrives, the 100ms process will NEVER execute. Furthermore, it is practically impossible for the OS to accurately predict the exact future burst time of a process."},{"type":"subheading","content":"3. Shortest Remaining Time First (SRTF) [Preemptive SJF]"},{"type":"paragraph","content":"This is the highly aggressive, preemptive version of SJF. \n- **Mechanism:** If P1 (Burst 10ms) is executing, and after 2ms (Remaining 8ms) a new process P2 arrives with a Burst Time of 4ms, the OS mathematically compares them. Since $4 < 8$, the OS violently interrupts P1, yanks it out of the CPU, and injects P2. This ensures the absolute lowest wait times but generates massive Context Switch overhead."},{"type":"subheading","content":"4. Round Robin (RR) [Preemptive]"},{"type":"paragraph","content":"The absolute standard for Time-Sharing desktop OS architectures. \n- **Mechanism:** The OS mathematically defines a strict Time Quantum (e.g., $Q = 4$ ms). The queue is treated as a massive circular buffer. P1 gets exactly 4ms. If P1 is not done, the OS violently triggers a hardware timer interrupt, pre-empts P1, throws it to the back of the queue, and gives P2 exactly 4ms. \n- **Mathematical Tuning:** The entire performance of RR hinges on the Quantum $Q$. If $Q$ is astronomically large, RR mathematically devolves into FCFS. If $Q$ is microscopically small (e.g., 1 microsecond), the CPU spends 99% of its time executing Context Switches (saving and loading registers) and 1% actually executing code, crashing system throughput."},{"type":"svg","content":""}]}},{"id":"v2-operating-system-2023-pC-q3","number":3,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"(a) Explain the concept of Mutual Exclusion. (b) Discuss the Producer-Consumer problem using semaphores."}],"answer":{"summary":"A rigorous theoretical exposition on Mutual Exclusion utilizing Dijkstra's Semaphores, followed by the definitive mathematical implementation of the Producer-Consumer synchronization problem to eradicate race conditions.","explanation":[{"type":"heading","content":"(a) The Concept of Mutual Exclusion"},{"type":"paragraph","content":"In multi-threaded CPU architectures, memory is fiercely shared between threads. If Thread A and Thread B simultaneously execute the machine-code instructions to increment a shared integer (`Counter++`), a catastrophic hardware Race Condition occurs. The `++` operation is not atomic; it physically involves three steps: Load, Increment, Store. If Thread A loads the value, and the OS preempts it before it can store, and Thread B executes, the final mathematical value will be physically corrupted. **Mutual Exclusion (Mutex)** is the absolute non-negotiable law that states: If one thread is physically inside its Critical Section (modifying shared data), every single other thread in the universe must be violently blocked from entering that exact same section."},{"type":"heading","content":"(b) The Producer-Consumer Problem via Semaphores"},{"type":"paragraph","content":"The Producer-Consumer (Bounded-Buffer) problem is the absolute classic synchronization crisis. \n- **The Producer** generates data and violently pushes it into a fixed-size shared Buffer.\n- **The Consumer** aggressively pulls data out of the Buffer.\n- **The Catastrophe:** If the Producer runs when the buffer is completely full, data is destroyed. If the Consumer runs when the buffer is empty, it reads garbage. If they both access the buffer at the exact same millisecond, the physical memory pointers are corrupted."},{"type":"subheading","content":"The Mathematical Semaphore Solution"},{"type":"paragraph","content":"We violently enforce synchronization using three mathematical Semaphores (invented by Dijkstra). A Semaphore `S` is an integer modified strictly by two atomic operations: `Wait(S)` (decrements S; if S<0, the thread is blocked) and `Signal(S)` (increments S; wakes up a blocked thread)."},{"type":"list","items":["1. `Mutex = 1`: A binary semaphore guaranteeing absolute Mutual Exclusion inside the buffer.","2. `Empty = N`: A counting semaphore tracking the exact mathematical number of empty slots (initialized to Buffer Size N).","3. `Full = 0`: A counting semaphore tracking the exact number of filled slots (initialized to 0)."]},{"type":"subheading","content":"The Producer Code Execution"},{"type":"paragraph","content":"```c\nwhile (true) {\n Item data = produce_data();\n wait(Empty); // Decrements Empty. If buffer is full (Empty==0), Producer is violently blocked.\n wait(Mutex); // Locks the Critical Section. No one else can touch the buffer.\n \n insert_into_buffer(data); // Safely manipulate memory.\n \n signal(Mutex); // Unlocks the Critical Section.\n signal(Full); // Increments Full. Instantly wakes up the Consumer if it was sleeping.\n}\n```"},{"type":"subheading","content":"The Consumer Code Execution"},{"type":"paragraph","content":"```c\nwhile (true) {\n wait(Full); // Decrements Full. If buffer is empty (Full==0), Consumer is violently blocked.\n wait(Mutex); // Locks the Critical Section.\n \n Item data = remove_from_buffer(); // Safely extract memory.\n \n signal(Mutex); // Unlocks the Critical Section.\n signal(Empty); // Increments Empty. Instantly wakes up the Producer if it was blocked.\n consume_data(data);\n}\n```"},{"type":"paragraph","content":"This mathematical architecture absolutely guarantees zero race conditions, zero data corruption, and zero deadlock."}]}},{"id":"v2-operating-system-2023-pC-q4","number":4,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the concept of Virtual Memory in detail. Discuss the Page Replacement Algorithms with examples."}],"answer":{"summary":"An exhaustive architectural analysis of Virtual Memory and Demand Paging, explicitly detailing the catastrophic hardware Page Fault mechanism and comparing the FIFO, LRU, and Optimal Page Replacement algorithms.","explanation":[{"type":"heading","content":"Virtual Memory and Demand Paging Architecture"},{"type":"paragraph","content":"In the primitive era of computing, the absolute physical size of a program (e.g., a 10MB game) could never exceed the absolute physical size of the motherboard's RAM (e.g., 4MB). Virtual Memory is a massively complex mathematical illusion engineered by the OS Kernel and the CPU's Memory Management Unit (MMU) to completely shatter this limitation. Virtual Memory allows the execution of processes that are astronomically larger than physical RAM by mathematically utilizing the hard drive as an extension of memory."},{"type":"subheading","content":"The Mechanics of Demand Paging"},{"type":"paragraph","content":"Virtual Memory relies on **Demand Paging**. The 10MB program is mathematically sliced into 4KB blocks called \"Pages\". When the user double-clicks the game, the OS does NOT load the 10MB into RAM. It lazily loads ONLY the very first page containing the `main()` function into a RAM \"Frame\"."},{"type":"paragraph","content":"As the CPU executes, it will inevitably attempt to jump to a line of code located on Page 5. The MMU checks the Page Table and realizes Page 5 is NOT in RAM; it is still on the hard drive. This triggers a catastrophic hardware exception known as a **Page Fault**. The OS violently halts the program, commands the hard drive to read Page 5, loads it into a free RAM Frame, updates the Page Table, and restarts the CPU instruction flawlessly."},{"type":"heading","content":"Page Replacement Algorithms"},{"type":"paragraph","content":"The crisis occurs when the physical RAM is 100% full, and a Page Fault triggers. The OS must violently evict an existing page from RAM to make room. The algorithm chosen drastically impacts system speed."},{"type":"subheading","content":"1. FIFO (First-In, First-Out)"},{"type":"paragraph","content":"The OS tracks the exact time each page entered RAM. It ruthlessly evicts the absolute oldest page. \n- **Demerit:** It is mathematically blind. It might evict the core OS kernel loop just because it was loaded early. It also suffers from **Belady's Anomaly**, where physically adding more RAM to the motherboard can bizarrely cause *more* page faults."},{"type":"subheading","content":"2. LRU (Least Recently Used)"},{"type":"paragraph","content":"This is the industry standard. It relies on the mathematical principle of Temporal Locality (if you used a variable 1 millisecond ago, you will probably use it again soon). \n- **Mechanism:** The OS utilizes complex hardware counters to track the exact microsecond every single page was last accessed by the CPU. When eviction is necessary, it violently hunts down the page with the absolute oldest access timestamp (the one completely ignored by the program) and evicts it. It provides near-perfect performance."},{"type":"subheading","content":"3. Optimal Page Replacement (OPT)"},{"type":"paragraph","content":"This is a theoretical, mathematically perfect algorithm. \n- **Mechanism:** It evicts the page that will not be used for the longest period of time in the absolute FUTURE. \n- **Reality:** It is physically impossible to implement because the OS cannot mathematically predict the future execution path of the code. It is used strictly as a theoretical benchmark to measure how good LRU is."}]}},{"id":"v2-operating-system-2023-pC-q5","number":5,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"(a) Discuss the Disk Scheduling Algorithms with examples. (b) Explain the directory structures used in file systems."}],"answer":{"summary":"A deep technical exposition on mechanical Hard Disk Scheduling algorithms (FCFS, SSTF, SCAN, C-SCAN), and a thorough breakdown of hierarchical File System Directory structures.","explanation":[{"type":"heading","content":"(a) Disk Scheduling Algorithms"},{"type":"paragraph","content":"Unlike solid-state SSDs, traditional Hard Disk Drives (HDDs) are massive, violently spinning magnetic platters accessed by a physical, mechanical Read/Write head mounted on an arm. The absolute slowest operation in a computer is physically moving this mechanical arm (Seek Time). If 10 processes simultaneously request data from random tracks on the disk, the OS cannot execute the requests blindly. It must utilize Disk Scheduling algorithms to mathematically optimize the mechanical movement of the arm to prevent hardware degradation."},{"type":"subheading","content":"1. FCFS (First-Come, First-Served)"},{"type":"paragraph","content":"The requests are executed in the exact chronological order they arrived.\n- **Example:** Queue = 98, 183, 37, 122, 14. Head starts at 53.\n- **Execution:** Head moves 53 -> 98 -> 183 -> 37 -> 122 -> 14. \n- **Demerit:** The mechanical arm violently swings back and forth across the entire disk, resulting in catastrophic Seek Time and mechanical wear."},{"type":"subheading","content":"2. SSTF (Shortest Seek Time First)"},{"type":"paragraph","content":"The OS mathematically calculates the physical distance from the current head position to all pending requests, and aggressively moves to the absolute closest one.\n- **Merit:** Drastically reduces total mechanical movement compared to FCFS.\n- **Demerit (Starvation):** If the head is in the middle, and a continuous stream of requests arrives in the middle, requests at the extreme edges of the disk will mathematically starve and never be read."},{"type":"subheading","content":"3. SCAN (The Elevator Algorithm)"},{"type":"paragraph","content":"The mechanical arm behaves exactly like a building elevator. It starts at one end, sweeps all the way to the absolute physical edge of the disk (Track 0), servicing requests strictly as it passes them. Once it hits the edge, it violently reverses direction and sweeps to the other edge (Track 199).\n- **Merit:** Completely eradicates Starvation. Provides mathematically bounded wait times."},{"type":"subheading","content":"4. C-SCAN (Circular SCAN)"},{"type":"paragraph","content":"A highly aggressive optimization of SCAN. The head sweeps from Track 0 to Track 199, servicing requests. However, when it hits 199, it does NOT service requests on the reverse trip. It violently snaps back to Track 0 without reading anything, and starts sweeping up again. \n- **Merit:** Provides mathematically perfect, absolutely uniform wait times for all cylinders."},{"type":"heading","content":"(b) Directory Structures in File Systems"},{"type":"paragraph","content":"The OS must mathematically map human-readable file names (like `data.txt`) to absolute physical disk block addresses. This translation matrix is the Directory."},{"type":"list","items":["**1. Single-Level Directory:** All files for all users are dumped into one massive, flat directory. It is mathematically impossible to have two files with the exact same name. Useless for modern systems.","**2. Two-Level Directory:** The OS creates a Master File Directory (MFD), and assigns each User their own User File Directory (UFD). User A can have `data.txt` and User B can have `data.txt` without catastrophic collision.","**3. Tree-Structured (Hierarchical) Directory:** The absolute global standard (Windows, Linux, macOS). It mathematically allows users to create infinite sub-directories inside directories. It utilizes Absolute Pathnames (`/root/user/data.txt`) and Relative Pathnames (`./data.txt`), allowing massive, deeply nested organizational architectures.","**4. Acyclic-Graph Directory:** A highly advanced evolution of the Tree structure. It mathematically allows a single physical file to exist in multiple directories simultaneously utilizing Hard Links and Symbolic Links (Shortcuts). It violently prevents catastrophic infinite loops by strictly forbidding cycle formations during directory traversal."]}]}}]},{"id":"operating-system-2024","title":"Operating System (2024)","subjectSlug":"operating-system","subjectName":"Operating System","universitySlug":"rtu","branchSlug":"computer-science","year":3,"semester":5,"examYear":2024,"paperCode":"5E1753","questions":[{"id":"v2-operating-system-2024-pA-q1","number":1,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Multiprogramming?"}],"answer":{"summary":"Multiprogramming is the technique of loading and running multiple programs simultaneously in memory to maximize CPU utilization.","explanation":[{"type":"paragraph","content":"Multiprogramming is the organization of multiple jobs (programs) in memory simultaneously so that the CPU always has one to execute, improving CPU utilization. When one process is waiting for I/O, the OS switches the CPU to another process. This ensures the CPU is never idle due to I/O waits. It requires memory management and scheduling. Unlike multitasking, users do not interact with running processes in a traditional multiprogramming environment."}]}},{"id":"v2-operating-system-2024-pA-q2","number":2,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Context Switching."}],"answer":{"summary":"Context switching is the process of saving the state of a currently running process and restoring the state of the next process to be executed.","explanation":[{"type":"paragraph","content":"Context switching is the mechanism by which the CPU switches from one process (or thread) to another. The state (context) of the currently running process is saved into its Process Control Block (PCB), and the context of the next selected process is restored from its PCB. The context includes the program counter, CPU registers, stack pointer, and memory management information. Context switching is pure overhead — no useful work is done during the switch. The time taken depends on hardware support (e.g., register sets)."}]}},{"id":"v2-operating-system-2024-pA-q3","number":3,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is a Thread?"}],"answer":{"summary":"A thread is the smallest unit of CPU execution within a process, sharing the process's resources while having its own program counter, registers, and stack.","explanation":[{"type":"paragraph","content":"A thread (or lightweight process) is a basic unit of CPU utilization within a process. Each thread has its own thread ID, program counter, register set, and stack. However, all threads of the same process share the process's code section, data section, heap, and OS resources (open files, signals). Multithreading allows a program to perform multiple tasks concurrently. Examples: A web browser uses one thread to display images while another thread retrieves data from the network. Threads are faster to create and switch between compared to processes."}]}},{"id":"v2-operating-system-2024-pA-q4","number":4,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Race Condition."}],"answer":{"summary":"A race condition is a situation where the outcome of a computation depends on the relative order of execution of multiple concurrent processes accessing shared data.","explanation":[{"type":"paragraph","content":"A race condition occurs when two or more processes/threads access and manipulate shared data concurrently, and the final result depends on the order of access. For example, if processes P1 and P2 both read a shared variable count (=5), increment it, and write back, the result may be 6 instead of 7 if their operations are interleaved. Race conditions lead to data inconsistency and are prevented by synchronization mechanisms (semaphores, mutex locks, monitors)."}]}},{"id":"v2-operating-system-2024-pA-q5","number":5,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Monitor?"}],"answer":{"summary":"A monitor is a high-level synchronization construct that encapsulates shared data and the procedures to access it, ensuring mutual exclusion automatically.","explanation":[{"type":"paragraph","content":"A monitor is an abstract data type (ADT) that encapsulates shared data variables and the procedures (operations) that operate on them, along with a synchronization mechanism. The monitor guarantees that only one process can be active within the monitor at a time (mutual exclusion is automatic). Condition variables (cond.wait() and cond.signal()) are used within monitors to allow processes to wait for specific conditions. Monitors are easier and safer to use than semaphores for writing correct concurrent programs. Example: Java's synchronized keyword provides monitor-like behavior."}]}},{"id":"v2-operating-system-2024-pA-q6","number":6,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Segmentation."}],"answer":{"summary":"Segmentation is a memory management scheme that supports the user's view of memory by dividing a program into logically related units called segments.","explanation":[{"type":"paragraph","content":"Segmentation is a non-contiguous memory management technique where a program is divided into variable-sized logical units called segments (e.g., code segment, data segment, stack segment). Each segment has a name and length. The logical address consists of a segment number and an offset. A segment table maps each segment number to its base address and limit in physical memory. Segmentation supports the user's logical view of memory and allows sharing and protection at the segment level. It can cause external fragmentation."}]}},{"id":"v2-operating-system-2024-pA-q7","number":7,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is Demand Paging?"}],"answer":{"summary":"Demand Paging is a virtual memory technique where pages are loaded into physical memory only when they are accessed (demanded), rather than loading the entire program upfront.","explanation":[{"type":"paragraph","content":"In demand paging, pages of a process are loaded into memory only when they are needed. Initially, the process starts with no pages in memory. When a page is referenced that is not in memory, a page fault occurs, and the OS loads the required page from disk into a free frame. This reduces initial loading time, reduces memory usage, and allows processes larger than physical memory to run. It relies on the principle of locality of reference."}]}},{"id":"v2-operating-system-2024-pA-q8","number":8,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Spooling."}],"answer":{"summary":"Spooling (Simultaneous Peripheral Operations Online) is a technique where data is temporarily stored on disk for use by a slow peripheral device like a printer.","explanation":[{"type":"paragraph","content":"Spooling is a process in which data is temporarily held in a buffer (usually on disk — the spool) to be used and executed by a device, program, or system that cannot accept the data for processing at the same rate it is sent. The most classic example is print spooling: print jobs from multiple users are stored in a disk queue, and the printer processes them one at a time. This allows multiple users to submit print jobs concurrently without waiting. Spooling effectively overlaps I/O operations with computation, improving overall efficiency."}]}},{"id":"v2-operating-system-2024-pA-q9","number":9,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is a Device Driver?"}],"answer":{"summary":"A device driver is a software module that controls and manages a specific hardware device, providing a standard interface between the OS kernel and the hardware.","explanation":[{"type":"paragraph","content":"A device driver is a specialized software component that allows the operating system to communicate with and control a hardware device (such as a keyboard, mouse, graphics card, or disk drive). It translates generic OS I/O commands into device-specific instructions understood by the hardware. Each device has its own driver that is either built into the kernel or loaded as a kernel module. Device drivers run in kernel mode and handle interrupts from devices. Examples: GPU drivers (NVIDIA, AMD), network card drivers, USB drivers."}]}},{"id":"v2-operating-system-2024-pA-q10","number":10,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define Disk Scheduling."}],"answer":{"summary":"Disk scheduling is the technique used by the OS to determine the order in which disk I/O requests are processed to minimize total seek time and improve disk throughput.","explanation":[{"type":"paragraph","content":"Disk scheduling refers to the set of algorithms and policies used by the OS to manage and order the pending disk I/O requests. Since disk access involves mechanical movement of the read/write head (seek time), the order in which requests are processed significantly affects performance. Common disk scheduling algorithms include FCFS, SSTF (Shortest Seek Time First), SCAN (Elevator), C-SCAN, LOOK, and C-LOOK. The goal is to minimize total head movement and improve throughput while ensuring fairness."}]}},{"id":"v2-operating-system-2024-pB-q1","number":1,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the differences between Process and Thread."}],"answer":{"summary":"Processes and threads differ in resource allocation, overhead, communication mechanisms, and the level of isolation they provide.","explanation":[{"type":"paragraph","content":"A process is an independent program in execution with its own address space, while a thread is a unit of execution within a process that shares the process's resources. Key differences:"},{"type":"list","items":["Resource Sharing: Threads share the code, data, heap, and open files of their parent process. Processes have separate address spaces and do not share memory by default.","Creation Overhead: Thread creation is much faster and requires fewer resources than process creation (fork()). Threads are called 'lightweight processes' for this reason.","Communication: Inter-thread communication is easy since threads share memory. Inter-process communication (IPC) requires pipes, sockets, shared memory, or message queues — more complex and slower.","Context Switching: Thread context switching is faster (only stack and registers switch); process context switching requires switching the entire memory map and other resources.","Isolation/Protection: Processes are isolated — a crash in one process does not affect others. A crash in one thread can crash the entire process.","Synchronization: Threads require careful synchronization (locks, semaphores) to avoid race conditions on shared data. Processes are naturally isolated.","Use Cases: Use multiple threads when tasks share data and need fast communication. Use multiple processes for tasks needing strong isolation (e.g., web server processes separate requests)."]},{"type":"paragraph","content":"Examples: A web browser uses threads for rendering (UI thread) and networking. A web server like Apache uses separate processes per request for isolation. Modern applications commonly use multi-threading (Java threads, pthreads in C)."}]}},{"id":"v2-operating-system-2024-pB-q2","number":2,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Describe the Round Robin Scheduling algorithm with an example."}],"answer":{"summary":"Round Robin is a preemptive CPU scheduling algorithm where each process is given a fixed time quantum in cyclic order, ideal for time-sharing systems.","explanation":[{"type":"paragraph","content":"Round Robin (RR) scheduling is designed especially for time-sharing systems. The ready queue is treated as a circular queue. The CPU scheduler assigns the CPU to each process for a time interval (time quantum or time slice), typically 10–100 milliseconds."},{"type":"paragraph","content":"Algorithm: (1) Processes are arranged in a circular ready queue. (2) The scheduler picks the first process and sets a timer for one quantum. (3) If the process finishes before the quantum expires, it releases the CPU voluntarily. (4) If the process does not finish, the timer interrupts, the process is preempted, and it is placed at the end of the ready queue."},{"type":"paragraph","content":"Example: Processes P1(Burst=24ms), P2(Burst=3ms), P3(Burst=3ms), all arrive at t=0. Time Quantum = 4ms."},{"type":"list","items":["Gantt Chart: [P1(0-4) | P2(4-7) | P3(7-10) | P1(10-14) | P1(14-18) | P1(18-22) | P1(22-26) | P1(26-30)]","Completion times: P1=30, P2=7, P3=10","Waiting times: P1=(30-24)=6, P2=(7-3)=4, P3=(10-3)=7 — Wait = Completion - Burst","Average Waiting Time = (6+4+7)/3 = 5.67 ms","Average Turnaround Time = (30+7+10)/3 = 15.67 ms"]},{"type":"paragraph","content":"Performance of RR heavily depends on the size of the time quantum. A very large quantum makes RR behave like FCFS. A very small quantum (approaching 0) provides the effect of processor sharing but context switching overhead becomes prohibitive. An appropriate quantum is typically slightly larger than the duration of a typical CPU burst. RR gives good response time for all processes and is fair, making it the default algorithm for most time-sharing OS."}]}},{"id":"v2-operating-system-2024-pB-q3","number":3,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the Peterson's Solution for the Critical Section Problem."}],"answer":{"summary":"Peterson's Solution is a software-based algorithm that correctly solves the Critical Section Problem for two processes using shared variables.","explanation":[{"type":"paragraph","content":"Peterson's Solution is a classic software-based solution to the Critical Section Problem for two processes (P0 and P1). It uses two shared variables: (1) int turn — indicates whose turn it is to enter the critical section. (2) boolean flag[2] — flag[i] = true means process Pi is ready to enter its critical section."},{"type":"heading","content":"Algorithm for Process Pi (where j = 1-i):"},{"type":"paragraph","content":"Entry Section: flag[i] = true; turn = j; while (flag[j] && turn == j); /* busy wait */ Critical Section: (access shared resource) Exit Section: flag[i] = false; Remainder Section: (rest of program)"},{"type":"heading","content":"Proof of Correctness:"},{"type":"list","items":["Mutual Exclusion: Both processes can only be in the CS simultaneously if both flag[0] and flag[1] are true, and both turn==0 and turn==1. Since turn is a single variable, it cannot be both 0 and 1 simultaneously. Hence mutual exclusion is satisfied.","Progress: If no process is in the CS and both want to enter, the one whose turn it is enters. The while loop condition will eventually become false for one process.","Bounded Waiting: After setting turn = j, process Pi waits at most one critical section execution by Pj before entering."]},{"type":"paragraph","content":"Limitation: Peterson's Solution may not work correctly on modern architectures with reordered instructions (memory reordering). Memory barriers or atomic operations are required on such hardware. It is also limited to two processes; for n processes, more complex algorithms (Bakery Algorithm) are needed."}]}},{"id":"v2-operating-system-2024-pB-q4","number":4,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Discuss the methods of handling deadlock (prevention, avoidance, detection)."}],"answer":{"summary":"Deadlock can be handled through three main strategies: Prevention (eliminate necessary conditions), Avoidance (safe-state checking), and Detection & Recovery.","explanation":[{"type":"paragraph","content":"Deadlock handling methods fall into three categories:"},{"type":"heading","content":"1. Deadlock Prevention"},{"type":"paragraph","content":"Prevent at least one of the four Coffman conditions from holding: (a) Mutual Exclusion: Make resources sharable where possible (e.g., read-only files). Not always possible. (b) Hold and Wait: Require a process to request all resources before starting (low resource utilization) or release all resources before requesting new ones. (c) No Preemption: If a process requests a resource that cannot be immediately allocated, preempt all its currently held resources. (d) Circular Wait: Impose a total ordering on resource types and require processes to request in increasing order only."},{"type":"heading","content":"2. Deadlock Avoidance"},{"type":"paragraph","content":"Requires processes to declare maximum resource needs in advance. The system uses this information to ensure it never enters an unsafe state. The Banker's Algorithm checks whether granting a request will leave the system in a safe state (a state from which all processes can eventually complete). If unsafe, the request is denied."},{"type":"heading","content":"3. Deadlock Detection and Recovery"},{"type":"paragraph","content":"Allow deadlocks to occur but detect and recover from them. Detection: Use a resource allocation graph (for single instance resources) or a detection algorithm similar to Banker's (for multiple instances). Recovery options: (a) Process Termination — abort all deadlocked processes, or abort one at a time until deadlock is broken. (b) Resource Preemption — preempt resources from some process and give them to others, then roll back the preempted process to a safe state."},{"type":"paragraph","content":"Most modern OS (like Windows and Linux) ignore deadlocks (Ostrich Algorithm), relying on application-level handling, acceptable only when deadlocks are rare. Databases use deadlock detection and rollback."}]}},{"id":"v2-operating-system-2024-pB-q5","number":5,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the concept of Segmentation with its advantages and disadvantages."}],"answer":{"summary":"Segmentation is a memory management scheme where a program is divided into variable-sized logical segments, each with its own base and limit in physical memory.","explanation":[{"type":"paragraph","content":"In segmentation, the logical address space is divided into variable-size segments (code, data, stack, heap, etc.). A logical address is a pair (segment-number, offset). The segment table contains the base address and limit (size) for each segment. The CPU translates a logical address by looking up the segment table: physical address = base[segment-number] + offset (if offset < limit)."},{"type":"heading","content":"Advantages of Segmentation:"},{"type":"list","items":["Supports the user's logical view of memory (code, data, stack are naturally separate segments).","Facilitates sharing of code segments (e.g., shared library segments can be mapped into multiple processes).","Provides protection at the segment level (e.g., code segment can be marked read-only).","Segments can grow or shrink independently (e.g., stack or heap).","No internal fragmentation — segments are exactly as large as needed."]},{"type":"heading","content":"Disadvantages of Segmentation:"},{"type":"list","items":["External Fragmentation: Variable-size segments leave holes in physical memory over time.","Compaction required to eliminate fragmentation — expensive.","Segment table overhead: Each process needs a full segment table in memory.","More complex memory management than paging."]},{"type":"paragraph","content":"Modern systems often combine segmentation with paging (segmented paging or paged segmentation) to get benefits of both. Intel x86 architecture uses a segmentation model (though most modern OS like Linux use a flat segmentation model effectively bypassing it)."}]}},{"id":"v2-operating-system-2024-pB-q6","number":6,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Describe the different disk scheduling algorithms (FCFS, SSTF, SCAN)."}],"answer":{"summary":"FCFS, SSTF, and SCAN are disk scheduling algorithms that order I/O requests to minimize disk head movement and reduce access times.","explanation":[{"type":"paragraph","content":"Disk scheduling algorithms order the service of disk I/O requests to minimize seek time. Consider head initially at cylinder 53 and pending requests: 98, 183, 37, 122, 14, 124, 65, 67."},{"type":"heading","content":"1. FCFS (First-Come, First-Served)"},{"type":"paragraph","content":"Requests are serviced in arrival order: 53→98→183→37→122→14→124→65→67. Total head movement = 45+85+146+85+108+110+59+2 = 640 cylinders. Advantage: Simple and fair, no starvation. Disadvantage: Inefficient with high seek time; the arm moves back and forth across the disk."},{"type":"heading","content":"2. SSTF (Shortest Seek Time First)"},{"type":"paragraph","content":"At each step, service the request nearest to the current head position: 53→65→67→37→14→98→122→124→183. Total movement = 12+2+30+23+84+24+2+59 = 236 cylinders. Advantage: Much better than FCFS; reduces average seek time significantly. Disadvantage: Can cause starvation for requests far from the current head position; not optimal."},{"type":"heading","content":"3. SCAN (Elevator Algorithm)"},{"type":"paragraph","content":"The head moves in one direction (say, toward higher cylinders), services all requests in its path, reaches the end (or last request), then reverses direction. Starting at 53 moving up: 53→65→67→98→122→124→183→(reverse)→37→14. Total movement = 130+169 = 299 cylinders (roughly). Advantage: Efficient, no starvation, more uniform service. Disadvantage: Processes that just missed the head must wait for a full sweep."},{"type":"paragraph","content":"C-SCAN (Circular SCAN) improves on SCAN by always sweeping in one direction and jumping back to the beginning, providing more uniform wait times. LOOK and C-LOOK are practical variants that don't go to disk ends but only to the last request in each direction. Modern OS typically use C-LOOK or deadline schedulers."}]}},{"id":"v2-operating-system-2024-pB-q7","number":7,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the concept of File Access methods."}],"answer":{"summary":"File access methods determine how data in a file can be read or written, with sequential, direct, and indexed being the main methods.","explanation":[{"type":"paragraph","content":"A file access method defines the manner in which data in a file can be accessed. The main file access methods are:"},{"type":"list","items":["Sequential Access: The simplest access method. Information in the file is processed in order, one record after another. Read advances a file pointer; write appends to the end of file. Most common for text files and streams. Example: Tape drives, log files. Rewinding/backtracking is allowed but not efficient for random access.","Direct (Random) Access: A file is made of fixed-length logical records that allow programs to read and write records rapidly in no particular order. The file is viewed as a numbered sequence of blocks/records. Operations: read(n) and write(n) where n is the block number. Efficient for applications like databases and airline reservations that need fast random record retrieval.","Indexed Access: Built on top of direct access. Maintains an index file that contains pointers to the various blocks of the main file. To find a record, search the index for the pointer, then use it to directly access the main file block. Allows fast searching by key. Used in database systems and file systems (e.g., ISAM — Indexed Sequential Access Method).","Indexed Sequential Access (ISAM): Combines sequential and indexed access. Records are stored sequentially; an index of key fields provides direct access to any record. Supports both sequential and random retrieval efficiently."]},{"type":"paragraph","content":"The choice of access method depends on the application. Most OS provide sequential and direct access at the file system level; applications implement indexed access. UNIX treats all files as sequences of bytes supporting both sequential and direct (lseek) access."}]}},{"id":"v2-operating-system-2024-pC-q1","number":1,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"(a) Explain the Process Control Block (PCB) in detail. (b) Describe the different states of a process with a state transition diagram."}],"answer":{"summary":"The PCB stores all information needed to manage a process, while the process state transition diagram shows how processes move between states during their lifetime.","explanation":[{"type":"heading","content":"Part (a): Process Control Block (PCB)"},{"type":"paragraph","content":"The Process Control Block (PCB), also called the Task Control Block, is the data structure used by the OS kernel to store all information about a process. Each process has exactly one PCB. The OS uses PCBs to manage, schedule, and control processes. When a context switch occurs, the current process's state is saved in its PCB and the next process's state is restored from its PCB."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/process-control-block.svg","alt":"Process Control Block Structure","caption":"Figure 1: Structure of a Process Control Block (PCB)"},{"type":"heading","content":"PCB Contains the Following Information:"},{"type":"list","items":["Process State: Current state of the process (new, ready, running, waiting, terminated).","Process ID (PID): Unique identifier for each process.","Program Counter (PC): Address of the next instruction to be executed.","CPU Registers: Contents of all CPU registers (accumulators, index registers, stack pointer, general-purpose registers) that must be saved and restored on context switch.","CPU Scheduling Information: Process priority, scheduling queue pointers, and other scheduling parameters.","Memory Management Information: Base and limit registers, page tables, or segment tables depending on the memory system used.","Accounting Information: CPU time used, elapsed real time, time limits, account numbers, job or process numbers.","I/O Status Information: List of I/O devices allocated to the process, list of open files, pending I/O requests."]},{"type":"heading","content":"Part (b): Process States and State Transition Diagram"},{"type":"paragraph","content":"A process passes through a series of distinct states during its lifetime. The process state is stored in the PCB and is updated by the OS."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/process-state-diagram.svg","alt":"Process State Transition Diagram","caption":"Figure 2: Process State Transition Diagram showing five states"},{"type":"heading","content":"Five-State Process Model:"},{"type":"list","items":["New: The process is being created. The OS is setting up the PCB and allocating resources. Transition: New → Ready (after admission by the OS long-term scheduler).","Ready: The process is waiting to be assigned to the CPU. It has all resources except the CPU. Multiple processes can be in the ready state simultaneously (ready queue). Transition: Ready → Running (short-term scheduler dispatches it).","Running: The process is currently executing on the CPU. Only one process per CPU core can be in running state. Transitions: Running → Waiting (process requests I/O or event), Running → Ready (preempted by scheduler or time quantum expires), Running → Terminated (process finishes).","Waiting (Blocked): The process is waiting for an event (I/O completion, signal, resource). Cannot proceed until the event occurs. Transition: Waiting → Ready (I/O completes or event occurs).","Terminated: The process has finished execution. The OS deallocates its resources and removes its PCB. Also called the exit state."]},{"type":"paragraph","content":"In some models, two additional states are added: Suspended Ready and Suspended Waiting, to handle swapping of processes to disk when memory is insufficient. The medium-term scheduler handles these transitions (swap in/swap out)."}]}},{"id":"v2-operating-system-2024-pC-q2","number":2,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain Deadlock in detail. Discuss the necessary conditions for Deadlock and the methods to handle it with suitable examples."}],"answer":{"summary":"Deadlock is a system state where processes are permanently blocked. It requires four necessary conditions and can be handled by prevention, avoidance, detection, and recovery.","explanation":[{"type":"heading","content":"Deadlock — Definition"},{"type":"paragraph","content":"A deadlock is a situation where a set of processes are permanently blocked, each waiting for a resource held by another process in the same set. No process can proceed, none can release resources, and none can be awakened. This is a permanent blocking as opposed to a temporary wait."},{"type":"paragraph","content":"Example: Process P1 holds Resource R1 and needs R2. Process P2 holds Resource R2 and needs R1. Neither can proceed — classic deadlock."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/deadlock-resource-allocation-graph.svg","alt":"Resource Allocation Graph showing Deadlock","caption":"Figure 3: Resource Allocation Graph with Circular Wait (Deadlock)"},{"type":"heading","content":"Necessary Conditions for Deadlock (Coffman Conditions)"},{"type":"paragraph","content":"All four of the following conditions must hold simultaneously for a deadlock to occur:"},{"type":"list","items":["Mutual Exclusion: At least one resource must be held in a non-shareable mode. Only one process at a time can use the resource. If another process requests that resource, it must wait.","Hold and Wait: A process must be holding at least one resource and waiting to acquire additional resources that are currently held by other processes.","No Preemption: Resources cannot be preempted; a resource can be released only voluntarily by the process holding it after it has completed its task.","Circular Wait: A set of processes {P0, P1, …, Pn} must exist such that P0 waits for a resource held by P1, P1 waits for a resource held by P2, …, Pn waits for a resource held by P0 — forming a circular chain."]},{"type":"heading","content":"Methods to Handle Deadlock"},{"type":"heading","content":"1. Deadlock Prevention"},{"type":"paragraph","content":"Ensure that at least one of the four necessary conditions cannot hold. Strategies: Eliminate Mutual Exclusion (use sharable resources where possible), Eliminate Hold and Wait (request all resources at once or release all before new request), Allow Preemption (preempt resources from waiting processes), Eliminate Circular Wait (impose total ordering on resource types and require processes to request resources in increasing order)."},{"type":"heading","content":"2. Deadlock Avoidance — Banker's Algorithm"},{"type":"paragraph","content":"The OS dynamically decides whether each resource request should be granted based on future possible states. Requires each process to declare its maximum resource needs a priori. The Banker's Algorithm checks if granting a request leads to a safe state. A safe state guarantees a safe sequence exists — all processes can eventually complete. If the resulting state is unsafe, the request is postponed."},{"type":"heading","content":"3. Deadlock Detection"},{"type":"paragraph","content":"Allow deadlocks to occur. Periodically run a detection algorithm: For single-instance resources, detect cycles in the Resource Allocation Graph (RAG). For multiple-instance resources, use an algorithm similar to the Banker's algorithm (maintaining Wait-For graph). Run periodically or when CPU utilization drops suspiciously low."},{"type":"heading","content":"4. Deadlock Recovery"},{"type":"list","items":["Process Termination: Abort all deadlocked processes (drastic but simple). Or abort processes one at a time (by priority, resources held, time used) until deadlock is broken — re-run detection after each abort.","Resource Preemption: Select a victim process, preempt its resources, rollback the victim to a safe state (or restart it), and continue. Must consider victim selection (minimize cost), rollback (safe state or total restart), and starvation prevention (limit the number of times a process is victim)."]}]}},{"id":"v2-operating-system-2024-pC-q3","number":3,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"(a) Explain the concept of Memory Management. (b) Discuss Fixed and Variable Partition Memory allocation schemes."}],"answer":{"summary":"Memory management allocates physical memory to processes efficiently. Fixed partitioning uses static regions while variable partitioning uses dynamic allocation based on process needs.","explanation":[{"type":"heading","content":"Part (a): Memory Management"},{"type":"paragraph","content":"Memory Management is the functionality of an OS that handles the allocation and deallocation of physical memory (RAM) to processes. The main goals of memory management are: (1) Relocation — a program can be placed anywhere in memory and must be able to run correctly. (2) Protection — a process should not be able to access another process's memory. (3) Sharing — multiple processes should be able to share common data/code. (4) Logical organization — support the program's logical structure (segments, modules). (5) Physical organization — manage data flow between main memory and disk."},{"type":"paragraph","content":"Address binding converts logical addresses (used by programs) to physical addresses (actual hardware addresses). It can occur at compile time, load time, or execution time. Modern systems use execution-time binding with hardware support (MMU — Memory Management Unit)."},{"type":"heading","content":"Part (b): Fixed Partition Memory Allocation"},{"type":"paragraph","content":"In Fixed Partition (Static) allocation, memory is divided into a fixed number of partitions at system boot time. Each partition has a fixed size and can contain exactly one process. The OS maintains a table of partitions (size, status — free/busy)."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/fixed-variable-partition.svg","alt":"Fixed and Variable Partition Memory Allocation","caption":"Figure 4: Fixed Partition vs Variable Partition Memory Allocation"},{"type":"list","items":["Equal-size partitions: Any process whose size ≤ partition size can use any free partition. Simple but inflexible — large processes may not fit.","Unequal-size partitions: Partitions of different sizes. Processes are assigned to the smallest partition that fits (best fit within partitions).","Advantage: Simple to implement; OS overhead is low.","Disadvantage: Internal Fragmentation — partition may not be fully used. Degree of multiprogramming is limited to the number of partitions. Large processes may not fit at all.","Example: IBM OS/MFT (Multiprogramming with a Fixed number of Tasks)."]},{"type":"heading","content":"Variable Partition Memory Allocation"},{"type":"paragraph","content":"In Variable Partition (Dynamic) allocation, partitions are created at runtime as processes arrive. Memory is allocated exactly as much as a process needs. As processes finish, their memory is freed, creating holes of various sizes."},{"type":"list","items":["Allocation Strategies: First Fit (allocate first hole that is big enough — fastest), Best Fit (allocate smallest hole that fits — minimizes wasted space but leaves tiny unusable holes), Worst Fit (allocate largest hole — leaves largest remaining hole for future use; generally worst performer).","Advantage: No internal fragmentation; supports larger processes.","Disadvantage: External Fragmentation — over time, free memory breaks into many small holes that individually cannot satisfy requests. Compaction (shuffling processes to consolidate holes) requires relocation support and is time-consuming.","Example: IBM OS/MVT (Multiprogramming with a Variable number of Tasks)."]},{"type":"paragraph","content":"Modern OS use paging and segmentation rather than contiguous partitioned allocation to eliminate external fragmentation and provide flexible memory management. The concepts of fixed and variable partitioning are foundational for understanding why paging and segmentation were developed."}]}},{"id":"v2-operating-system-2024-pC-q4","number":4,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the concept of Paging in detail. Discuss the page table structure and TLB (Translation Lookaside Buffer)."}],"answer":{"summary":"Paging is a non-contiguous memory management scheme using page tables for address translation, with TLB providing fast hardware-assisted lookups.","explanation":[{"type":"heading","content":"Paging — Concept"},{"type":"paragraph","content":"Paging is a memory management scheme that allows the physical address space of a process to be non-contiguous. Logical memory is divided into fixed-size blocks called pages (typically 4KB), and physical memory is divided into fixed-size blocks called frames of the same size. When a process is to be executed, its pages are loaded into any available memory frames."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/paging-address-translation.svg","alt":"Paging Address Translation Diagram","caption":"Figure 5: Paging Address Translation using Page Table and TLB"},{"type":"heading","content":"Address Translation in Paging"},{"type":"paragraph","content":"A logical address generated by the CPU is divided into two parts: Page Number (p) — used as an index into the page table to find the corresponding frame number. Page Offset (d) — combined with the frame base address to form the physical address. Physical Address = Frame Base Address + Offset."},{"type":"heading","content":"Page Table Structure"},{"type":"paragraph","content":"The page table is a per-process data structure that maps page numbers to frame numbers. Each entry (Page Table Entry — PTE) contains:"},{"type":"list","items":["Frame Number: The physical frame where the page resides.","Valid/Invalid Bit: Indicates whether the page is currently in physical memory (valid) or on disk (invalid — causes page fault).","Protection Bits: Read, write, execute permissions.","Dirty Bit (Modified Bit): Set when the page has been written to. Used to decide if the page must be written to disk when replaced.","Reference Bit (Accessed Bit): Set when the page is accessed. Used by page replacement algorithms."]},{"type":"heading","content":"Types of Page Table Structures"},{"type":"list","items":["Simple (Single-Level) Page Table: One table for the entire address space. For 32-bit address space with 4KB pages, the page table has 2^20 ≈ 1M entries — too large.","Two-Level (Hierarchical) Page Table: The page table itself is paged. Used in 32-bit x86 (two levels). Reduces memory required for page tables using outer and inner page tables.","Hashed Page Table: A hash table used for address spaces > 32 bits. The page number is hashed to find the frame number.","Inverted Page Table: One entry per physical frame (not per logical page). Reduces page table memory but increases search time. Used in IBM and PowerPC."]},{"type":"heading","content":"TLB — Translation Lookaside Buffer"},{"type":"paragraph","content":"Accessing the page table in main memory for every memory reference doubles the memory access time. The Translation Lookaside Buffer (TLB) is a fast, small hardware cache (typically 64–1024 entries) inside the MMU that stores recently used page-to-frame mappings."},{"type":"list","items":["TLB Hit: If the page number is found in the TLB, the frame number is obtained directly. Access time ≈ TLB access time + memory access time.","TLB Miss: If not found in TLB, the page table in memory must be accessed, then the TLB is updated with the new mapping. Access time ≈ 2 × memory access time (page table + actual access).","Hit Ratio (α): The fraction of times a page number is found in the TLB. Effective Access Time (EAT) = α(TLB time + mem time) + (1-α)(TLB time + 2 × mem time).","ASID (Address Space ID): TLBs may store ASIDs to differentiate between entries of different processes, avoiding TLB flush on context switches."]},{"type":"paragraph","content":"Example: TLB access time = 20ns, memory access time = 100ns, hit ratio α = 0.80. EAT = 0.80 × (20+100) + 0.20 × (20+200) = 96 + 44 = 140ns (vs 200ns without TLB). TLB dramatically reduces effective memory access time, making paging practical."}]}},{"id":"v2-operating-system-2024-pC-q5","number":5,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the File System structure. Discuss the different file organization methods and directory structures with examples."}],"answer":{"summary":"The file system structure provides organized storage through layered design, while file organization methods and directory structures define how files are stored and accessed.","explanation":[{"type":"heading","content":"File System Structure"},{"type":"paragraph","content":"A file system provides the mechanism for on-line storage and access to both data and programs. It consists of two distinct parts: a collection of files (each storing related data) and a directory structure (organizing and providing information about all the files in the system). File systems are stored permanently on secondary storage (disks)."},{"type":"svg","src":"/assets/diagrams/rtu/cs/2024/operating-system/file-system-layered-structure.svg","alt":"Layered File System Structure","caption":"Figure 6: Layered Structure of a File System"},{"type":"heading","content":"Layered File System Structure"},{"type":"list","items":["Application Programs: User programs that request file operations.","Logical File System: Manages file metadata (directory structures, file control blocks/inodes). Translates file names to file control block numbers.","File-Organization Module: Knows about files and their logical and physical blocks. Translates logical block addresses to physical block addresses. Includes free-space management.","Basic File System: Issues generic commands to the device driver to read and write physical blocks on disk.","I/O Control: Device drivers and interrupt handlers that transfer data between disk and main memory.","Devices: Physical disk drives."]},{"type":"heading","content":"File Organization Methods (File Allocation Methods)"},{"type":"list","items":["Contiguous Allocation: Each file occupies a set of contiguous disk blocks. Simple directory entry (starting block + length). Supports both sequential and direct access. Suffers from external fragmentation and file growth difficulties. Example: CD-ROM file systems.","Linked Allocation: Each file is a linked list of disk blocks scattered anywhere on disk. Each block contains a pointer to the next block. The directory contains only the first block pointer. Eliminates external fragmentation; supports dynamic growth. Disadvantage: Only sequential access; pointer overhead; pointer loss causes data loss. FAT (File Allocation Table) stores all links in a separate table — enables direct access. Used in DOS/Windows FAT32.","Indexed Allocation: Each file has an index block containing all pointers to its data blocks. Directory entry points to the index block. Supports direct access without external fragmentation. For large files: linked index blocks, multilevel index, or combined scheme (like Unix inode). Unix inode: 12 direct pointers + 1 single indirect + 1 double indirect + 1 triple indirect."]},{"type":"heading","content":"Directory Structures"},{"type":"paragraph","content":"A directory maps file names to their file control blocks. Various directory organization structures exist:"},{"type":"list","items":["Single-Level Directory: All files in one directory. Simple but requires unique names for all files; not practical for multiple users. Oldest structure.","Two-Level Directory: Separate User File Directory (UFD) for each user; Master File Directory (MFD) at top level. Solves naming conflict between users. Cannot group files by type/project; limited sharing.","Tree-Structured Directory: Generalization to arbitrary depth. Sub-directories form a tree rooted at '/' (root). Supports grouping of files by project, type, etc. Absolute path from root; relative path from current directory. Most widely used (UNIX, Windows). Deletion of directory with files requires recursive deletion or only empty directories allowed.","Acyclic-Graph Directory: Allows sharing of files/directories. Implemented with hard links (directory entry pointing to same inode) and symbolic (soft) links (a file containing path to target). Link count in inode prevents premature deletion. Used in UNIX/Linux.","General Graph Directory: Allows arbitrary links including cycles. Requires garbage collection for cycle detection and removal of unreachable files. Rarely used in practice."]},{"type":"paragraph","content":"Example: In Linux (ext4), the file system uses indexed allocation (inodes with direct + indirect block pointers), tree-structured directories with acyclic-graph extension (hard links and symlinks). Windows NTFS uses a Master File Table (MFT) where every file/directory is a record with extents for data allocation."}]}}]}],"loading":false,"error":null}}}

Q2Operating System

Question

Answer