Operating System Lab Reports 2080

1. What are the different types of operating system? Describe OS services.

There are several types of operating systems, including:

1. Single-User, Single-Tasking: These systems allow only one user to execute one program at a time.
2. Single-User, Multi-Tasking: These systems allow one user to run multiple programs simultaneously.
3. Multi-User: These systems support multiple users simultaneously, each with their own sessions.
4. Real-Time Operating Systems (RTOS): Designed for time-sensitive applications, such as industrial control systems or robotics.
5. Distributed Operating Systems: Multiple machines work together to provide a unified computing environment.
6. Network Operating Systems: Manage and coordinate network resources.
7. Mobile Operating Systems: Designed for smartphones and tablets, like Android and iOS.

Operating System services include:

• Program Execution: Loading programs into memory and executing them.
• I/O Operations: Managing input and output operations.
• File System Manipulation: Creating, deleting, reading, and writing files.
• Communication Services: Enabling processes to exchange data and messages.
• Error Detection and Handling: Detecting and resolving errors to ensure system stability.
• Resource Allocation: Managing hardware resources like CPU time, memory, and I/O devices.
• Security and Access Control: Protecting data and restricting access to authorized users.
• User Interface: Providing a user-friendly interface for interaction.

Let me know if you'd like more details about any of these points!

 

2. Describe process and threads in OS. Explain different states of process with figure.

A process in an operating system is a program in execution. It consists of the program code, data, and the execution context. Processes are independent entities that run in their own memory spaces and have their own system resources.

Threads, on the other hand, are smaller units within a process. Multiple threads can exist within a single process and share the same resources like memory space and file descriptors. Threads within a process can run concurrently, allowing for more efficient multitasking.

Here are the different states of a process in an operating system:

1. New: The process is being created and initialized.
2. Ready: The process is ready to run and waiting to be assigned to a processor.
3. Running: The process is currently being executed by a processor.
4. Blocked (Waiting): The process is unable to execute until a certain event occurs, like an I/O operation completing.
5. Terminated: The process has completed its execution or has been explicitly terminated.

Unfortunately, I cannot provide a figure directly, but you can imagine a flowchart where processes transition from one state to another based on various events. For example, a process starts in the "New" state, moves to "Ready" when it's ready to run, transitions to "Running" when it's executing, may go to "Blocked" when waiting for I/O, and finally enters the "Terminated" state when it finishes.

Let me know if you have any further questions or if there's anything else you'd like to know!

 

What is process synchronization? How do the operating systems synchronize two processes using Peterson's Algorithm?

Process synchronization is a crucial concept in operating systems to ensure that multiple processes or threads work together harmoniously and avoid conflicts when accessing shared resources. It helps prevent issues like race conditions, where the final outcome depends on the order of execution.

Peterson's Algorithm is a classic synchronization algorithm used for achieving mutual exclusion between two processes in a shared memory environment. It ensures that only one process can execute a critical section (a portion of code that accesses shared resources) at a time. Here's a high-level explanation of how Peterson's Algorithm works:

Assume we have two processes, P0 and P1, and two shared variables: turn and flag. turn indicates whose turn it is to enter the critical section, and flag indicates if a process wants to enter the critical section.

1. Initialization: Both turn and flag are set to indicate that neither process is in the critical section.
2. Process P0:
• Set flag[0] to indicate that P0 wants to enter the critical section.
• Set turn to 1, indicating that it's P1's turn.
• Check if P1 wants to enter the critical section (flag[1] is true) and if it's P1's turn (turn == 1). If both conditions are true, P0 yields the turn to P1.
• If not, P0 enters the critical section, performs its work, clears its flag[0], and exits the critical section.
3. Process P1:
• Set flag[1] to indicate that P1 wants to enter the critical section.
• Set turn to 0, indicating that it's P0's turn.
• Check if P0 wants to enter the critical section (flag[0] is true) and if it's P0's turn (turn == 0). If both conditions are true, P1 yields the turn to P0.
• If not, P1 enters the critical section, performs its work, clears its flag[1], and exits the critical section.

By using the flag and turn variables along with appropriate checks, Peterson's Algorithm ensures that only one process can enter the critical section at a time, while also allowing processes to take turns fairly.

 

3. What is CPU scheduling? Describe the Round Robbin CPU scheduling algorithm with example with CPU Burst Time.

 

CPU scheduling is a key function of an operating system that manages the allocation of CPU time to various processes in order to achieve efficient and fair utilization of the CPU. It determines the order in which processes are executed and switches between them based on specific scheduling algorithms.

The Round Robin (RR) CPU scheduling algorithm is a widely used preemptive scheduling algorithm. In Round Robin scheduling, each process is assigned a fixed time quantum or time slice, and the processes are executed in a circular order. When a process's time quantum expires, it is moved to the back of the queue, and the CPU is given to the next process in line.

