Definition:
Software that manages computer hardware and software resources and provides common services for applications.
Types:
-
📦 Batch OS:
Processes batches of jobs without interaction. -
⏰ Time-Sharing OS:
Allows multiple users to interact with programs simultaneously. -
🌐 Distributed OS:
Manages a group of separate computers and makes them act as one system.
-
🔧 Resource Management:
Allocates CPU, memory, and I/O devices to processes. -
⚙️ Task Management:
Manages tasks like process scheduling, multitasking, and resource sharing. -
🖱️ User Interface:
Provides a user-friendly way to interact with the system (GUI or command-line).
Definition:
An OS designed for real-time applications where responses are needed within a specific time.
-
🔹 Program:
A set of instructions designed to complete a specific task. It is a passive entity residing in secondary memory. -
🔸 Process:
An active entity created during execution, loaded into main memory. It exists for a limited time, terminating after task completion. -
🧵 Thread:
A single sequence of execution within a process, often called a lightweight process. Threads improve application performance through parallelism.
Key Points:
- Processes are isolated and considered heavyweight, requiring OS intervention for switching.
- Threads share memory within the same process and are lightweight, allowing efficient communication.
-
📝 Process Control Block (PCB):
Tracks the execution status of a process, containing information like registers, priority, and execution state. -
🔌 Socket:
An endpoint for sending/receiving data over a network. -
🖥️ Shell:
Interface to access OS services, either via command-line or GUI. -
🧠 Kernel:
The core component of an OS, managing memory, CPU time, and hardware operations. Acts as a bridge between applications and hardware.
Monolithic Kernel:
- 💪 Monolithic Kernel:
Manages system resources and implements user and kernel services in the same address space, making OS execution faster but increasing its size.
- 🔀 Multiple threads are executed simultaneously within the same or different parts of a program.
- 💨 Lightweight process, involving parts of a single process.
- 🔄 CPU switches between multiple threads.
- 🔗 Shares computing resources among threads of a single process.
- 🔀 Several programs (or tasks) are executed concurrently.
- 💪 Heavyweight process, involving multiple processes.
- 🔄 CPU switches between multiple tasks or processes.
- 🔗 Shares computing resources (CPU, memory, devices) among multiple processes.
- 🔢 Performs multiple tasks using a single processor.
- 🧮 Has only one CPU.
- 💰 More economical.
- ⚡ Allows fast switching between tasks.
- 🔢 Performs multiple tasks using multiple processors.
- 🧮 Has more than one CPU.
- 💸 Less economical.
- ⚡ Allows smooth simultaneous task processing.
Different states that a process goes through include:
-
🆕 New State:
The process is just created. -
🏃 Running:
The CPU is actively executing the process's instructions. -
⏳ Waiting:
The process is paused, waiting for an event to occur. -
✅ Ready:
The process has all necessary resources and is waiting for CPU assignment. -
🛑 Terminate:
The process has completed execution and is finished.
-
🚀 Ready Queue:
Holds processes that are ready for CPU time. -
🕒 Waiting Queue:
Holds processes that are waiting for I/O operations.
-
🎯 Purpose:
Allows processes to communicate and share data. -
🛠️ Techniques:
Includes pipes, message queues, shared memory, and semaphores.
-
📖 Definition:
Linking a function or variable at runtime rather than at compile-time. -
✅ Advantage:
Flexibility in program behavior and memory use.
-
📖 Definition:
Moving processes between main memory and disk storage. -
🎯 Purpose:
Frees up memory for active processes, improving system performance.
-
📖 Definition:
Involves saving the state of a currently running process and loading the saved state of a new process. The process state is stored in the Process Control Block (PCB), allowing the old process to resume from where it left off. -
⚖️ Overhead:
Increases CPU load but allows multitasking.
-
🧟♂️ Zombie Process:
A terminated process still occupying memory until the parent acknowledges it. -
🍼 Orphan Process:
A child process without a parent, often adopted by the init system in Unix-based OS.
-
📖 Definition:
A method of storing data across multiple disks for redundancy or performance. -
🔢 Types:
Includes RAID 0 (striping), RAID 1 (mirroring), RAID 5 (striping with parity), etc.
-
🌑 Starvation:
When a process does not get the resources it needs for a long time because other processes are prioritized. -
⏳ Aging:
Gradually increases priority of waiting processes to prevent starvation.
-
🎯 Purpose:
Determines the order in which processes access the CPU. -
🔢 Types:
Includes FCFS (First-Come, First-Serve), Round Robin, Priority Scheduling, etc.
- ⚡ OS can interrupt and reassign CPU from a running process.
- Once a process starts, it runs until completion or voluntary release of CPU.
-
🏁 FCFS (First-Come, First-Serve):
Schedules jobs in the order they arrive in the ready queue. It is non-preemptive, meaning a process holds the CPU until it terminates or performs I/O, causing longer jobs to delay shorter ones. -
🚗 Convoy Effect:
Occurs in FCFS when a long process delays others behind it.
-
📖 Definition:
Schedules processes in a time slice or quantum, rotating through processes to ensure fair allocation of CPU time and preventing starvation. It is cyclic and does not prioritize any process. -
✅ Advantage:
Fair and efficient for time-sharing systems.
-
📖 Definition:
Processes are assigned CPU based on priority levels. -
⚠️ Challenge:
Risk of starvation for lower-priority processes.
-
📖 Definition:
Multiple processes appear to run simultaneously. -
🚀 Achieved By:
Multithreading or multitasking within a single CPU.
-
📖 Definition:
Two processes access shared data simultaneously, leading to unexpected results. -
🛡️ Solution:
Use locks or synchronization mechanisms.
- 📖 Definition:
A part of code that accesses shared resources and must not be executed by more than one process at a time.
-
🔐 Mutexes:
Only allows one process at a time, preventing concurrent access. -
📍 Condition Variables:
A variable used to control access in multithreading, allowing threads to wait until certain conditions are met. -
🔗 Semaphores:
Allows multiple processes to access resources up to a limit. -
📂 File Locks:
Restricts access to files to prevent conflicts.
- 📖 Definition:
A Semaphore is a synchronization tool used in operating systems to manage access to shared resources in multi-threaded or multi-process systems. It keeps a count of available resources and uses two atomic operations, wait() and signal(), to control access.
-
🔘 Binary Semaphore:
- Has values 0 or 1.
- Signals availability of a single resource.
-
🔢 Counting Semaphore:
- Can have values greater than 1.
- Controls access to multiple instances of a resource, like a pool of connections.
-
🔘 Binary Semaphore:
- Signals availability of a shared resource (0 or 1).
- Uses signaling mechanisms.
- Faster in some cases with multiple processes.
- Integer variable holding 0 or 1.
-
🔒 Mutex:
- Allows mutual exclusion with a single lock.
- Uses a locking mechanism.
- Slower when frequently contended.
- Object holding lock state and lock owner info.
- 🔢 Only two values: 0 or 1, similar to a lock.
- 🔒 Usage: Signals availability of a single resource.
- ⚡ Efficiency: Faster in scenarios with multiple processes.
- 🔄 Mechanism: Uses signaling mechanisms.
- 🔢 Range of values: Allows values greater than 1.
- 🔄 Flexibility: Manages multiple resources effectively.
- ⚙️ Usage: Controls access to multiple instances of a resource, like a pool of connections.
- 🔗 Mechanism: Uses counting to manage resource allocation.
-
📖 Definition:
A synchronization issue where producer and consumer processes access shared data. -
🔧 Solution:
Use semaphores or mutexes to control access and prevent race conditions.
-
📖 Definition:
An increase in page faults despite increasing memory pages in certain page replacement algorithms. -
🔍 Occurs In:
FIFO (First-In, First-Out) page replacement algorithm.
-
📖 Definition:
A deadlock is a situation where a set of processes are blocked because each process holds resources and waits to acquire additional resources held by another process. -
🔄 Scenario:
Two or more processes are unable to proceed because they are waiting for each other to release resources. -
⚠️ Common Occurrence:
In multiprocessing environments, leading to the system becoming unresponsive.
-
🔒 Mutual Exclusion:
Resources cannot be shared; at least one resource must be held in a non-shareable mode. -
🤝 Hold and Wait:
Processes holding resources are allowed to wait for additional resources. -
✋ No Pre-emption:
Resources cannot be forcibly taken from a process; they must be voluntarily released. -
🔄 Circular Wait:
A set of processes exists such that each process is waiting for a resource held by the next process in the cycle.
-
🎯 Purpose:
A deadlock avoidance algorithm used in resource allocation. -
🛠️ Method:
Checks if resources can be safely allocated without causing a deadlock by ensuring the system remains in a safe state.
- 🔒 Ensure at least one necessary condition for deadlock cannot hold.
- 🤝 Mutual Exclusion: Allow resource sharing where possible.
- ✋ Hold and Wait: Require all resources to be requested upfront.
- ✋ No Pre-emption: Permit resource preemption.
- 🔄 Circular Wait: Impose a strict order for resource allocation.
- 🔍 Dynamically examine resource allocation to prevent circular wait.
- 🎲 Use the Banker’s Algorithm to determine safe states; deny requests that would lead to an unsafe state.
- 🔍 Allow the system to enter a deadlock state, then detect it.
- 📈 Use a Wait-for Graph to represent wait-for relationships; a cycle indicates a deadlock.
- 🔗 Employ a Resource Allocation Graph to check for cycles and determine the presence of deadlock.
- 🛑 Terminate one or more processes involved in the deadlock (abruptly or gracefully).
- 🔄 Use resource preemption to take resources from processes and allocate them to others to break the deadlock.
| Parameter | Logical Address | Physical Address |
|---|---|---|
| 🔍 Basic | Generated by the CPU. | Located in a memory unit. |
| 📦 Address Space | Set of all logical addresses generated by the CPU. | Set of all physical addresses corresponding to logical addresses. |
| 👀 Visibility | Visible to the user. | Not visible to the user. |
| ⚙️ Generation | Created by the CPU. | Computed by the Memory Management Unit (MMU). |
- 📖 Definition:
Hardware that translates logical addresses to physical addresses.
-
💾 Usage:
Used for temporary data storage while the computer is running. -
⚡ Access Speed:
Faster as it is directly accessible by the CPU. -
💨 Nature:
Volatile; data is lost when power is turned off. -
💰 Cost:
More expensive due to the use of semiconductor technology. -
📊 Capacity:
Ranges from 16 to 32 GB, suitable for active tasks. -
🔍 Examples:
RAM, ROM, and Cache memory.
-
💾 Usage:
Used for permanent data storage, retaining information long-term. -
⚡ Access Speed:
Slower; not directly accessible by the CPU. -
💨 Nature:
Non-volatile; retains data even when power is off. -
💰 Cost:
Less expensive, often using magnetic or optical technology. -
📊 Capacity:
Can range from 200 GB to several terabytes for extensive storage. -
🔍 Examples:
Hard Disk Drives, Floppy Disks, and Magnetic Tapes.
-
📖 Definition:
Small, fast memory located close to the CPU for quick access to frequently used data. -
⚡ Caching:
Involves using a smaller, faster memory to store copies of data from frequently used main memory locations. Various independent caches within a CPU store instructions and data, reducing the average time needed to access data from the main memory.
-
🔒 Fixed Location:
Each block has a fixed cache location. -
⚡ Simplicity:
Simpler and faster due to the fixed placement.
-
🔄 Flexible Location:
Any block can be placed into any cache line, providing more flexibility. -
⚙️ Efficiency:
Better cache utilization but more complex to implement.
- 🔹 Definition:
Occurs when allocated memory blocks are larger than required by a process, leading to wasted space within the allocated memory. - 🔒 Characteristics:
- Fixed-sized memory blocks are allocated to processes.
- Difference between allocated and required memory is wasted.
- Arises when memory is divided into fixed-sized partitions.
- 🔧 Solution:
Best-fit block allocation to minimize wasted space.
- 🔹 Definition:
Happens when free memory is scattered in small, unusable fragments, preventing the allocation of large contiguous memory blocks. - 🔒 Characteristics:
- Variable-sized memory blocks are allocated to processes.
- Unused spaces between allocated blocks are too small for new processes.
- Arises when memory is divided into variable-sized partitions.
- 🔧 Solution:
Compaction, paging, and segmentation to reorganize memory and reduce fragmentation.
-
📖 Definition:
The process of rearranging memory to reduce fragmentation. -
🛠️ Compaction:
Collects fragments of available memory into contiguous blocks by moving programs and data in a computer's memory or disk, thereby optimizing memory usage.
-
📖 Definition:
Storing data temporarily for devices to access when they are ready, such as print jobs. -
🔡 Meaning:
Spooling stands for Simultaneous Peripheral Operations Online, which involves placing jobs in a buffer (either in memory or on a disk) where a device can access them when ready. -
🔧 Purpose:
Helps manage different data access rates of devices, ensuring efficient data processing.
-
📖 Definition:
Loading only the required part of a program into memory, unloading it when done, and loading a new part as needed. -
🔧 Purpose:
Efficiently manages memory usage by ensuring that only necessary parts of a program are in memory at any given time, optimizing resource allocation.
-
🗂️ Page Table:
Maps logical pages to physical frames, enabling the memory management unit (MMU) to translate addresses. -
🔲 Frame:
Fixed-size physical memory blocks where pages are loaded. -
📄 Page:
Fixed-size blocks of logical memory that are mapped to frames in physical memory.
-
📖 Definition:
A memory management technique for non-contiguous memory allocation, dividing both main and secondary memory into fixed-size partitions called pages and frames, respectively. -
🎯 Purpose:
- Avoids external fragmentation.
- Simplifies memory management by using fixed-size blocks.
-
🔄 Operation:
Fetches process pages into main memory frames as needed, ensuring efficient use of memory resources.
-
📖 Definition:
Dividing memory into segments based on logical units such as functions, objects, or data structures. -
🔍 Features:
- Segments are variable-sized, reflecting the logical structure of programs.
- Provides a more natural view of memory for programmers.
-
🔧 Purpose:
Enhances memory organization by grouping related data and code, improving access and management.
-
🔒 Invisible to the Programmer:
Memory management is handled by the OS and MMU, not directly visible in the programming model. -
🔢 Fixed-Size Pages:
Memory is divided into uniform page sizes, simplifying allocation. -
🔄 Procedures and Data:
Cannot be separated, as both are stored in fixed-size blocks. -
📈 Virtual Address Space:
Allows virtual address space to exceed physical memory, supporting virtual memory. -
⚡ Performance:
Faster memory access compared to segmentation. -
⚠️ Fragmentation:
Results in internal fragmentation due to fixed page sizes.
-
🔍 Visible to the Programmer:
Programmers work with segments that correspond to logical units in the code. -
📏 Variable-Size Segments:
Segments can be of different sizes, matching the logical structure of the program. -
🔄 Procedures and Data:
Can be separated, allowing more flexible memory organization. -
🔗 Address Spaces:
Breaks programs, data, and code into independent spaces, enhancing modularity. -
⚡ Performance:
Slower memory access compared to paging due to variable sizes. -
⚠️ Fragmentation:
Results in external fragmentation as free memory becomes scattered.
-
📖 Definition:
Occurs when a program accesses a page that is not currently in physical memory. -
🔄 Handling:
Triggers the OS to fetch the required page from secondary memory (e.g., disk) into physical memory, potentially causing a temporary pause in execution.
-
🎯 Definition:
A memory management technique in operating systems that creates the illusion of a large contiguous address space. -
🔗 Features:
- Extends physical memory using disk space.
- Allows more programs to run simultaneously.
- Stores data in pages for efficient memory use.
- Provides memory protection to ensure process isolation.
- Managed through methods like paging and segmentation.
- Acts as temporary storage alongside RAM for processes.
-
🔧 Purpose:
Enhances system performance by allowing efficient use of available memory and supporting multitasking.
-
🔄 Multiple Programs:
Allows multiple programs to run on a single processor. -
🚀 Addresses Underutilization:
Tackles underutilization of the CPU and main memory by keeping the CPU busy with multiple jobs. -
🔧 Coordination:
Coordinates the execution of several programs simultaneously. -
⚡ Continuous Execution:
Main objective is to have processes running at all times, improving CPU utilization by organizing multiple jobs for continuous execution.
-
📖 Definition:
Loads pages into memory only when they are needed, which occurs when a page fault happens. -
🔄 Operation:
- Pages are fetched from secondary memory to physical memory on demand.
- Reduces memory usage by loading only necessary pages.
-
🎯 Purpose:
Optimizes memory usage and improves system performance by avoiding loading entire processes into memory upfront.
- 🎯 Purpose:
Manage how pages are swapped in and out of physical memory when a page fault occurs.
- **🔄 Replaces the page that has not been used for the longest time.
- 📈 Keeps track of page usage over time to make informed replacement decisions.
- **🔄 Replaces the oldest page in memory.
- 🛠️ Simple to implement but can lead to suboptimal performance due to the Convoy Effect.
- **🔮 Replaces the page that will not be used for the longest period in the future.
- 🏆 Provides the best performance but is impractical to implement since future requests are unknown.
- **🔄 Replaces the page with the lowest access frequency.
- **📊 Tracks pages based on the number of accesses over time to determine replacements.
-
📖 Definition:
Excessive swapping between memory and disk, leading to significant system slowdown. -
🔄 Occurrence:
Happens when a computer spends more time handling page faults than executing transactions, resulting in degraded performance. -
⚠️ Cause:
High page fault rate due to insufficient physical memory, causing frequent swapping. -
🔧 Impact:
- Longer service times.
- Reduced system efficiency.
- Potential system unresponsiveness.
- Fragmentation is a critical concept in memory management, with internal and external fragmentation requiring different solutions like best-fit allocation, compaction, and paging.
- Defragmentation and compaction are essential for optimizing memory usage, ensuring that memory is used efficiently.
- Spooling and overlays enhance resource management by buffering data and loading only necessary program parts.
- Understanding paging, segmentation, and their differences is vital for effective memory management and system performance.
- Virtual memory and demand paging enable efficient use of physical memory, supporting multitasking and large applications.
- Page replacement algorithms like LRU, FIFO, Optimal, and LFU are crucial for maintaining system performance by managing memory efficiently.
- Thrashing is a severe issue that occurs due to high page fault rates, emphasizing the importance of adequate memory management.
- Multiprogramming aims to maximize CPU utilization by running multiple programs simultaneously, addressing resource underutilization.