1. Process Management: The OS is responsible for creating, scheduling, and managing processes, ensuring efficient utilization of the CPU.

2. Memory Management: The OS manages the computer's memory, allocating and deallocating memory space as needed by applications.

3. File Management: The OS provides a file system for organizing and managing files and directories on storage devices.

4. Device Management: The OS controls and coordinates the operation of input/output devices, such as keyboards, mice, printers, and displays.

5. Security: The OS enforces security measures to protect the system from unauthorized access and ensure data integrity.

6. User Interface: The OS provides a user interface, either command-line or graphical, for the user to interact with the computer system.

1. Processor (CPU): The OS is responsible for scheduling and managing the execution of multiple processes on the CPU, ensuring fair and efficient utilization of the processor.

2. Memory: The OS manages the allocation and deallocation of memory to various processes, ensuring that each process has the necessary memory resources to execute.

3. Storage: The OS manages the file system, providing a way for applications and users to store, retrieve, and organize data on storage devices.

4. Input/Output (I/O) Devices: The OS controls and coordinates the operation of various input and output devices, such as keyboards, mice, printers, and displays, ensuring that they are used efficiently and effectively.

5. Network Resources: In a networked environment, the OS manages the access and utilization of network resources, such as shared files, printers, and network bandwidth.

• Allocating resources to processes and applications as needed

• Scheduling the use of resources to ensure fairness and efficiency

• Protecting resources from unauthorized access or misuse

• Monitoring and optimizing resource utilization

• Providing mechanisms for sharing resources among multiple users and processes

• Users do not interact with the computer directly in a batch operating system.

• Each user prepares their job on an off-line device like punch cards and submits it to the computer operator.

• Jobs with similar needs are batched together and run as a group to speed up processing.

• The main problems with batch systems are lack of interaction between the user and job, CPU often being idle due to slower I/O devices compared to CPU, and difficulty providing desired priority.

• Time-sharing enables multiple users at terminals to use a computer system simultaneously.

• The processor's time is shared among multiple users by executing each user program in short bursts or quanta.

• Advantages include quick response, avoiding software duplication, and reducing CPU idle time.

• Disadvantages are problems with reliability, security, integrity, and data communication.

• Multi-programming systems run multiple programs on a single processor by switching between them.

• If one program is waiting for I/O, other ready programs can use the CPU.

• Concurrent program execution improves resource utilization and throughput compared to serial and batch processing.

• Enables execution of two or more programs at the same time by switching each program into and out of memory.

• Programs are temporarily saved on disk when switched out of memory.

• Allows multiple users to share processor time on a central computer from different terminals.

• Rapidly switches between terminals, each getting limited processor time.

• With many users, the central computer's reply time can become noticeable.

• Uses multiple central processors to serve multiple real-time applications and users.

• Processing jobs are distributed among the processors.

• Processors communicate via communication lines and are loosely coupled.

• Advantages include resource sharing, faster data exchange, continued operation if one site fails, better service, and reduced host computer load.

• Processes and responds to inputs within a small time interval to control the environment.

• Used when there are rigid time constraints on processor operation or data flow.

• Two types:
• Hard real-time: Guarantees critical tasks complete on time. Limited storage, no virtual memory.
• Soft real-time: Less restrictive. Critical tasks get priority but may be limited.

1. New: When a process is created, it enters the new state. At this stage, the process is being initialized and prepared for execution.

2. Ready: Processes in the ready state are prepared to run but are waiting for the CPU to be assigned. They reside in main memory and are waiting for their turn to be executed.

3. Running: A process in the running state is actively being executed by the CPU. Only one process can be in the running state on a single-core system at a given time.

4. Blocked or Wait: Processes move to the blocked or wait state when they are waiting for a resource, such as user input or I/O operation, to become available. The OS may switch the CPU to other processes while a process is in this state.

5. Completion or Termination: When a process finishes its execution, it enters the completion or termination state. At this point, the process is terminated, and its resources are released.

New -> Ready -> Running -> Blocked -> Completion

• New: Process is created and initialized.

• Ready: Process is waiting for CPU allocation.

• Running: Process is actively executing on the CPU.

• Blocked: Process is waiting for a resource or event.

• Completion: Process has finished execution and is terminated.

• Processes are heavyweight and require more system resources compared to lightweight threads.

• Process switching requires interaction with the OS, while thread switching is faster as it doesn't need OS intervention.

• Processes have separate memory and resources, while threads share resources like memory and files within a process.

• If a process is blocked, the entire process is blocked, but in a multi-threaded process, other threads can still run while one thread is blocked.

