Chapter 2: Stack-Based Process Queue Key Points: Stack-Based Process Queue: A Last-In, First-Out (LIFO) data structure. Processes are managed like a stack: the most recently added... Chapter 2: Stack-Based Process Queue Key Points: Stack-Based Process Queue: A Last-In, First-Out (LIFO) data structure. Processes are managed like a stack: the most recently added process is handled first. Used for managing function calls and returning execution to the correct location after each function ends. Example: A recursive function uses the stack to store local variables and return addresses. Process States (State Diagram): New: The process is being created. Ready: The process is in the queue, waiting for CPU allocation. Running: The process is actively executing on the CPU. Waiting: The process is paused, waiting for an event (e.g., I/O completion). Terminated: The process has completed execution. Transitions: The OS moves processes between states using scheduling and interrupts. Functionality of the OS: Resource Management: Allocates CPU, memory, and I/O resources efficiently. Scheduling: Ensures processes are executed in an optimal order. Security: Protects data and system integrity. Error Handling: Detects and responds to system failures or process errors. Chapter 5: Risk Conditions and Deadlock Handling Risk Conditions for Deadlock (Important): Mutual Exclusion: Only one process can access a resource at a time. Hold and Wait: Processes holding resources can request additional resources. No Preemption: Resources cannot be forcibly taken from a process; they must be released voluntarily. Circular Wait: A closed chain of processes exists, where each process holds a resource the next process needs. Handling Deadlocks: Prevention: Modify resource allocation policies to eliminate one of the four conditions. Avoidance: Use algorithms like the Banker’s Algorithm. Detection: Identify deadlocks by analyzing resource allocation graphs. Recovery: Terminate processes. Preempt resources. Banker’s Algorithm for Deadlock Detection (Requires Calculation): Maintain these matrices: Available: Total free resources. Max: Maximum resources each process may need. Allocation: Resources currently allocated to processes. Need: Need = Max - Allocation Steps: Find a process whose Need is less than or equal to Available. Simulate allocating resources and mark the process as finished. Repeat until all processes are finished or a deadlock is detected. Chapter 3: Algorithm for CPU Scheduling Key Goals: Maximize CPU Utilization and Throughput. Minimize Turnaround Time and Waiting Time. Algorithms (Important for Calculation): First-Come, First-Served (FCFS): Non-preemptive; executes processes in the order they arrive. Simple but can lead to the convoy effect (long processes delay shorter ones). Calculations: Turnaround Time = Completion Time - Arrival Time. Waiting Time = Turnaround Time - Burst Time. Shortest Job First (SJF): Executes the process with the shortest burst time first. Preemptive version = Shortest Remaining Time First (SRTF). Round Robin (RR): Time-sharing approach with a fixed time quantum for each process. Processes not completed in their time slice are added back to the ready queue. Priority Scheduling: Executes processes based on priority (highest priority first). Can lead to starvation, mitigated by aging (gradually increasing the priority of waiting processes). Chapter 8: Partitioning and Page Replacement Partitioning (Important): Fixed Partitioning: Divides memory into fixed-size blocks. Causes internal fragmentation (unused space within allocated blocks). Dynamic Partitioning: Allocates memory dynamically based on process size. Causes external fragmentation (scattered free spaces). Page Replacement Algorithms (Important for Calculation): FIFO (First-In, First-Out): Replaces the oldest page in memory. Belady’s Anomaly: More frames can sometimes lead to more page faults. LRU (Least Recently Used): Replaces the page least recently used. Efficient but requires tracking access history. Optimal Algorithm: Replaces the page that won’t be used for the longest time in the future. Theoretical, used for comparison. Clock Algorithm: Circular buffer approximation of LRU. Chapter 9: Disk Management Disk Scheduling Algorithms (Important for Calculation): First-Come, First-Served (FCFS): Simple but inefficient for scattered requests. Total head movement = Sum of absolute differences between adjacent requests. Shortest Seek Time First (SSTF): Services the nearest request. Reduces seek time but risks starvation for far-off requests. SCAN (Elevator Algorithm): Head moves in one direction, servicing requests, then reverses. Fairer for heavy disk loads. C-SCAN (Circular SCAN): Like SCAN but resets to the start after reaching the end. Ensures uniform wait time. LOOK and C-LOOK: Variants of SCAN and C-SCAN, stopping at the last request instead of going to the disk edge. Disk Metrics: Seek Time: Time to position the head over the correct track. Rotational Latency: Time for the desired sector to rotate under the head. Transfer Time: Time to read/write data. Read more