Preemptive & Non-Preemptive Scheduling

Scheduling can be **preemptive** or **non-preemptive**. In **preemptive scheduling**, the OS can suspend a running process to give CPU time to another (e.g., Round Robin). In **non-preemptive scheduling**, once a process starts, it runs until it finishes or switches voluntarily (e.g., FCFS, SJF). Choosing the right approach balances fairness and response time.

Multiple-Processor Scheduling

Modern systems often have multiple processors or cores. **Multiple-processor scheduling** ensures processes are distributed efficiently across CPUs. Two models: • **Asymmetric multiprocessing** — one processor controls the system, others follow. • **Symmetric multiprocessing (SMP)** — all processors share the load equally. Good scheduling improves performance and resource usage.

Thread Scheduling

Threads need scheduling too! The OS can manage user-level or kernel-level threads. Threads can be **cooperatively** or **preemptively** scheduled. Efficient thread scheduling is key for web servers, real-time apps, and multi-core performance.

Introduction to Deadlock

A **deadlock** happens when processes block each other forever, waiting for resources. For example, two processes each hold one resource and wait for the other — stuck forever! Understanding deadlocks is vital for OS design.

Banker's Algorithm

The **Banker's Algorithm** checks if allocating resources will keep the system in a safe state. It "pretends" to allocate requested resources and checks if all processes can finish. If yes → safe; if no → the request is denied. This prevents deadlocks proactively.

Wait For Graph in Deadlock Detection

In **distributed systems**, a **Wait-For Graph** shows which processes are waiting for which resources. A cycle in the graph → deadlock! Detecting cycles helps the OS find and resolve deadlocks in multi-node systems.

Deadlock Prevention & Avoidance

• **Prevention**: Design the system so that at least one of the 4 deadlock conditions never holds (e.g., by ordering resources). • **Avoidance**: Dynamically check requests (like Banker's Algorithm) to avoid unsafe states.

Deadlock Detection & Recovery

If prevention isn’t possible, the OS can detect deadlocks and recover. Detection: periodically check resource allocation graphs for cycles. Recovery: terminate one or more processes, or preempt resources to break the deadlock.

Deadlock Ignorance

Some systems (like UNIX) simply ignore deadlocks — assuming they’re rare. They rely on rebooting or manual intervention if needed.

Memory Management

Memory Management controls how RAM is allocated and used. It ensures processes have enough memory, prevents conflicts, and optimizes performance with techniques like paging and segmentation.

Fixed (Static) Partitioning

In fixed partitioning, RAM is divided into fixed-size blocks. Processes fit into these blocks. It’s simple but can waste memory (internal fragmentation) if a process doesn’t fully use its block.

Variable (Dynamic) Partitioning

Unlike fixed partitioning, dynamic partitioning allocates RAM blocks sized to fit the process exactly. It reduces waste but can lead to external fragmentation (free space scattered in small chunks).

Paging

**Paging** breaks memory into fixed-size pages and divides processes into same-sized page frames. Pages are loaded into any available frames, avoiding external fragmentation. The OS maintains a page table to map logical to physical addresses.

Segmentation

Segmentation divides processes into logical segments (code, data, stack) of variable lengths. Unlike paging, segments match program structure. Segmentation can suffer from external fragmentation, so some OS combine paging + segmentation.

Page Replacement Algorithms

When RAM is full, the OS replaces pages using algorithms like: • FIFO (First In, First Out) • LRU (Least Recently Used) • Optimal Replacement These help balance performance when multitasking.

File Systems

The OS’s file system organizes how data is stored and accessed. It handles file naming, directories, permissions, storage allocation, and recovery. Common file systems: FAT32, NTFS, ext4.

Multithreading

Multithreading lets multiple threads run within a single process. This improves resource sharing and responsiveness (like in browsers that load tabs in parallel).

Compaction

To solve external fragmentation, OS can use **compaction** — it rearranges memory so free spaces combine into larger blocks.

Belady's Anomaly

Belady’s Anomaly is when adding more frames (RAM) leads to *more* page faults in FIFO paging. Some algorithms like LRU don’t suffer from this.

Techniques to Handle Thrashing

**Thrashing** happens when the OS spends more time swapping pages than running processes. To reduce thrashing: • Use good replacement algorithms (LRU) • Increase RAM • Reduce degree of multiprogramming

Free Space Management

The OS tracks free disk space using: • Bitmaps (each block is a bit) • Linked lists (free blocks linked together) • Grouping or counting methods Good management reduces wasted space and speeds up file access.

RAID (Redundant Array of Independent Disks)

RAID combines multiple disks to improve performance and reliability. Popular RAID levels: • RAID 0 — striping, fast but no redundancy. • RAID 1 — mirroring for data safety. • RAID 5 — striping with parity for balanced performance & fault tolerance.