• Using multiple processes requires more system resources compared to using multiple threads within a single process.

• Five philosophers sit around a circular table. In the center is a large bowl of rice.

• Between each pair of philosophers is a single chopstick.

• Each philosopher needs both chopsticks to eat.

• Philosophers spend their time thinking and eating. When a philosopher gets hungry, they try to pick up the two chopsticks next to them.

• The problem is to coordinate the philosophers so that no philosopher starves.

• Deadlock: If each philosopher picks up the left chopstick at the same time, they will all be holding one chopstick and waiting for the other, resulting in deadlock.

• Starvation: If a philosopher is continuously unlucky and never gets both chopsticks, they will starve.

• Philosophers can only pick up chopsticks in a specific order (e.g. odd philosophers pick up left first, even pick up right first).

• Philosophers must pick up both chopsticks at the same time.

• A philosopher can only pick up a chopstick if both chopsticks are available.

• A shared resource can be accessed by multiple readers simultaneously, but only by one writer at a time.

• Writers have priority over readers - if a writer is waiting to access the resource, no new readers should be allowed access.

• Readers should not be kept waiting indefinitely by writers.

• Starvation: If writers are always given priority, readers may starve and never get access.

• Deadlock: Improper synchronization between readers and writers can lead to deadlock.

• A semaphore can be used to control access to the shared resource.

• A mutex can be used to ensure only one writer accesses the resource at a time.

• A read-write lock can be used to allow multiple readers or one writer to access the resource.

• Readers increment a read count when entering and decrement it when exiting. Writers wait for the read count to be zero before accessing the resource.

1. Long-Term Scheduler (Job Scheduler):
• Determines which processes are admitted to the system for processing.
• Selects processes from the job queue and loads them into memory for execution.
• Controls the degree of multiprogramming by balancing the mix of jobs.

2. Short-Term Scheduler (CPU Scheduler):
• Increases system performance based on specific criteria.
• Selects a process from the ready queue for execution.
• Allocates CPU to the selected process, transitioning it from the ready state to the running state.
• Responsible for making quick decisions on which process to execute next.

3. Medium-Term Scheduler:
• Part of swapping, handling processes moved out of memory.
• Reduces the degree of multiprogramming by swapping out processes.
• Manages suspended processes, moving them to secondary storage to free up memory.
• Plays a role in improving the process mix and system performance.

1. CPU Utilization:
• Maximizing CPU usage to keep the system busy.
• Ranges from 0% to 100%, ideally between 40% to 90% for efficient operation.

2. Throughput:
• Measures the number of processes completed per unit of time.
• Indicates the system's efficiency in processing tasks.

3. Turnaround Time:
• Duration from process submission to completion.
• Includes waiting time, execution time, and I/O time.

4. Waiting Time:
• Time spent by a process in the ready queue waiting for CPU allocation.
• Reflects the efficiency of the scheduling algorithm.

5. Response Time:
• Time from request submission to the first response produced.
• Crucial for interactive systems to provide quick feedback to users.

1. Mutual Exclusion:
• At least one resource must be held in a non-shareable mode, meaning that only one process can use the resource at a time.

2. Hold and Wait:
• A process is holding at least one resource and is waiting to acquire additional resources held by other processes.

3. No Preemption:
• Resources cannot be taken away from a process; they can only be released voluntarily.

4. Circular Wait:
• There is a circular chain of two or more processes, each holding one or more resources that are being requested by the next process in the chain.

1. Time 0: Process 0 starts (P0) [Remaining burst time: 8]

2. Time 1: Process 1 arrives, it has a shorter burst time than P0. So, P1 starts (P1) [Remaining burst time: 4]

3. Time 2: Process 2 arrives, P1 continues since it has the shortest remaining burst time. [P1 remaining: 3]

4. Time 3: Process 3 arrives, P1 continues since it still has the shortest remaining burst time. [P1 remaining: 2]

5. Time 4-6: Process 1 continues until it finishes. [P1 remaining: 0]

6. Time 6-11: Process 3 has the shortest remaining time among the remaining processes (P0, P2, P3). So, P3 executes. [P3 remaining: 0]

7. Time 11-19: Process 0 continues as it has the next shortest remaining time. [P0 remaining: 0]

8. Time 19-26: Process 2 starts and completes. [P2 remaining: 0]

| P0 | P1 | P1 | P1 | P1 | P3 | P3 | P3 | P3 | P3 | P0 | P0 | P0 | P0 | P0 | P0 | P0 | P0 | P2 | P2 | P2 | P2 | P2 | P2 | P2 | P2 |
0    1    2    3    4    5    6    7    8    9   10    11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26