Let's illustrate the Round Robin scheduling algorithm with an example using CPU Burst Times:

Consider three processes: P1, P2, and P3, with their respective CPU Burst Times (in milliseconds):

P1: 12 ms P2: 6 ms P3: 8 ms

Let's assume the time quantum is 4 ms. The execution would proceed as follows:

1. Time 0 ms: P1 arrives and is assigned the CPU.
• P1 executes for 4 ms (remaining burst time: 8 ms).
• P2 enters the ready queue.
2. Time 4 ms: P1's time quantum expires, and P2 is assigned the CPU.
• P2 executes for 4 ms (remaining burst time: 2 ms).
• P3 enters the ready queue.
3. Time 8 ms: P2's time quantum expires, and P3 is assigned the CPU.
• P3 executes for 4 ms (remaining burst time: 4 ms).
• P1 remains in the ready queue.
4. Time 12 ms: P3's time quantum expires, and P1 is assigned the CPU.
• P1 executes for 4 ms (remaining burst time: 4 ms).
• P2 remains in the ready queue.
5. Time 16 ms: P1's time quantum expires, and P2 is assigned the CPU.
• P2 completes its remaining burst time (2 ms).
• P3 remains in the ready queue.
6. Time 18 ms: P2 completes its execution.
• P3 is assigned the CPU.
7. Time 22 ms: P3's time quantum expires, and P1 is assigned the CPU.
• P1 completes its remaining burst time (4 ms).
8. Time 24 ms: P3 completes its execution.

The execution order would be: P1, P2, P3, P1, P2, P3, P1, P3.

4. Explain the different types of page replacements algorithm.

Page replacement algorithms are used in operating systems to manage memory by selecting which page to replace when a new page needs to be loaded into memory and there is no free space available. Different algorithms have different strategies for selecting which page to evict. Here are some of the common page replacement algorithms:

1. FIFO (First-In-First-Out): The oldest page in memory is replaced. This algorithm is easy to implement but can suffer from the "Belady's Anomaly," where increasing the number of frames can lead to more page faults.
2. Optimal Page Replacement: The page that will not be used for the longest period of time in the future is replaced. It provides the best possible performance but is often not practical since it requires knowledge of future page accesses.
3. LRU (Least Recently Used): The page that has not been used for the longest time is replaced. It tries to mimic the optimal algorithm by replacing the least recently used page. Implementing LRU efficiently can be challenging, especially in systems with a large number of pages.
4. LFU (Least Frequently Used): The page with the smallest usage count is replaced. This algorithm assumes that pages used less frequently are less likely to be needed in the future.
5. MFU (Most Frequently Used): The page with the highest usage count is replaced. It aims to keep pages that are frequently used, but it can be less effective if a page is heavily used initially and then becomes unused.
6. Clock (Second-Chance): Pages are treated as a circular list. A "hand" points to the oldest page, and when a page is to be replaced, the hand is moved forward until a page with a "second chance" (not recently used) is found. This combines aspects of FIFO and LRU.
7. Random Page Replacement: A random page is chosen for replacement. This algorithm is simple but may not perform well in practice.

 

5.OR. How does paging work in virtual memory? Explain.

Paging is a memory management scheme used in virtual memory systems to efficiently manage large amounts of memory in both physical RAM and secondary storage (usually a disk). Virtual memory allows processes to use more memory than is physically available by using a combination of RAM and disk space.

Here's how paging works in virtual memory:

1. Page and Page Table: Memory is divided into fixed-size blocks called "pages." Similarly, the physical memory (RAM) is divided into blocks of the same size called "frames." Each process has its own page table, which maps the logical addresses (pages) to physical addresses (frames).
2. Address Translation: When a process accesses a memory location, it generates a logical address. The logical address is split into a page number and an offset within the page. The page number is used to index the process's page table, which provides the corresponding frame number (physical address). The offset remains unchanged.
3. Page Fault: If the page corresponding to the logical address is not in physical memory (i.e., it's a "page fault"), the operating system needs to bring that page into memory from the secondary storage (disk). This involves selecting a victim page (if all frames are in use) and loading the required page from disk to a free frame in RAM.
4. Frame Management: To manage the available frames in RAM, a data structure known as the "page frame table" or "frame table" is maintained. It keeps track of which frames are in use, which are free, and which page is mapped to each frame.
5. Replacement Policy: If there are no free frames when a page fault occurs, the operating system uses a page replacement algorithm (such as LRU, FIFO, etc.) to select a victim page for replacement. The selected page is evicted from RAM, and the new page is brought in.
6. Swapping: When a page is replaced, it may be written back to disk if it has been modified since it was loaded into memory. This process is known as "swapping" or "page swapping." Swapping helps manage the limited amount of RAM effectively.
7. Dirty Bit: A "dirty bit" is used to track whether a page has been modified since it was loaded into memory. This helps determine whether a page needs to be written back to disk before being replaced.

5. Describe the different RAID level with suitable diagram.

RAID (Redundant Array of Independent Disks) is a technology used to improve the performance, reliability, and capacity of storage systems by combining multiple physical disk drives into a single logical unit. There are several RAID levels, each with its own characteristics and benefits. Here, I'll describe the most common RAID levels along with a brief explanation and suitable diagrams:

1. RAID 0 (Striping):
• Data is striped across multiple disks without any redundancy.
• Offers improved performance since data can be read/written in parallel from/to multiple disks.
• No fault tolerance; if one disk fails, all data is lost.
• Diagram:

mathematicaCopy code

Disk 1 Disk 2 Disk 3 +--+ +--+ +--+ |A | |B | |C | +--+ +--+ +--+ |D | |E | |F | +--+ +--+ +--+

2. RAID 1 (Mirroring):
• Data is duplicated (mirrored) on two or more disks.
• Provides data redundancy; if one disk fails, data is still available on the mirrored disk(s).
• Improved read performance, but write performance may be slightly reduced.
• Diagram:

cssCopy code

Disk 1 Disk 2 +--+ +--+ |A | |A | +--+ +--+ |B | |B | +--+ +--+

3. RAID 5 (Striping with Distributed Parity):
• Data is striped across multiple disks with distributed parity information.
• Provides fault tolerance and good performance.
• Requires a minimum of three disks.
• Diagram:

mathematicaCopy code

Disk 1 Disk 2 Disk 3 +--+ +--+ +--+ |A | |B | |P | +--+ +--+ +--+ |C | |P | |D | +--+ +--+ +--+

4. RAID 6 (Striping with Dual Parity):
• Similar to RAID 5, but with two independent parity calculations.
• Can tolerate the failure of two disks simultaneously.
• Provides high fault tolerance at the cost of increased storage overhead.
• Diagram:

mathematicaCopy code

Disk 1 Disk 2 Disk 3 Disk 4 +--+ +--+ +--+ +--+ |A | |B | |P1| |P2| +--+ +--+ +--+ +--+ |C | |D | |P2| |P1| +--+ +--+ +--+ +--+

5. RAID 10 (RAID 1+0 or Mirrored Stripes):
• Combines RAID 1 (mirroring) and RAID 0 (striping).
• Offers both data redundancy and improved performance.
• Requires a minimum of four disks.
• Diagram:

Mathematica Copy code

Disk 1 Disk 2 Disk 3 Disk 4 +--+ +--+ +--+ +--+ |A | |A | |C | |C | +--+ +--+ +--+ +--+ |B | |B | |D | |D | +--+ +--+ +--+ +--+

These are some of the common RAID levels, each with its own trade-offs between performance, redundancy, and storage efficiency. The choice of RAID level depends on the specific requirements of the storage system and the desired balance between performance and data protection.

 

6. What are the different types of file allocation methods? Explain them with necessary diagrams.

There are three main types of file allocation methods used in operating systems to manage how files are stored on disk: contiguous allocation, linked allocation, and indexed allocation. Each method has its own advantages and disadvantages. Here's an explanation of each method along with diagrams:

1. Contiguous Allocation:
• Each file occupies a set of contiguous blocks on the disk.
• Simple and efficient for sequential access.
• Fragmentation can occur, leading to inefficient use of space.

Diagram:

cssCopy code

+---+---+---+---+---+---+---+---+ | | A | A | A | B | C | | | +---+---+---+---+---+---+---+---+

2. Linked Allocation:
• Files are divided into blocks, and each block contains a pointer to the next block.
• No fragmentation, but random access can be slow due to the need to traverse the linked blocks.
• Disk space overhead due to storing pointers.

Diagram:

diffCopy code

File A: +---+ +---+ +---+ +---+ | | -> | B | -> | D | -> | | +---+ +---+ +---+ +---+ File B: +---+ +---+ | | -> | C | +---+ +---+

3. Indexed Allocation:
• Each file has an index block containing pointers to its data blocks.
• Provides efficient random access, but can lead to space wastage if small files are stored.
• Combines characteristics of both contiguous and linked allocation.

Diagram:

mathematicaCopy code

Index Block for File A: +---+---+---+---+ | B | C | D | | +---+---+---+---+ Data Blocks: +---+ +---+ +---+ +---+ | | | B | | D | | | +---+ +---+ +---+ +---+ Index Block for File B: +---+---+ | C | D | +---+---+ Data Blocks: +---+ | C | +---+

Each file allocation method has its own trade-offs in terms of space utilization, access speed, and management complexity. The choice of method depends on the characteristics of the file system and the types of files being stored

Bottom of Form