In computing, the operating system (OS) acts as a vital link between hardware and software. It manages processes, which are programs in execution. e.g., A large game like GTA, despite its size of 50-60 GB, can run smoothly on a computer with just 16 GB of RAM due to efficient resource allocation by the OS. Each process is represented by a Program Control Block (PCB) that includes details such as memory allocation.
Processes can communicate via Inter-Process Communication (IPC), and within a process, multiple threads execute tasks independently, enhancing program speed. Threads share memory, making communication easier compared to separate processes that require more overhead.
Processes transition through states: creation, ready, running (where they actively use the CPU), and waiting (for events like user input).
Multiprocessing allows simultaneous execution of multiple tasks, utilizing modern CPUs effectively.
The OS’s role is critical in managing processes, threads, and resources for efficient computing across various devices and systems.
First Come First Serve (FCFS): Processes are scheduled in the order they request the CPU. The first process that arrives is allocated the CPU first, and subsequent processes wait in a queue. e.g., At a grocery store checkout, the first customer in line is served first.
Shortest Job Next (SJN): Also known as Shortest Process Next or Shortest Job First (SJF), this algorithm schedules processes based on their burst time (execution time). The process with the shortest burst time is executed first, minimizing average waiting time. e.g., In a barber shop, a quick trim is done before a full hair dye job.
Round Robin (RR): Each process is assigned a fixed time slice or quantum. The CPU scheduler cyclically assigns the CPU to processes in a round-robin fashion. If a process doesn't complete within its time quantum, it is preempted and put back in the queue. e.g., Friends playing a board game take turns rolling the dice in equal intervals.
Priority Scheduling: Processes are scheduled based on priority levels assigned to them. The CPU is allocated to the highest priority process first. Preemptive priority scheduling allows higher priority processes to preempt lower priority ones currently executing. e.g., In an emergency room, a critical injury is treated before a minor ailment.
Multi-Level Queue Scheduling: Processes are divided into different queues with different priorities. Each queue may have its own scheduling algorithm (e.g., RR for high-priority queue, FCFS for low-priority queue). In multi-level queue scheduling, processes are classified into distinct queues based on priority or characteristics, each utilizing a specific scheduling algorithm tailored to its requirements. e.g., A high-priority queue (P1) might employ Round Robin scheduling to ensure critical tasks receive frequent CPU time, whereas a medium-priority queue (P2) could use a similar algorithm but with longer time slices to balance responsiveness and efficiency for less critical processes. e.g., A school has different schedules for different grades, with younger students having shorter classes.
Process synchronization is essential in concurrent programming to manage shared resources effectively and prevent data inconsistency issues such as race conditions. Key mechanisms include:
Critical Section: A segment of code that only one process can execute at a time, typically protected by mutual exclusion mechanisms like locks or semaphores. e.g., Only one person can use a single bathroom in a house at a time.
Process Entry: Ensures that processes require mutual agreement or a certain condition before entering a critical section, ensuring fairness and synchronization. e.g., A club bouncer only lets in people on the guest list.
Bounded Waiting: Limits the amount of time a process can wait to enter a critical section to prevent indefinite delays and maintain system responsiveness. e.g., A theme park ride ensures each person in line gets a turn within a certain time.
To implement these mechanisms:
Locks: Basic synchronization primitives that ensure exclusive access to a resource by allowing only one process to hold a lock at a time. e.g., Only the person with the key can access a locker in a locker room.
Semaphores: Used to control access to shared resources, with binary semaphores (mutex) for mutual exclusion and counting semaphores to manage a specified number of concurrent accesses. e.g., A parking lot with limited spaces only allows a certain number of cars to enter.
Read/Write Locks: Allow multiple processes to read a resource simultaneously while restricting write access to one process at a time, ensuring data consistency. e.g., Multiple people can read a library book simultaneously, but only one can check it out.
The critical section problem arises when multiple processes attempt to access shared resources simultaneously without proper synchronization. This can lead to inconsistent data states or program failures. Effective synchronization mechanisms ensure that only one process accesses the critical section at a time, preventing such issues.
Deadlocking is a critical issue in concurrent computing where processes become stuck in a state where each is waiting for a resource held by another, resulting in none of the processes being able to proceed. e.g., Cars stuck at an intersection, each waiting for another to move, causing a standstill.
Conditions necessary for deadlock are:
Mutual Exclusion: Resources that processes are competing for cannot be simultaneously shared. Each resource can only be held by one process at a time.
Hold and Wait: Processes hold resources already allocated to them while waiting for additional resources held by other processes. This can lead to resource utilization inefficiencies.
No Preemption: Resources cannot be forcibly taken away from a process; they can only be released voluntarily.
Circular Wait: A set of processes must exist such that each process holds at least one resource and is waiting to acquire additional resources held by other processes in a circular chain.
Deadlock handling strategies include:
Detection: Periodically check for the presence of deadlocks. If detected, strategies can be employed to resolve them.
Avoidance: Use resource allocation algorithms that ensure the system will never enter a deadlock state, typically by ensuring that the system remains in a safe state by using algorithms like the Banker's algorithm.
Recovery: Break the deadlock by preemptively aborting processes or preemptively releasing resources to resolve the deadlock state.
Ignorance: Some systems choose to ignore the problem altogether, relying on timeouts or system crashes to resolve deadlock situations.
In real-time operating systems (RTOS) and critical systems like those used by NASA, deadlock handling is crucial due to the need for continuous and predictable operation. In contrast, general-purpose operating systems like Windows often rely on deadlock ignorance, allowing the system to crash and restart when a deadlock occurs, rather than implementing more complex detection and recovery mechanisms.
Memory management in operating systems involves the efficient allocation and utilization of RAM (Random Access Memory), which is controlled by the OS rather than the hard disk.
Fixed Partitioning: In this scheme, memory is divided into fixed-size partitions. Each partition is allocated to a process, and if a partition is not large enough to accommodate a process, it remains unused even if there is sufficient total memory available. e.g., A parking lot with fixed-size spaces may leave some spaces unused if cars don't fit.
Dynamic Partitioning: Memory is divided into variable-sized partitions to accommodate processes as needed. Unused memory between allocated partitions (internal fragmentation) can limit efficiency. Allocation strategies include:
First Fit: Allocates the first available partition that is large enough to accommodate a process.
Best Fit: Finds the smallest partition that can accommodate a process, minimizing internal fragmentation.
Worst Fit: Allocates the largest available partition, potentially leaving large unused spaces (external fragmentation).
Paging: Main memory is divided into fixed-size blocks called pages. Processes are also divided into fixed-size blocks called pages, which do not need to be contiguous in memory. The Memory Management Unit (MMU) maps virtual addresses to physical addresses using a page table, allowing efficient use of physical memory. e.g., A bookshelf with fixed-size slots holds different parts of various books.
Virtual Memory: Allows the execution of processes larger than main memory by using disk space as an extension of RAM. Only active portions of a process and data are loaded into physical memory, while the rest remains on disk. This allows for efficient multitasking and enables the use of applications requiring more memory than is physically available. e.g., A library keeps frequently accessed books on shelves and stores the rest in the back.
Virtual memory management is crucial for modern operating systems to handle large and diverse workloads efficiently, ensuring optimal performance and resource utilization without needing all data and programs to reside in physical RAM simultaneously.
Page Replacement Algorithms:
Page replacement algorithms are used in operating systems to decide which pages to replace when a new page needs to be brought into memory and there are no free frames available. This decision is crucial as it directly impacts the efficiency and performance of memory management.
First In, First Out (FIFO): Pages are replaced in the order they were brought into memory. It is simple to implement using a queue data structure where the oldest page (first page brought in) is replaced. e.g., The oldest plate in a stack is used first.
Optimal Page Replacement: Replaces the page that will not be used for the longest period of time . It is an optimal strategy but is often impractical to implement since future page accesses are not known beforehand. e.g., A librarian keeps books that will be needed soon on the shelves.
Least Recently Used (LRU): Pages that have not been used for the longest time are replaced. It requires tracking when each page was last accessed, either through hardware counters or software implementations using timestamps. e.g., The least recently used items in a fridge are thrown out first.
Thrashing:
Thrashing occurs when a system spends more time swapping pages in and out of memory than executing actual computational tasks. This happens when the system is over-committed with more processes than the available physical memory can accommodate. To mitigate thrashing:
Increase the amount of physical RAM.
Reduce the number of processes running concurrently (reduce multiprogramming). e.g., A student keeps switching textbooks without reading, wasting time.
Segmentation:
Segmentation is a memory management technique where memory is divided logically into segments that correspond to different parts of a program (e.g., code, data, stack). Each segment can grow or shrink dynamically based on the needs of the program. Unlike paging, segments can have variable sizes. e.g., A book divided into chapters, each growing or shrinking independently.
Secondary Memory:
Secondary memory, such as hard disks and SSDs, is used for long-term storage of data and programs that are not currently in use by the CPU.
Disk Management:
Seek Time: The time taken by the disk arm to move the read/write heads to a specific track on the disk. e.g., A librarian moves to the correct aisle to find a book.
Rotational Latency: The time taken for the disk to rotate and position the desired sector under the read/write heads. e.g., Waiting for a rotating carousel to bring the desired item around.
SSDs vs. HDDs:
SSDs (Solid State Drives) are faster than traditional HDDs (Hard Disk Drives) because they have no moving parts and use flash memory, resulting in faster data access times and lower latency. e.g., SSDs are like flash drives (fast, no moving parts), while HDDs are like record players (slower, with moving parts).
Understanding these memory and disk management concepts is crucial for optimizing system performance and ensuring efficient utilization of resources in modern computing environments.