1. Turnaround Time (TAT) = Completion Time - Arrival Time

2. Waiting Time (WT) = Turnaround Time - Burst Time

• Average Turnaround Time: 13.75

• Average Waiting Time: 7.25

1. CPU Utilization:
• Maximizing CPU usage to keep the system busy.
• Ranges from 0% to 100%, ideally between 40% to 90% for efficient operation.

2. Throughput:
• Measures the number of processes completed per unit of time.
• Indicates the system's efficiency in processing tasks.

3. Turnaround Time:
• Duration from process submission to completion.
• Includes waiting time, execution time, and I/O time.

4. Waiting Time:
• Time spent by a process in the ready queue waiting for CPU allocation.
• Reflects the efficiency of the scheduling algorithm.

5. Response Time:
• Time from request submission to the first response produced.
• Crucial for interactive systems to provide quick feedback to users.

6. Fairness:
• Ensuring that each process gets a fair share of CPU time.
• Preventing starvation of low-priority processes.

7. Preemption:
• Ability to interrupt a running process and resume it later.
• Allows higher-priority processes to get CPU time when needed.

8. Priority:
• Assigning priorities to processes based on specific criteria.
• Ensures that important processes get CPU time first.

9. Predictability:
• Ability to predict the behavior of the scheduling algorithm.
• Helps in estimating the completion time of processes.

10. Overhead:
• The time and resources spent by the operating system in context switching and scheduling.
• Should be minimized to improve overall system performance.

1. Binary Semaphore:
• Also known as mutex (mutual exclusion).
• Can have only two values: 0 and 1.
• Used for protecting critical sections where only one process can access the resource at a time.
• Provides exclusive access to a resource.

2. Counting Semaphore:
• Can have an integer value greater than or equal to zero.
• Used to control access to a pool of identical resources.
• Allows multiple processes to access a resource up to a specified limit.
• Used for synchronization among multiple processes.

3. Mutex Semaphore:
• A mutex semaphore is a binary semaphore used for mutual exclusion.
• Ensures that only one process can access a resource at a time.
• Typically used to protect critical sections of code.

4. Named Semaphore:
• A semaphore that can be shared between processes.
• Identified by a name in the system and can be accessed by multiple processes.
• Useful for inter-process communication and synchronization.

5. Unnamed Semaphore:
• A semaphore that is local to a process and not shared between processes.
• Typically used for synchronization within a single process or thread.

6. Counting Semaphore with Priority Inheritance:
• Extends the counting semaphore to prevent priority inversion.
• Ensures that a high-priority process waiting for a resource held by a low-priority process will inherit the priority of the low-priority process.
• Helps prevent deadlock and priority inversion issues.

1. Initialization:
• Initialize the available resources and the maximum demand of each process.

2. Request:
• When a process requests resources, the system checks if the request can be granted without leading to an unsafe state.
• If the request can be granted, the resources are allocated to the process temporarily.

3. Safety Check:
• After allocating resources, the system checks if the new state is safe.
• It simulates the allocation of resources to all processes and checks if they can complete their tasks without deadlock.

4. Resource Allocation:
• If the new state is safe, the resources are permanently allocated to the process.
• If the new state is unsafe, the request is denied to avoid deadlock.

• Resource Allocation:
• P1: (2, 1, 0, 1, 0)
• P2: (1, 0, 3, 1, 4)
• P3: (1, 1, 1, 1, 1)

• Maximum Demand:
• P1: (3, 1, 1, 2, 1)
• P2: (1, 1, 5, 2, 4)
• P3: (2, 2, 1, 1, 2)

• Available Resources: (1, 0, 2, 1, 1)

• The CPU can be taken away from a process before it completes its execution.

• The operating system can interrupt a running process and allocate the CPU to another process.

• This is done when a higher priority process becomes ready or when the currently running process exceeds its time slice.

• Examples of preemptive scheduling algorithms include Round Robin and Preemptive Priority Scheduling.

• Ensures that high priority processes get the CPU when needed.

• Prevents lower priority processes from monopolizing the CPU.

• Provides better response time for interactive processes.

• Introduces overhead due to frequent context switches.

• Processes may have to wait longer to complete if they are frequently preempted.

• Once a process is allocated the CPU, it runs to completion without interruption.

• The CPU is taken away from a process only when it terminates or performs an I/O operation.

• The scheduler does not intervene to stop a running process.

• Lower overhead as context switches occur only when a process blocks or terminates.

