UNIT=1
Explain Process States (7 Marks – GTU Style)
A process is a program that is currently running in the computer. During execution, a process changes from one state to another. These states are called process states. The operating system keeps track of each process and manages its movement between states.
Process states help the operating system in CPU scheduling, resource allocation, and multitasking.
Diagram of Process States:
New
|
v
Ready
|
v
Running
/ \
v v
Waiting Terminated
|
v
Ready
Different Process States
1. New State
This is the first state of a process.
In this state, the process is being created.
The operating system allocates memory and other resources.
The process is not ready for execution yet.
Example: When we click on an application icon, the process is created.
2. Ready State
In this state, the process is ready to run.
It waits for CPU allocation.
The process stays in the ready queue.
Multiple processes can be in ready state.
Example: If many programs are open, they wait in ready state.
3. Running State
In this state, the process is executing on the CPU.
Only one process can run at one time in a single processor system.
The process performs its task.
Example: While typing in a text editor.
4. Waiting (Blocked) State
Sometimes a process needs input/output operations.
During this time, it cannot use CPU.
So it moves to waiting state.
It waits until the event is completed.
Example: Waiting for data from disk.
5. Terminated State
When the process finishes its work, it enters this state.
The operating system removes it from memory.
Resources used by the process are released.
Example: Closing an application after use.
State Transitions
New → Ready
The process is admitted into the ready queue.
Ready → Running
CPU is assigned by the scheduler.
Running → Waiting
The process requests I/O operation.
Waiting → Ready
After I/O completion, the process becomes ready again.
Running → Ready
If CPU time is over, the process goes back to ready state.
Running → Terminated
When execution is completed.
Importance of Process States
Helps in proper CPU management.
Improves system performance.
Supports multitasking.
Makes scheduling easier.
Conclusion
Process states are important in operating systems because they show the life cycle of a process. The operating system uses these states to control process execution and utilize CPU efficiently.
Explain Thread and its States (7 Marks – GTU Style)
A thread is the smallest unit of execution inside a process. It is also called a lightweight process. A process can have one or more threads. Threads share the same memory and resources of the process.
For example, in a browser, one thread can download data while another thread displays the page.
Threads make program execution faster and improve CPU utilization.
Definition of Thread
A thread is a sequence of instructions that can run independently within a process.
A process contains:
Program code
Data section
Files
Resources
A thread contains:
Thread ID
Program counter
Register set
Stack
Advantages of Thread
1. Fast Execution
Threads run tasks simultaneously, so execution becomes faster.
2. Resource Sharing
Threads share memory and resources of the same process.
3. Better CPU Utilization
CPU remains busy by executing multiple threads.
4. Easy Communication
Communication between threads is easier than between processes.
States of a Thread
A thread also passes through different states during execution.
Diagram of Thread States:
New
|
v
Ready
|
v
Running
/ \
v v
Blocked Terminated
|
v
Ready
1. New State
The thread is created in this state.
It is not yet ready for execution.
Example: Creating a new thread in a program.
2. Ready State
The thread is ready to run.
It waits for CPU allocation.
Example: Thread waiting in queue.
3. Running State
The thread is currently executing on CPU.
It performs its assigned task.
Example: Downloading a file.
4. Blocked (Waiting) State
The thread waits for some event like I/O completion.
It cannot execute during this state.
Example: Waiting for user input.
5. Terminated State
The thread completes its task.
It is removed from the system.
Example: File download finished.
Difference Between Process and Thread
| Process | Thread |
|---|---|
| Process is heavy weight. | Thread is light weight. |
| It has separate memory. | It shares process memory. |
| Creation takes more time. | Creation takes less time. |
| Communication is slower. | Communication is faster. |
Conclusion
A thread is an important part of modern operating systems. It improves performance by dividing work into smaller tasks. Thread states help the operating system manage thread execution efficiently.
Compare FCFS, SJF and RR Scheduling (7 Marks – GTU Style)
CPU scheduling is the process of selecting which process will get the CPU for execution. Different scheduling algorithms are used to improve CPU utilization and reduce waiting time. The three important scheduling algorithms are FCFS, SJF, and RR.
1. FCFS (First Come First Serve)
In this scheduling, the process that arrives first gets the CPU first. It works like a queue.
Features:
Simple and easy to implement.
It follows FIFO (First In First Out).
It is a non-preemptive scheduling algorithm.
Once CPU is assigned, the process runs until completion.
Advantages:
Easy to understand.
No starvation problem.
Disadvantages:
Average waiting time is high.
Short processes may wait for a long time.
2. SJF (Shortest Job First)
In this scheduling, the process with the smallest burst time is executed first.
Features:
It gives minimum average waiting time.
It can be preemptive or non-preemptive.
Burst time must be known before execution.
Advantages:
Best performance in terms of waiting time.
Better CPU utilization.
Disadvantages:
Difficult to know exact burst time.
Long processes may suffer starvation.
3. RR (Round Robin)
In this scheduling, each process gets CPU for a fixed time called time quantum.
Features:
It is a preemptive scheduling algorithm.
After time quantum ends, the process goes back to ready queue.
Each process gets equal chance.
Advantages:
Good for time-sharing systems.
Fair CPU allocation.
Better response time.
Disadvantages:
Performance depends on time quantum.
Too small quantum increases overhead.
Comparison Table
| Basis | FCFS | SJF | RR |
|---|---|---|---|
| Meaning | FCFS executes the process in the order of arrival. | SJF executes the process with the shortest burst time first. | RR executes each process for a fixed time quantum. |
| Nature | FCFS is a non-preemptive scheduling algorithm. | SJF can be preemptive or non-preemptive. | RR is a preemptive scheduling algorithm. |
| Process Selection | In FCFS, the first arrived process gets CPU first. | In SJF, the shortest job gets CPU first. | In RR, all processes get CPU one by one. |
| Waiting Time | FCFS usually gives high waiting time. | SJF gives minimum waiting time. | RR gives average waiting time. |
| Response Time | FCFS has slower response time. | SJF has better response time than FCFS. | RR has fast response time because every process gets CPU quickly. |
| Starvation | FCFS does not cause starvation. | SJF may cause starvation for long jobs. | RR does not cause starvation because all processes get equal chance. |
| Complexity | FCFS is simple and easy to implement. | SJF is more difficult because burst time must be known. | RR is easy but needs time quantum management. |
| Fairness | FCFS is fair according to arrival order. | SJF is not fully fair because short jobs get priority. | RR is fair because each process gets equal CPU time. |
| Performance | FCFS gives lower performance in many cases. | SJF gives better performance and high CPU utilization. | RR gives good performance in time-sharing systems. |
| Suitable For | FCFS is suitable for batch processing systems. | SJF is suitable for short jobs. | RR is suitable for interactive and time-sharing systems. |
Example
Suppose three processes:
| Process | Burst Time |
|---|---|
| P1 | 8 ms |
| P2 | 4 ms |
| P3 | 2 ms |
FCFS: P1 → P2 → P3
SJF: P3 → P2 → P1
RR (Time quantum = 2 ms): P1 → P2 → P3 → P1 → P2 → P1 ...
This shows how execution order changes.
Conclusion
FCFS is simple but less efficient.
SJF gives the best average waiting time but may cause starvation.
RR is most suitable for multitasking and time-sharing systems because it gives equal chance to every process.
------------------------------------------------------------------------------------------------------------------------
UNIT=4
Explain LRU Page Replacement (7 Marks – GTU Style)
LRU (Least Recently Used) Page Replacement is an important page replacement algorithm used in operating systems. It removes the page that has not been used for the longest time when a new page needs to be loaded into memory.
The main idea of LRU is that pages used recently are likely to be used again soon, so they should remain in memory.
LRU is more efficient than FIFO because it uses the history of page usage.
Definition
LRU page replacement is a technique in which the page that was least recently accessed is replaced first when memory is full.
It helps in reducing page faults and improving memory performance.
Working of LRU
The working of LRU is as follows:
1. Check whether the page is present in memory
If the page is found, it is called a Page Hit.
The page becomes the most recently used.
2. If the page is not present
A Page Fault occurs.
3. If there is an empty frame
The page is loaded into the empty frame.
4. If all frames are full
The operating system checks which page was used least recently.
5. Replace the least recently used page
That old page is removed.
The new page is inserted.
6. Continue execution
The process continues after page replacement.
Diagram of LRU
Reference Page Arrives
|
v
Page Present?
/ \
Yes No
| |
Hit Page Fault
| |
Update Empty Frame?
Usage / \
Yes No
| |
Load Page Replace LRU Page
Example (VDU Table)
Reference String: 7, 0, 1, 2, 0, 3, 0, 4
Number of Frames = 3
| Page Reference | Frame 1 | Frame 2 | Frame 3 | Status |
|---|---|---|---|---|
| 7 | 7 | - | - | Fault |
| 0 | 7 | 0 | - | Fault |
| 1 | 7 | 0 | 1 | Fault |
| 2 | 2 | 0 | 1 | Fault (7 removed) |
| 0 | 2 | 0 | 1 | Hit |
| 3 | 2 | 0 | 3 | Fault (1 removed) |
| 0 | 2 | 0 | 3 | Hit |
| 4 | 4 | 0 | 3 | Fault (2 removed) |
Calculation
Total Pages = 8
Total Page Faults = 6
Total Page Hits = 2
Hit Ratio = Page Hits / Total Pages
= 2 / 8
= 0.25
Fault Ratio = Page Faults / Total Pages
= 6 / 8
= 0.75
Advantages of LRU
1. Reduces Page Faults
LRU gives fewer page faults than FIFO.
2. Better Memory Utilization
Frequently used pages stay in memory.
3. Improves Performance
System performance becomes better.
4. Uses Actual Page History
It makes better replacement decisions.
Disadvantages of LRU
1. Difficult to Implement
Tracking page usage is complex.
2. Extra Time Required
Updating recent use information takes time.
3. Extra Memory Needed
Additional data structures are required.
Difference between FIFO and LRU
| Basis | FIFO | LRU |
|---|---|---|
| Rule | FIFO removes the oldest page. | LRU removes the least recently used page. |
| Performance | FIFO gives more page faults. | LRU gives fewer page faults. |
| Complexity | FIFO is simple. | LRU is complex. |
| Efficiency | FIFO is less efficient. | LRU is more efficient. |
Conclusion
LRU page replacement is one of the best page replacement techniques in operating systems. It replaces the least recently used page, which helps reduce unnecessary page faults. Although its implementation is complex, it provides better performance and efficient memory management.
Explain First Fit, Best Fit and Worst Fit (7 Marks – GTU Style)
First Fit, Best Fit, and Worst Fit are memory allocation techniques used in operating systems for dynamic memory management.
When a process requests memory, the operating system uses these methods to allocate free memory blocks.
These methods help in efficient memory utilization.
1. First Fit
In First Fit, the operating system allocates the first free memory block that is large enough for the process.
It starts searching from the beginning of memory and stops when it finds the first suitable block.
Working:
Scan memory blocks from start.
Select the first block that fits the process size.
Allocate memory.
Example:
Free blocks: 100 KB, 500 KB, 200 KB, 300 KB, 600 KB
Process size = 212 KB
Allocation:
100 KB → Not enough
500 KB → Selected (first suitable block)
So process is allocated in 500 KB block.
Advantages:
Simple and fast.
Easy to implement.
Disadvantages:
Causes memory fragmentation.
May waste large blocks.
2. Best Fit
In Best Fit, the operating system allocates the smallest free block that is sufficient for the process.
It searches all memory blocks and selects the best matching block.
Working:
Check all free blocks.
Find the smallest suitable block.
Allocate memory.
Example:
Free blocks: 100 KB, 500 KB, 200 KB, 300 KB, 600 KB
Process size = 212 KB
Allocation:
Suitable blocks: 500, 300, 600
Smallest suitable = 300 KB
So process is allocated in 300 KB block.
Advantages:
Reduces memory wastage.
Uses memory efficiently.
Disadvantages:
Searching takes more time.
Creates many small unused blocks.
3. Worst Fit
In Worst Fit, the operating system allocates the largest available block to the process.
The idea is to leave large remaining space after allocation.
Working:
Check all free blocks.
Select the largest block.
Allocate memory.
Example:
Free blocks: 100 KB, 500 KB, 200 KB, 300 KB, 600 KB
Process size = 212 KB
Largest block = 600 KB
So process is allocated in 600 KB block.
Advantages:
Large leftover space remains.
Useful for future large processes.
Disadvantages:
Wastes large memory blocks.
Not efficient in many cases.
Comparison Table
| Basis | First Fit | Best Fit | Worst Fit |
|---|---|---|---|
| Selection | Selects first suitable block. | Selects smallest suitable block. | Selects largest suitable block. |
| Speed | It is fast. | It is slower. | It is slower. |
| Memory Usage | May waste memory. | Uses memory efficiently. | May waste large memory. |
| Fragmentation | More fragmentation occurs. | Small fragments are created. | Large fragments may remain. |
| Searching | Stops early after finding block. | Searches all blocks. | Searches all blocks. |
Conclusion
First Fit, Best Fit, and Worst Fit are important memory allocation methods.
First Fit is simple and fast.
Best Fit uses memory more efficiently.
Worst Fit keeps larger free blocks for future use.
The choice of method depends on system requirements.
-------------------------------------------------------------------------------------------------------------------------
UNIT=5
Directory Structure in Operating System (GTU Style – 7 Marks)
A directory structure is a way of organizing files and folders in an operating system. A directory is a special file that contains information about files and subdirectories. It helps users to store, manage, and access files easily.
Directory structure is important because an operating system stores a large number of files, and without proper organization it becomes difficult to manage them.
Definition
A directory structure is the hierarchical arrangement of files and directories in an operating system.
Need of Directory Structure
It organizes files properly.
It makes searching easy and fast.
It avoids confusion between files.
It provides security and protection.
It supports file sharing.
It improves file management.
Operations on Directory
The operating system performs different operations on directories for file management.
1. Create
Used to create a new directory.
Example: Creating a new folder named “Documents”.
2. Delete
Used to remove a directory.
A directory can be deleted only if it is empty (in many systems).
3. Open
Used to open a directory and access its files.
4. Close
Used to close the directory after work is completed.
5. Search
Used to find a file inside the directory.
6. Read
Used to read the contents of a directory.
7. Rename
Used to change the name of a directory.
8. Traverse
Used to move through all files and subdirectories.
Types of Directory Structure
1. Single-Level Directory Structure
In this structure, all files are stored in one single directory.
Directory
/ | | \
A B C D
Points:
Simplest directory structure.
No subdirectories are present.
All users store files in one place.
Each file name must be unique.
Suitable for small systems.
Advantages:
Easy to understand.
Easy to implement.
Fast for small number of files.
Disadvantages:
File name conflict occurs.
Difficult for large systems.
No grouping of files.
2. Two-Level Directory Structure
This structure contains one master directory and separate directories for each user.
Master Directory
/ \
User1 User2
/ | \ / | \
A B C D E F
Points:
Each user has their own directory.
Same file names are allowed for different users.
Better organization than single-level.
User files are separated.
Searching is easier.
Advantages:
Avoids file name conflicts.
Better security.
Better management.
Disadvantages:
File sharing is difficult.
Limited flexibility.
3. Tree-Structured Directory
This structure contains root directory and subdirectories in hierarchical form.
Root
/ | \
Bin Home Docs
/ \
User1 User2
Points:
Starts from root directory.
Supports multiple levels.
Files can be grouped.
Most commonly used structure.
Easy navigation.
Advantages:
Better organization.
Easy searching.
Flexible and efficient.
Disadvantages:
More complex.
Requires proper management.
4. Acyclic Graph Directory Structure
In this structure, files and directories can be shared but cycles are not allowed.
Root
/ \
Dir1 Dir2
\ /
Shared File
Points:
Supports file sharing.
Same file can appear in multiple directories.
No cycle formation.
Saves memory space.
Avoids duplication.
Advantages:
Easy sharing.
Saves storage space.
Better resource usage.
Disadvantages:
Complex structure.
Deletion problem may occur.
5. General Graph Directory Structure
This structure allows both file sharing and cycles.
A → B → C
↑ ↓
← ← ← ←
Points:
Directories can form cycles.
Maximum flexibility.
Supports advanced sharing.
Complex structure.
Needs special handling.
Advantages:
Maximum sharing.
Very flexible.
Disadvantages:
Infinite loop problem.
Difficult searching.
Hard to manage.
Conclusion
Directory structure is an important part of the operating system. It helps to organize files and perform operations like create, delete, search, and rename. Different types of directory structures are used depending on system requirements. Among them, Tree-Structured Directory is the most commonly used because it provides better organization and flexibility.
Q.Explain Boot Block with advantages and disadvantages. (GTU Style – Long Answer – 7 Marks)
A Boot Block is a special block present at the beginning of a disk. It contains a small program called the bootstrap loader which is used to start the computer system and load the operating system into main memory.
When the computer is switched ON, the system first checks hardware and then reads the boot block from the disk. The boot block then loads the operating system kernel into memory and starts execution.
It is the most important part of the booting process because without it the operating system cannot start.
Definition
A Boot Block is the first block of the storage device that stores the bootstrap program required to load the operating system.
Need of Boot Block
It starts the computer system.
It loads the operating system into memory.
It connects hardware initialization with OS loading.
It makes the booting process automatic.
It provides initial instructions to the CPU.
Working of Boot Block
The boot block works in the following steps:
1. Power ON
The computer is switched ON.
2. BIOS/UEFI Starts
BIOS or UEFI checks all hardware devices.
This checking process is called POST (Power-On Self Test).
3. Search Boot Device
BIOS searches for a bootable device such as HDD, SSD, or USB.
4. Load Boot Block
The first block of the bootable disk is loaded into memory.
5. Execute Bootstrap Loader
The bootstrap program stored in the boot block starts execution.
6. Load Operating System
The bootstrap loader loads the operating system kernel into RAM.
7. System Ready
The operating system takes control and the system becomes ready.
Diagram of Boot Block
Power ON
↓
BIOS / UEFI
↓
Search Boot Device
↓
Load Boot Block
↓
Execute Bootstrap Loader
↓
Load OS Kernel
↓
System Ready
Characteristics of Boot Block
It is located at the beginning of the disk.
It contains bootstrap code.
It is small in size.
It is necessary for system startup.
It loads the operating system.
Advantages of Boot Block
Automatic system startup
Fast loading of operating system
Easy and organized booting process
Connects BIOS with operating system
Supports different bootable devices
Necessary for system initialization
Disadvantages of Boot Block
System cannot start if corrupted
Small storage capacity
Vulnerable to boot sector viruses
Difficult recovery process
Depends completely on storage device
Security risks due to unauthorized changes
Applications of Boot Block
Hard Disk Drive (HDD)
Solid State Drive (SSD)
USB Drive
CD/DVD
Memory Card
Network Boot (PXE)
Hard Disk Drive (HDD)
Solid State Drive (SSD)
USB Drive
CD/DVD
Memory Card
Network Boot (PXE)
Explain Bad Block with Causes and Types (GTU Style – Long Answer – 7 Marks)
A Bad Block is a block or sector in a storage device that cannot be used for storing or reading data correctly. It is a defective area of the disk where data may become corrupted or inaccessible.
In operating systems, storage devices such as hard disks, SSDs, USB drives, and memory cards are divided into many small blocks. These blocks are used to store data. If any block becomes damaged or corrupted, it is called a Bad Block.
Bad blocks can affect system performance and may lead to loss of important data. Therefore, the operating system detects such blocks and marks them so they are not used again.
Definition
A Bad Block is a damaged or corrupted block in secondary storage that cannot perform read or write operations properly.
Need of Bad Block Management
Bad block management is necessary because:
It prevents data loss.
It improves storage reliability.
It avoids using damaged blocks.
It protects important files.
It improves disk performance.
Causes of Bad Block
There are many causes of bad blocks:
1. Physical Damage
Damage to the disk surface due to scratches or shock can create bad blocks.
2. Sudden Power Failure
If power fails during writing, the block may become corrupted.
3. Improper Shutdown
Force shutdown can damage file system blocks.
4. Aging of Storage Device
After long use, storage media may wear out.
5. Virus or Malware Attack
Viruses can corrupt data and create bad blocks.
6. Manufacturing Defect
Some storage devices may contain defective blocks from the beginning.
7. Excessive Heat
High temperature can damage the internal components.
8. Repeated Read/Write Operations
Frequent usage may reduce the life of storage blocks.
Types of Bad Block
Bad blocks are mainly divided into two types:
1. Physical Bad Block (Hard Bad Block)
A Physical Bad Block is created due to actual physical damage in the storage device. It is also called a hard bad block.
Disk Surface
--------------------
| Good | Bad | Good |
--------------------
Points:
It occurs because of hardware damage.
It is permanent in nature.
It cannot be repaired.
The operating system marks it as unusable.
Data stored in it may be permanently lost.
Example:
A damaged sector on a hard disk because of falling or scratching.
Advantages:
Helps the OS identify damaged sectors.
Prevents reuse of defective blocks.
Disadvantages:
Permanent data loss.
Reduces storage capacity.
2. Logical Bad Block (Soft Bad Block)
A Logical Bad Block occurs because of software errors or incorrect data writing. It is also called a soft bad block.
Data Error
--------------------
| Good | Error | Good |
--------------------
Points:
It occurs due to software or file system problems.
There is no physical damage.
It can be repaired using disk tools.
It is temporary in many cases.
Data may be recoverable.
Example:
Corrupted data after sudden shutdown.
Advantages:
Can be repaired.
Data can sometimes be recovered.
Disadvantages:
May affect system performance.
Can cause temporary data access problems.
Detection of Bad Blocks
The operating system can detect bad blocks using:
1. Disk Scanning
Checks all sectors of the disk.
2. Error Checking Tools
Tools like CHKDSK and fsck.
3. SMART Monitoring
Monitors disk health automatically.
4. Read/Write Testing
Detects errors during operations.
Prevention of Bad Blocks
Bad blocks can be reduced by:
Proper shutdown of the system.
Using UPS to avoid power failure.
Regular disk scanning.
Protecting storage from heat and shock.
Keeping antivirus updated.
Taking regular backups.
Applications / Where Bad Blocks are Found
Hard Disk Drive (HDD)
Solid State Drive (SSD)
USB Drive
Memory Card
CD/DVD
External Hard Disk
UNIT:2
Explain Mutual Exclusion in Operating System. (GTU Style – 7 Marks)
Mutual Exclusion
Mutual Exclusion is a synchronization technique used in an operating system to ensure that only one process can access a shared resource at a time.
It allows only one process to enter the critical section at a time. If one process is executing in the critical section, other processes must wait.
The main purpose of mutual exclusion is to prevent race condition and maintain data consistency.
Need of Mutual Exclusion
When many processes share the same resource like memory, file, or printer, problems may occur if they access it together.
For example:
Suppose two processes P1 and P2 want to update the same variable.
Value of X = 10
P1 adds 5
P2 adds 10
If both execute at the same time, the final result may be wrong.
So, mutual exclusion is required.
Real Life Example (Bank Transaction)
Consider a bank account with balance ₹10,000.
Two transactions happen at the same time:
- P1 wants to withdraw ₹2,000
- P2 wants to withdraw ₹3,000
Without mutual exclusion:
- P1 reads balance = ₹10,000
- P2 also reads balance = ₹10,000
- P1 updates balance = ₹8,000
- P2 updates balance = ₹7,000
Final balance becomes ₹7,000, but the correct balance should be ₹5,000.
This problem happens because both processes access the same data at the same time.
With mutual exclusion:
- P1 enters critical section and withdraws ₹2,000
- P2 waits outside
- After P1 finishes, P2 enters and withdraws ₹3,000
Final balance becomes ₹5,000, which is correct.
This shows why mutual exclusion is necessary.
Basic Structure of Critical Section
do{
Entry Section
Critical Section
Exit Section
Remainder Section
} while(TRUE);
1. Entry Section
In this section, the process requests permission to enter the critical section.
2. Critical Section
This section contains the code where shared resources are accessed.
3. Exit Section
After completing work, the process leaves the critical section.
4. Remainder Section
This is the remaining part of the program.
Requirements of Mutual Exclusion
A good mutual exclusion solution must satisfy the following conditions:
1. Mutual Exclusion
Only one process can enter the critical section at one time.
2. Progress
If no process is inside the critical section, waiting processes should be allowed to enter.
3. Bounded Waiting
Every process should get a chance after a limited waiting time.
Methods of Mutual Exclusion
1. Software Solutions
These methods use programming logic.
Examples:
Peterson’s Algorithm
Dekker’s Algorithm
2. Hardware Solutions
These methods use special CPU instructions.
Examples:
Test and Set
Compare and Swap
3. Semaphore
Semaphore is a signaling mechanism used for process synchronization.
It controls access to shared resources.
4. Mutex Lock
Mutex is a locking mechanism.
A process locks the resource before using it and unlocks after completing.
Advantages of Mutual Exclusion
It prevents race condition.
It protects shared data.
It maintains data consistency.
It provides proper synchronization.
Disadvantages of Mutual Exclusion
It may create deadlock.
It increases waiting time.
It can reduce system performance.
Applications of Mutual Exclusion
Printer sharing
File management
Database systems
Banking transactions
Shared memory access
OTHER QUE.
4. Compare Pre-emptive and Non-Preemptive Scheduling
Introduction
CPU Scheduling is the process of selecting a process from the ready queue and allocating the CPU for execution. Scheduling algorithms are mainly classified into Pre-emptive and Non-Preemptive scheduling.
Pre-emptive Scheduling
In Pre-emptive Scheduling, the operating system can take the CPU away from a running process and assign it to another process. This usually happens when a higher-priority process arrives or when the time quantum expires.
Examples
Round Robin (RR)
Shortest Remaining Time First (SRTF)
Pre-emptive Priority Scheduling
Advantages
Better response time.
Suitable for interactive and time-sharing systems.
High-priority processes get CPU quickly.
Disadvantages
More context switching overhead.
More complex to implement.
Non-Preemptive Scheduling
In Non-Preemptive Scheduling, once a process gets the CPU, it continues execution until it finishes or enters a waiting state. The CPU cannot be taken away forcibly.
Examples
FCFS (First Come First Serve)
SJF (Non-Preemptive)
Non-Preemptive Priority Scheduling
Advantages
Simple and easy to implement.
Less context switching overhead.
Efficient for batch systems.
Disadvantages
Poor response time.
Long processes may keep the CPU for a long time.
Comparison Between Pre-emptive and Non-Preemptive Scheduling
| Pre-emptive Scheduling | Non-Preemptive Scheduling |
|---|---|
| CPU can be taken away from a running process. | CPU cannot be taken away until the process completes. |
| More flexible and responsive. | Less responsive. |
| Suitable for time-sharing systems. | Suitable for batch processing systems. |
| Requires more context switching. | Requires less context switching. |
| More complex to implement. | Easy to implement. |
| Better response time. | Higher response time. |
| Examples: Round Robin, SRTF. | Examples: FCFS, SJF. |
| Higher overhead due to frequent switching. | Lower overhead. |
Conclusion
Pre-emptive scheduling allows the operating system to interrupt a running process and allocate the CPU to another process, resulting in better responsiveness. Non-Preemptive scheduling allows a process to run until completion, making it simpler and less costly. The choice between them depends on the requirements of the system.
UNIT=2
1. Explain Synchronization Problems in Operating Systems.
Introduction
In a multiprogramming operating system, multiple processes may execute simultaneously and share common resources such as memory, files, and printers. When several processes access shared data at the same time, inconsistencies may occur. To avoid such problems, process synchronization is required.
Synchronization is a technique used to coordinate the execution of multiple processes so that shared resources are accessed safely and correctly.
Need for Synchronization
To prevent data inconsistency.
To avoid race conditions.
To ensure mutual exclusion.
To maintain correct execution of processes.
To protect shared resources from simultaneous access.
Common Synchronization Problems
1. Producer-Consumer Problem (Bounded Buffer Problem)
In this problem, one process (Producer) produces data and places it into a buffer, while another process (Consumer) removes data from the buffer.
Problem
Producer should not add data if the buffer is full.
Consumer should not remove data if the buffer is empty.
Diagram
Producer ---> Buffer ---> Consumer
Solution
Use Semaphores and Mutual Exclusion.
Producer waits when the buffer is full.
Consumer waits when the buffer is empty.
Example
A keyboard (producer) generates characters and stores them in a buffer, while a program (consumer) reads those characters.
2. Readers-Writers Problem
In this problem, multiple readers and writers share a common database.
Problem
Multiple readers can read the database simultaneously.
Only one writer can write at a time.
No reader should read while a writer is updating data.
Diagram
Readers ----\
> Shared Database
Writers ----/
Solution
Allow multiple readers together.
Allow only one writer at a time using synchronization techniques.
Example
Students reading records from a library database while a librarian updates records.
3. Dining Philosophers Problem
This classical synchronization problem involves five philosophers sitting around a circular table.
Problem
Each philosopher alternates between thinking and eating.
To eat, a philosopher needs two forks.
If all philosophers pick one fork at the same time, deadlock occurs.
Diagram
P1
/ \
P5 P2
| |
P4 P3
(Forks are placed between philosophers.)
Solution
Use Semaphores.
Limit the number of philosophers allowed to eat simultaneously.
Prevent deadlock by proper resource allocation.
Example
Five people sharing limited resources such as printers or network connections.
Race Condition
A Race Condition occurs when two or more processes access and modify shared data simultaneously, and the final result depends on the order of execution.
Example
Suppose variable X = 10.
Process P1: X = X + 5
Process P2: X = X - 3
If both execute simultaneously, the final value may become incorrect.
Solution
Use synchronization mechanisms such as:
Mutex Locks
Semaphores
Monitors
Synchronization Tools
1. Semaphore
A semaphore is a signaling mechanism used to control access to shared resources.
2. Mutex
A mutex allows only one process to access a critical section at a time.
3. Monitor
A monitor is a high-level synchronization construct that provides mutual exclusion automatically.
Advantages of Synchronization
Prevents data inconsistency.
Avoids race conditions.
Ensures mutual exclusion.
Improves system reliability.
Provides proper sharing of resources.
Conclusion
Synchronization is an important concept in operating systems that coordinates multiple processes accessing shared resources. Common synchronization problems include the Producer-Consumer Problem, Readers-Writers Problem, and Dining Philosophers Problem. These problems are solved using techniques such as Semaphores, Mutexes, and Monitors, ensuring correct and efficient process execution.