• Simpler to implement compared to preemptive scheduling.

• Avoids issues like priority inversion and convoying.

• High priority processes may have to wait for a long time if a lower priority process is running.

• Interactive processes may experience poor response times.

• Processes can monopolize the CPU if they run for a long time without blocking.

• Ensure that resources are not held exclusively but can be shared among processes. If resources can be shared, deadlock can be prevented.

• Require processes to request all necessary resources at the beginning and only proceed if all resources can be allocated. If a process cannot get all resources, it releases all resources and starts over.

• Allow the operating system to preempt resources from processes if necessary. If a process cannot get all resources, preempt resources from other processes to avoid deadlock.

• Implement a policy that prevents circular dependencies by imposing a total ordering of all resources and requiring processes to request resources in a specific order.

1. Resource Allocation Graph:
• Represent resource allocation and request using a graph. Detect cycles in the graph to identify potential deadlocks and take corrective actions.

2. Banker's Algorithm:
• Ensure that the system is always in a safe state by granting resource requests only if the system will remain in a safe state after allocation.

3. Timeouts:
• Set timeouts for resource requests. If a process cannot get a resource within a specified time, release all resources and restart the process.

4. Resource Ordering:
• Define a global order for resources and require processes to request resources in that order to prevent circular wait conditions.

5. Dynamic Resource Allocation:
• Allow resources to be dynamically allocated and de-allocated to prevent deadlock situations.

6. Avoidance Algorithms:
• Use algorithms that predict resource requests and avoid granting resources that could lead to deadlock.

1. Disabling Interrupts:
• In a single-processor system, a process can achieve mutual exclusion by disabling interrupts before entering the critical section and re-enabling them after exiting.
• This approach is simple but has limitations as it requires the process to have special privileges and cannot be used in multiprocessor systems.

2. Strict Alternation:
• Two processes can achieve mutual exclusion using a strict alternation approach.
• Each process checks if it is its turn to enter the critical section and waits if it is not.
• This approach is simple but has limitations as it requires busy waiting and does not generalize to more than two processes.

3. Peterson's Algorithm:
• Peterson's algorithm is a software-based mutual exclusion algorithm for two processes.
• It uses a shared flag variable to indicate which process wants to enter the critical section and a turn variable to indicate whose turn it is to enter.
• Each process checks the flag and turn variables before entering the critical section.

4. Semaphores:
• Semaphores are a synchronization primitive that provide a way to achieve mutual exclusion.
• A binary semaphore (mutex) can be used to ensure that only one process enters the critical section at a time.
• Processes acquire the semaphore before entering the critical section and release it after exiting.

5. Mutex Locks:
• Mutex locks are a synchronization mechanism provided by many operating systems and programming languages.
• A mutex lock can be acquired by a process before entering the critical section and released after exiting.
• If a process tries to acquire a lock that is already held by another process, it is blocked until the lock is released.

6. Spinlocks:
• Spinlocks are a type of mutex lock that busy waits for the lock to become available.
• They are typically used in kernel-level code and on multiprocessor systems where the overhead of a context switch is high.
• Spinlocks are efficient when the critical section is short and the lock is likely to be available soon.

7. Monitors:
• Monitors are a high-level synchronization construct that provide mutual exclusion and condition variables.
• They encapsulate shared variables and the procedures that operate on them.
• Only one process can be active within a monitor at a time, ensuring mutual exclusion.

1. Batch Operating System

2. Time-Sharing Operating System

3. Multiprogramming Operating System
• Multitasking OS
• Multiuser OS
• Distributed OS

4. Real-Time Operating System
• Hard real-time OS
• Soft real-time OS

• Users do not interact with the computer directly in a batch operating system.

• Each user prepares their job on an off-line device like punch cards and submits it to the computer operator.

• Jobs with similar needs are batched together and run as a group to speed up processing.

• The main problems with batch systems are lack of interaction between the user and job, CPU often being idle due to slower I/O devices compared to CPU, and difficulty providing desired priority.

• Time-sharing enables multiple users at terminals to use a computer system simultaneously.

• The processor's time is shared among multiple users by executing each user program in short bursts or quanta.

• Advantages include quick response, avoiding software duplication, and reducing CPU idle time.

• Disadvantages are problems with reliability, security, integrity, and data communication.

• Multiprogramming OS: Runs multiple programs concurrently on a single processor by switching between them. Includes multitasking, multiuser, and distributed variants.

• Real-Time OS: Processes and responds to inputs within a small time interval to control the environment. Includes hard real-time (critical tasks complete on time) and soft real-time (critical tasks get priority) variants.

1. flag[i]: Indicates if process i wants to enter the critical section.

2. turn: Indicates whose turn it is to enter the critical section.

do {
    flag[i] = true;
    turn = j;
    while (flag[j] && turn == j);

    // critical section

    flag[i] = false;

    // remainder section
} while (true);

1. Process i sets its flag[i] to true to indicate it wants to enter the critical section.

2. It sets the turn variable to j, indicating it's now process j's turn.

3. It then enters a busy-wait loop, checking two conditions:
• flag[j] is true, meaning process j also wants to enter the critical section.
• turn is equal to j, meaning it's process j's turn.

4. If both conditions are true, process i waits in the loop.

5. If either condition is false, process i enters the critical section.

6. After the critical section, process i sets its flag[i] to false and enters the remainder section.

1. Mutual Exclusion: At most one process is in the critical section.

2. Progress: If no process is in the critical section and some processes want to enter, then only those processes that are not blocked can participate in deciding which will enter next.

3. Bounded Waiting: There is a bound on the number of times other processes can enter the critical section after a process has made a request to enter and before the request is granted.

• It only works for two processes.

• It assumes the processes execute at the same speed and make progress.

• It uses busy-waiting, which can be inefficient if the critical section is long.

| P1 | P2 | P3 | P4 |
0    21   24   30   32

• Waiting Time (WT) for P1 = 0 (starts immediately)

• Waiting Time (WT) for P2 = 21 (waits for P1 to finish)

• Waiting Time (WT) for P3 = 24 (waits for P1 and P2 to finish)

• Waiting Time (WT) for P4 = 30 (waits for P1, P2, and P3 to finish)

| P4 | P2 | P3 | P1 |
0    2    5   11  32

• Waiting Time (WT) for P4 = 0 (starts immediately)

• Waiting Time (WT) for P2 = 2 (waits for P4 to finish)

• Waiting Time (WT) for P3 = 5 (waits for P4 and P2 to finish)

• Waiting Time (WT) for P1 = 11 (waits for P4, P2, and P3 to finish)

• FCFS Average Waiting Time: 18.75

• SJF Average Waiting Time: 4.5

1. Process Management: The kernel is responsible for creating, scheduling, and managing processes. It allocates CPU time to processes and ensures fair and efficient utilization of the processor.

2. Memory Management: The kernel manages the computer's memory, allocating and deallocating memory space as needed by applications. It also handles virtual memory and paging.

3. File Management: The kernel provides a file system for organizing and managing files and directories on storage devices. It handles file-related operations like read, write, and seek.

4. Device Management: The kernel controls and coordinates the operation of input/output devices, such as keyboards, mice, printers, and displays. It provides a uniform interface for accessing devices.

5. Security: The kernel enforces security measures to protect the system from unauthorized access and ensure data integrity. It manages user accounts, permissions, and access control.

6. System Calls: The kernel provides a set of system calls that allow applications to request services from the operating system. System calls are the interface between user-mode applications and kernel-mode code.

#include <stdio.h>
#include <unistd.h>

int main() {
    printf("Hello, world!\\n");
    write(STDOUT_FILENO, "This is a system call example.\\n", 29);
    return 0;
}

• open(), read(), write(), close(): File I/O operations

• fork(), exec(), wait(), exit(): Process management

• malloc(), free(): Memory management

• socket(), send(), recv(): Network communication

• Process P1: Priority 3

• Process P2: Priority 1

• Process P3: Priority 2

• Time Quantum: 4 units

• Process P1: Burst Time 8 units

• Process P2: Burst Time 5 units

• Process P3: Burst Time 6 units

• Process P1: Burst Time 3 units

• Process P2: Burst Time 5 units

• Process P3: Burst Time 2 units

1. Improved Responsiveness: Threads allow an application to remain responsive even when one thread is performing a time-consuming task. This responsiveness is crucial for user interfaces and real-time systems.

2. Resource Sharing: Threads within the same process share the same memory space, allowing them to easily share data and communicate with each other. This shared memory simplifies inter-thread communication and coordination.

3. Efficient Utilization of Multi-Core Processors: Threads can be executed in parallel on multi-core processors, making better use of the available hardware resources and improving overall system performance.

4. Simplified Programming: Threads simplify the design and implementation of concurrent applications compared to processes. They are lightweight and have lower overhead, making them easier to create and manage.

5. Faster Context Switching: Context switching between threads is faster than between processes since threads share the same memory space. This results in lower overhead and improved performance.

6. Scalability: Threads allow applications to scale better on multi-core systems. By dividing tasks into threads, applications can take advantage of parallel processing and utilize multiple cores efficiently.

7. Modularity and Encapsulation: Threads promote modularity and encapsulation by allowing different parts of an application to be implemented as separate threads, each responsible for a specific task. This modular design enhances code reusability and maintainability.

8. Asynchronous Programming: Threads enable asynchronous programming, where tasks can run concurrently without blocking the main thread. This is useful for handling I/O operations, event-driven programming, and parallel processing.

• Critical Section: The part of the program where a process accesses a shared resource.

• Mutual Exclusion: Ensuring that only one process can execute the critical section at a time.

• Bounded Waiting: Ensuring that there is a limit on the number of times other processes can enter the critical section before a waiting process is granted access.

1. Mutual Exclusion: If one process is executing in its critical section, no other process can be executing in its critical section.

2. Progress: If no process is executing in its critical section and some processes want to enter their critical sections, then only those processes that are not executing in their remainder sections can participate in deciding which will enter its critical section next.

3. Bounded Waiting: There exists a bound on the number of times other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted.

do {
    flag[i] = true;
    turn = j;
    while (flag[j] && turn == j);

    // critical section

    flag[i] = false;

    // remainder section
} while (true);

1. Process i sets its flag[i] to true to indicate it wants to enter the critical section.

2. It sets the turn variable to j, indicating it's now process j's turn.

3. It then enters a busy-wait loop, checking two conditions:
• flag[j] is true, meaning process j also wants to enter the critical section.
• turn is equal to j, meaning it's process j's turn.

4. If both conditions are true, process i waits in the loop.

5. If either condition is false, process i enters the critical section.

6. After the critical section, process i sets its flag[i] to false and enters the remainder section.

• It only works for two processes.

• It assumes the processes execute at the same speed and make progress.

• It uses busy-waiting, which can be inefficient if the critical section is long.

1. wait(): Also known as P() or down(), it decrements the value of the semaphore if it is positive. If the value is zero or negative, the calling thread is blocked until the value becomes positive.

2. signal(): Also known as V() or up(), it increments the value of the semaphore. If there are blocked threads waiting on the semaphore, one of them is unblocked.

#include <semaphore.h>

sem_t mutex, wrt;
int readcount = 0;

void reader() {
    while (true) {
        sem_wait(&mutex);
        readcount++;
        if (readcount == 1)
            sem_wait(&wrt);
        sem_post(&mutex);

        // Read

        sem_wait(&mutex);
        readcount--;
        if (readcount == 0)
            sem_post(&wrt);
        sem_post(&mutex);
    }
}

void writer() {
    while (true) {
        sem_wait(&wrt);

        // Write

        sem_post(&wrt);
    }
}

1. mutex: A binary semaphore used to ensure mutual exclusion when updating the readcount variable.

2. wrt: A binary semaphore used to ensure mutual exclusion for writers.

3. readcount: A variable to keep track of the number of readers currently accessing the shared resource.

1. When a reader wants to access the shared resource, it first acquires the mutex semaphore to ensure mutual exclusion when updating readcount.

2. If the reader is the first one to enter, it acquires the wrt semaphore to ensure mutual exclusion for writers.

3. After acquiring the necessary semaphores, the reader can safely access the shared resource.

4. Before exiting, the reader decrements readcount and releases the mutex semaphore. If it was the last reader to exit, it releases the wrt semaphore to allow writers to access the shared resource.

5. When a writer wants to access the shared resource, it acquires the wrt semaphore, ensuring mutual exclusion for writers. This also prevents any new readers from entering while a writer is active.

6. After acquiring the necessary semaphores, the writer can safely access the shared resource.

7. Before exiting, the writer releases the wrt semaphore, allowing other writers or readers to access the shared resource.

1. Mutual Exclusion: At most one writer can access the shared resource at a time.

2. Readers-Writers Preference: Readers have priority over writers. If there are waiting readers, a writer cannot enter until all readers have finished.

3. No Starvation: Readers and writers are served in the order they request access to the shared resource.

1. Deadlock Detection and Killing Processes:
• Detect deadlocks using deadlock detection algorithms.
• Once a deadlock is detected, kill one or more processes involved in the deadlock to resolve it.
• This is the simplest recovery technique but can lead to loss of work and starvation if not done carefully.

2. Resource Preemption:
• Temporarily take away resources from processes involved in the deadlock.
• Choose a victim process and preempt some of its resources.
• Assign the preempted resources to other processes to break the deadlock.
• The victim process is rolled back to a safe state and restarted later.

3. Rollback:
• When a deadlock is detected, roll back the processes involved to a safe state before the deadlock occurred.
• Restore the system to a previous safe state by undoing the actions of the processes.
• Restart the processes from the safe state.
• Requires checkpointing to periodically save the state of processes.

4. Ignore Deadlocks:
• If deadlocks are very rare, it may be more efficient to simply ignore them.
• When a deadlock occurs, the system crashes or reboots.
• This is the approach taken by many operating systems like Windows and Unix.
• Suitable for single-user systems where deadlocks are unlikely.

• When a deadlock is detected, resources are taken away from processes involved in the deadlock.

• A victim process is chosen based on factors like how many resources it holds, how long it has been running, and how many times it has been a victim before.

• Resources are preempted from the victim process and given to other processes to break the deadlock.

• The victim process is rolled back to a safe state before the deadlock occurred.

• The victim process is restarted later when the deadlock is resolved.

1. Choose a victim process, say P1.

2. Preempt resource R1 from P1 and give it to P2 to allow P2 to complete.

3. Roll back P1 to a safe state before it acquired R1.

4. Restart P1 later when the deadlock is resolved.

monitor DiningPhilosophers {
    enum {THINKING, HUNGRY, EATING} state[5];
    condition self[5];

    void pickup(int i) {
        state[i] = HUNGRY;
        test(i);
        if (state[i] != EATING)
            self[i].wait();
    }

    void putdown(int i) {
        state[i] = THINKING;
        test((i + 4) % 5);
        test((i + 1) % 5);
    }

    void test(int i) {
        if (state[(i + 4) % 5] != EATING && state[i] == HUNGRY && state[(i + 1) % 5] != EATING) {
            state[i] = EATING;
            self[i].signal();
        }
    }

    void initialize() {
        for (int i = 0; i < 5; i++)
            state[i] = THINKING;
    }
}

• Each philosopher is represented by an index i from 0 to 4.

• The pickup method is used when a philosopher wants to eat. It sets the philosopher's state to HUNGRY and checks if they can start eating.

• The putdown method is used when a philosopher finishes eating. It sets the philosopher's state to THINKING and checks if neighboring philosophers can start eating.

• The test method checks if a philosopher can start eating based on the states of neighboring philosophers.

• The initialize method initializes the states of all philosophers to THINKING.

Semaphore chopstick[5] = {1, 1, 1, 1, 1}; // Semaphore for each chopstick

void philosopher(int i) {
    while (true) {
        think(); // Philosopher is thinking
        wait(chopstick[i]); // Wait for left chopstick
        wait(chopstick[(i + 1) % 5]); // Wait for right chopstick
        eat(); // Philosopher is eating
        signal(chopstick[i]); // Release left chopstick
        signal(chopstick[(i + 1) % 5]); // Release right chopstick
    }
}

• Each philosopher is represented by an index i from 0 to 4.

• Each chopstick is represented by a semaphore in the chopstick array.

• The philosopher function represents the behavior of a philosopher:
• Think: Philosopher is thinking.
• Wait: Philosopher waits to pick up the left and right chopsticks.
• Eat: Philosopher is eating.
• Signal: Philosopher releases the left and right chopsticks.

monitor ProducerConsumer {
    int buffer[N];
    int in = 0, out = 0, count = 0;

    condition notFull, notEmpty;

    void produce(int item) {
        if (count == N)
            notFull.wait();

        buffer[in] = item;
        in = (in + 1) % N;
        count++;

        if (count == 1)
            notEmpty.signal();
    }

    int consume() {
        if (count == 0)
            notEmpty.wait();

        int item = buffer[out];
        out = (out + 1) % N;
        count--;

        if (count == N - 1)
            notFull.signal();

        return item;
    }
}

• The monitor ProducerConsumer manages a shared buffer with a fixed size N.

• The produce method is used by producers to add items to the buffer.

• The consume method is used by consumers to remove items from the buffer.

• The notFull and notEmpty conditions are used to signal when the buffer is not full or not empty, respectively.

• Producers wait if the buffer is full, and consumers wait if the buffer is empty.

1. Thread ID: A unique identifier assigned to each thread.

2. Program Counter: Indicates the address of the next instruction to be executed by the thread.

3. Register Set: Includes the registers used by the thread for its execution.

4. Stack: Stores the local variables and return addresses of the thread.

1. User-Level Threads

2. Kernel-Level Threads

1. Implemented in the kernel: Kernel-Level Threads are implemented within the kernel, which provides a thread control block (TCB) for each thread.

2. Scheduling: The kernel scheduler is responsible for scheduling threads on available CPUs. It uses preemptive scheduling to switch between threads.

3. System calls: Kernel-Level Threads can make system calls to the kernel for services like I/O operations, memory management, and synchronization.

4. Blocking: If a thread blocks (e.g., waiting for I/O), the kernel can switch to another thread, allowing the CPU to be utilized efficiently.

5. Synchronization: The kernel provides synchronization primitives like semaphores and mutexes to coordinate access to shared resources among threads.

• Efficient scheduling: The kernel has complete control over thread scheduling, allowing for efficient utilization of CPU resources.

• Blocking: When a thread blocks, the kernel can switch to another thread without incurring the overhead of a full process switch.

• Compatibility: Kernel-Level Threads are compatible with multiprocessor systems, allowing threads to be scheduled on different CPUs.

• Overhead: Creating and managing threads in the kernel incurs more overhead compared to User-Level Threads.

• Complexity: The kernel is more complex due to the additional functionality required for thread management.

1. Thread ID: A unique identifier assigned to each thread.

2. Program Counter: Indicates the address of the next instruction to be executed by the thread.

3. Register Set: Includes the registers used by the thread for its execution.

4. Stack: Stores the local variables and return addresses of the thread.

1. User-Level Threads

2. Kernel-Level Threads

1. Implemented in the kernel: Kernel-Level Threads are implemented within the kernel, which provides a thread control block (TCB) for each thread.

2. Scheduling: The kernel scheduler is responsible for scheduling threads on available CPUs. It uses preemptive scheduling to switch between threads.

3. System calls: Kernel-Level Threads can make system calls to the kernel for services like I/O operations, memory management, and synchronization.

4. Blocking: If a thread blocks (e.g., waiting for I/O), the kernel can switch to another thread, allowing the CPU to be utilized efficiently.

5. Synchronization: The kernel provides synchronization primitives like semaphores and mutexes to coordinate access to shared resources among threads.

• Efficient scheduling: The kernel has complete control over thread scheduling, allowing for efficient utilization of CPU resources.

• Blocking: When a thread blocks, the kernel can switch to another thread without incurring the overhead of a full process switch.

• Compatibility: Kernel-Level Threads are compatible with multiprocessor systems, allowing threads to be scheduled on different CPUs.

• Overhead: Creating and managing threads in the kernel incurs more overhead compared to User-Level Threads.

• Complexity: The kernel is more complex due to the additional functionality required for thread management.

• open(), read(), write(), close(): File I/O operations

• fork(), exec(), wait(), exit(): Process management

• malloc(), free(): Memory management

• socket(), send(), recv(): Network communication

1. Library APIs: Provide access to functionality within a library or framework.

2. Web APIs: Allow communication between web-based applications, often using HTTP and JSON or XML.

3. Operating System APIs: Provide access to operating system services, such as file I/O, process management, and networking.

4. Remote APIs: Allow communication between applications over a network, often using protocols like SOAP or REST.

1. FCFS (First-Come-First-Served) Scheduling: In FCFS, processes are executed in the order they arrive in the ready queue. If a high-priority process arrives after a low-priority process, the low-priority process may continue to execute, causing the high-priority process to starve[1].

2. SJF (Shortest Job First) Scheduling: In SJF, the process with the shortest burst time is executed first. If a process with a shorter burst time arrives after a process with a longer burst time, the process with the longer burst time may continue to execute, causing the process with the shorter burst time to starve[1].

3. Priority Scheduling: In priority scheduling, processes are executed based on their priority. If a process with a higher priority arrives after a process with a lower priority, the process with the lower priority may continue to execute, causing the process with the higher priority to starve[1].

4. Round Robin Scheduling: In round robin scheduling, each process is given a fixed time slice (called a time quantum) to execute. If a process requires more time than its allocated time quantum, it may not complete its execution, leading to starvation[1].

• Priority inversion: When a high-priority process is blocked by a low-priority process, causing the high-priority process to starve.

• Resource contention: When multiple processes contend for a shared resource, leading to starvation if the resource is not allocated fairly.

• Scheduling policy: The scheduling policy itself can lead to starvation if it does not ensure fairness in resource allocation.

• Priority aging: Increasing the priority of a process over time to ensure it gets a chance to execute.

• Time slicing: Allocating a fixed time slice to each process to ensure every process gets a chance to execute.

• Resource allocation algorithms: Using algorithms that ensure fair allocation of resources to prevent starvation.