ASSIGNMENT 1

Q.(1) Define real time operating system? What are the factors that need to be
considered to
determine the degree of Multiprogramming in a system?

A Real-Time Operating System (RTOS) is designed to manage hardware resources and

execute applications within strict timing constraints. Unlike general-purpose
operating systems, which prioritize throughput and resource utilization, an RTOS
ensures that critical tasks are completed within predetermined time limits, making
it essential for applications requiring timely and deterministic responses, such as
embedded systems, automotive control, medical devices, and industrial automation.

Factors Influencing the Degree of Multiprogramming in a System:

System Resources: The availability of CPU, memory, and I/O devices determines how
many processes can run concurrently. Limited resources restrict the level of
multiprogramming.

Task Characteristics: The nature of the tasks, such as their computational

intensity, I/O demands, and execution times, influences the system's ability to
manage multiple processes. Short-lived or I/O-bound tasks allow for higher
multiprogramming levels.

Scheduling Algorithms: The efficiency of the scheduling strategy (e.g., Round

Robin, Shortest Job First) impacts how effectively processes are managed and how
quickly they can switch contexts, affecting overall system performance.

Context Switching Overhead: Frequent context switching can degrade performance. The
overhead associated with saving and loading process states must be balanced with
the need for concurrent execution.

User Requirements: The expectations for response time and throughput from the end-
users can influence how many processes should be running simultaneously without
compromising system performance.

Q.(2) How would you define following structures of Operating System:-

a. Layered System
b. Virtual Machine
c. Client Server System

a. Layered System:
A Layered Operating System architecture organizes the OS into distinct layers, each
with specific functionalities and responsibilities. The top layer provides user
interfaces and application support, while lower layers handle hardware interactions
and system-level operations. This modular structure promotes simplicity and
maintainability, as each layer can be developed and updated independently. For
example, in a typical layered OS, the user interface might interact with a
middleware layer that communicates with hardware drivers. This separation allows
for easier debugging and enhances security since lower layers can be protected from
direct user access, limiting potential vulnerabilities.

b. Virtual Machine:
A Virtual Machine (VM) is an abstraction that enables the execution of multiple
operating systems or instances of an OS on a single physical hardware system. The
hypervisor or virtual machine monitor (VMM) manages these VMs, allocating resources
and isolating their operations. Each VM operates as if it were a separate physical
machine, allowing for efficient resource utilization and flexibility. This
structure is particularly useful for server consolidation, testing different OS
versions, and creating isolated environments for software development. VMs enhance
portability and scalability, enabling applications to run in diverse environments
without modification.

c. Client-Server System:
A Client-Server System architecture separates service providers (servers) from
service requesters (clients). In this model, clients initiate requests for
resources or services, which servers fulfill. This structure is highly scalable,
allowing multiple clients to connect to a single server or a group of servers,
facilitating load balancing and resource management. The client-server model is
widely used in network applications, where clients may be personal computers or
mobile devices, and servers can host databases, applications, or web services. This
separation enhances security, as servers can implement centralized controls, and
promotes modular development, enabling easier updates and maintenance.

Q.(3) Differentiate between the followings:-

a. Buffering and Spooling b. System Programs and System Calls

a. Buffering vs. Spooling:

Buffering is a technique used to temporarily hold data in memory while it is being
transferred between two locations, such as between an application and a disk or
network. The primary purpose of buffering is to manage differences in data
processing rates. For example, when a program writes data to a disk, it may use a
buffer to collect a certain amount of data before writing it in one operation, thus
improving efficiency and reducing the number of write operations.

Spooling (Simultaneous Peripheral Operations On-Line) is a specialized form of

buffering that involves the preparation and scheduling of data for processing. In
spooling, data is temporarily stored in a queue (often on disk) for later
processing by an output device, like a printer. For example, when multiple print
jobs are sent to a printer, they are spooled in a queue, allowing the printer to
process them sequentially, improving the overall efficiency of resource
utilization.

b. System Programs vs. System Calls:

System Programs are utility programs that provide services to users and manage
system resources. These programs are designed to perform specific tasks, such as
file management, system monitoring, and configuration. Examples include file
browsers, command interpreters, and system utilities like disk cleanup tools.

System Calls, on the other hand, are the programming interface through which user
programs interact with the operating system's core services. System calls allow
applications to request services from the OS, such as file operations, process
management, and communication. They act as a bridge between user applications and
the operating system, facilitating actions like opening files, creating processes,
or sending network requests.

Assignment II

Q. (1) How would you apply scheduling policy for each of the following cases?
Explain your
reasons for choosing them:
a. The processes arrive at large time intervals
b. The system’s efficiency is measured by the percentage of jobs completed.
c. All the processes take almost equal amounts of time to complete
a. The processes arrive at large time intervals:
Scheduling Policy: First-Come, First-Served (FCFS)
Reasoning: Since processes arrive at large intervals, the system can afford to use
a simple and straightforward scheduling algorithm like FCFS. This method ensures
that processes are executed in the order they arrive, leading to minimal waiting
time for individual processes. Since the arrival times are significantly spaced
apart, the chances of context switching and overhead are reduced, thereby enhancing
overall efficiency. This policy also minimizes the complexity of the scheduler and
keeps it efficient for such sporadic arrivals.

b. The system’s efficiency is measured by the percentage of jobs completed:

Scheduling Policy: Shortest Job First (SJF)
Reasoning: To maximize the percentage of jobs completed, SJF is an optimal choice.
By prioritizing shorter jobs, the system minimizes the average waiting time and
turnaround time, allowing more processes to be completed in a given time frame.
This policy also helps in reducing the average waiting time and improving the
throughput, leading to higher efficiency. While SJF may require knowledge of the
job lengths, it effectively maximizes job completion rates when appropriately
implemented.

c. All the processes take almost equal amounts of time to complete:

Scheduling Policy: Round Robin (RR)
Reasoning: When processes have similar execution times, Round Robin is an ideal
scheduling policy. This algorithm allocates a fixed time slice (quantum) to each
process, allowing all processes to receive an equal share of CPU time. This
fairness leads to improved responsiveness and ensures that no single process
monopolizes the CPU. Additionally, with similar process durations, the context-
switching overhead becomes less impactful, leading to efficient CPU utilization and
user satisfaction. RR effectively balances the workload and maintains system
responsiveness in such scenarios.

Q.(2) Define WAIT & SIGNAL Operations.

WAIT and SIGNAL operations are fundamental synchronization mechanisms used in

concurrent programming to manage access to shared resources and prevent race
conditions among processes or threads.

WAIT Operation:
The WAIT operation (also known as P or down operation) is employed when a process
or thread wants to access a resource that may not be immediately available. When a
process invokes WAIT on a semaphore (a synchronization variable), it checks the
semaphore's value. If the value is greater than zero, the process decrements the
semaphore (indicating that a resource is being used) and continues execution. If
the value is zero, the process is blocked and placed in a waiting queue,
effectively yielding control until the resource becomes available. This operation
ensures that processes only access resources when they are free, preventing
conflicts.

SIGNAL Operation:
The SIGNAL operation (also known as V or up operation) is used to indicate that a
resource has been released or is now available. When a process completes its use of
a resource, it invokes SIGNAL on the corresponding semaphore. This operation
increments the semaphore's value, and if any processes are waiting in the queue,
one of them is unblocked and allowed to proceed. SIGNAL thus serves to notify
waiting processes that they can now access the resource.

Q.(3) What is a critical section? Give solution to the critical section problem
using semaphores.
A critical section is a segment of code in a multi-threaded or multi-process
environment where shared resources (such as variables or data structures) are
accessed and manipulated. The critical section problem arises when multiple
processes or threads attempt to enter their critical sections simultaneously,
potentially leading to data inconsistency and unpredictable behavior.

Solution Using Semaphores:

Semaphores are synchronization tools that help manage access to shared resources
and prevent race conditions. Here’s how to solve the critical section problem using
semaphores:

Initialization: Define a semaphore variable, typically initialized to 1. This

semaphore will control access to the critical section.

semaphore mutex = 1; // Binary semaphore

Entering the Critical Section: Each process must execute the following code before
entering its critical section:

wait(mutex); // Decrement the semaphore

f the semaphore value is greater than 0, the process enters the critical section
and decrements the semaphore. If the value is 0, the process is blocked and waits.

Exiting the Critical Section: Once a process finishes executing its critical
section, it must signal the semaphore:

signal(mutex); // Increment the semaphore

This operation releases the semaphore, allowing other waiting processes to enter
their critical sections.

Assignment III

Q. (1) What is fragmentation ? What are its types? How they are minimized in
different
memory management schemes ?

Fragmentation refers to the inefficient use of memory space that occurs when free
memory is divided into small, non-contiguous blocks. It can lead to reduced
available memory for new processes, ultimately impacting system performance.
Fragmentation is typically categorized into two types:

Types of Fragmentation:
Internal Fragmentation: This occurs when allocated memory blocks are larger than
the requested memory. For example, if a process requests 20 KB but is allocated 32
KB, the remaining 12 KB is wasted, leading to internal fragmentation.

External Fragmentation: This happens when free memory is split into small,
scattered blocks that are not usable for larger processes. Even if there is enough
total free memory, the non-contiguous nature prevents allocation for processes that
require larger contiguous blocks.

Minimizing Fragmentation:
Segmentation: This memory management scheme divides memory into segments based on
logical divisions (e.g., functions, arrays). By using segments, internal
fragmentation is reduced as memory allocation can be more closely aligned with the
actual size of data structures.

Paging: This method breaks physical memory into fixed-size pages and divides
logical memory into pages of the same size. Paging eliminates external
fragmentation, as any free page can be used regardless of its location.

Compaction: This technique involves reorganizing memory contents to eliminate

external fragmentation. By moving processes closer together, larger contiguous free
blocks can be created.

Buddy System: This approach allocates memory in powers of two, which helps reduce
internal fragmentation and allows for efficient merging of free blocks.

Q. (2) What are demand paging and Demand Segmentation?

Demand Paging and Demand Segmentation are memory management techniques used in
operating systems to optimize the use of physical memory while managing large
processes efficiently.

Demand Paging:
Demand Paging is a memory management scheme where pages of a process are loaded
into memory only when they are needed (i.e., when a page fault occurs). This allows
the operating system to keep physical memory usage low by loading only those pages
that are actively used, rather than the entire process. When a process tries to
access a page that is not currently in memory, a page fault is triggered, and the
required page is loaded from secondary storage (usually a disk) into physical
memory. This approach helps in utilizing memory more efficiently and reduces
loading time, as it only loads necessary pages, leading to improved performance for
large applications.

Demand Segmentation:
Demand Segmentation operates similarly but is based on logical segments rather than
fixed-size pages. In this method, segments of a process (e.g., functions, arrays,
or data structures) are loaded into memory only when required. Each segment can be
of varying sizes, and when a segment fault occurs (when a segment is not in
memory), the operating system loads the needed segment from disk to memory. Demand
segmentation provides a more logical view of memory allocation and can improve the
organization of processes, as it allows for loading only the required segments.

Q.(3) Give difference between physical & logical address. Also show that how
logical

Physical Address vs. Logical Address

In computer systems, understanding the distinction between physical and logical

addresses is essential for memory management and addressing mechanisms.

Physical Address:
Definition: A physical address refers to an actual location in the computer’s
physical memory (RAM). It is the address that the memory unit recognizes and uses
to access data.
Context: Physical addresses are used by the memory management unit (MMU) to access
the memory hardware directly.
Example: If the physical memory has a size of 4 GB, addresses range from 0x00000000
to 0xFFFFFFFF.
Logical Address:
Definition: A logical address, also known as a virtual address, is generated by the
CPU during program execution. It represents an address within a process's logical
address space, which may not correspond directly to a physical memory address.
Context: Logical addresses allow processes to use memory without knowing the actual
physical address. This abstraction enables easier memory allocation and process
isolation.
Example: In a system with virtual memory, a process might use a logical address of
0x00001234, which the MMU translates into a physical address.
Translation from Logical to Physical Address:
The translation from logical to physical addresses is managed by the MMU using a
page table in the case of paging systems. When a program accesses a logical
address, the MMU checks the page table to find the corresponding physical address.
For example, if a logical address maps to a page frame in physical memory, the MMU
retrieves the data from the physical address.

Assignment IV

Q.(1) How would you compare different types of disk scheduling algorithm.

Disk scheduling algorithms are essential for managing how read and write requests
are handled on a disk, optimizing performance and minimizing wait times. Here’s a
comparison of several common disk scheduling algorithms:

1. First-Come, First-Served (FCFS):

Description: Requests are processed in the order they arrive.
Pros: Simple to implement; fair as it treats all requests equally.
Cons: Can lead to high average waiting time, especially with a long queue.
2. Shortest Seek Time First (SSTF):
Description: The disk arm moves to the nearest request first.
Pros: Reduces average seek time compared to FCFS; more efficient in servicing
requests.
Cons: Can cause starvation for requests far from the current head position.
3. SCAN (Elevator Algorithm):
Description: The disk arm moves in one direction, servicing requests until it
reaches the end, then reverses direction.
Pros: Provides a more even wait time and reduces starvation compared to SSTF.
Cons: Still has longer wait times for requests at the extreme ends.
4. C-SCAN (Circular SCAN):
Description: Similar to SCAN but returns to the beginning after reaching the end.
Pros: Offers a more uniform wait time; treats all requests equally by servicing
them in a circular manner.
Cons: Can result in longer wait times for requests at the start and end.

Q. (2) Can you explain different attributes of a file system.

A file system is a crucial component of an operating system, managing how data is

stored, organized, and accessed on storage devices. Here are the key attributes of
a file system:

1. File Naming:
Description: Each file in a file system has a unique name that can include various
characters, depending on the file system's rules.
Significance: Allows users to easily identify and access files.
2. File Structure:
Description: Refers to how data is organized within a file, which can vary (e.g.,
plain text, binary, or structured formats like JSON).
Significance: Impacts how data is read, written, and processed by applications.
3. File Permissions:
Description: Defines who can read, write, or execute a file. Permissions can be set
for different user roles (owner, group, others).
Significance: Ensures security and access control over files.
4. File Types:
Description: Files can be categorized by type (e.g., text, image, executable) and
are often identified by their extensions (e.g., .txt, .jpg).
Significance: Helps the operating system determine how to handle and execute files.
5. File Metadata:
Description: Additional information about files, including size, creation date,
modification date, and access time.
Significance: Useful for managing files and optimizing performance, as well as for
backup and recovery purposes.
6. Directory Structure:
Description: Organizes files into directories (or folders), allowing for
hierarchical storage and easy navigation.
Significance: Enhances user experience by providing a logical way to access files.

Assignment V

Q.(1) What is the need of synchronization in distributed operating

system .Explain the
working of any one clock synchronization algorithm.

In a distributed operating system, multiple independent processes run on different

machines but may need to coordinate with each other to ensure data consistency and
correctness. Synchronization is crucial for the following reasons:

Consistency: Ensures that all nodes have a consistent view of shared data,
preventing conflicts and anomalies.
Coordination: Allows processes to communicate effectively, especially when they
rely on the same resources or data.
Order of Operations: Guarantees that operations occur in a defined order, which is
vital for processes that depend on the outcomes of others.
Clock Synchronization Algorithm: Berkeley Algorithm
One widely used algorithm for clock synchronization in distributed systems is the
Berkeley Algorithm. Here’s how it works:

Coordinator Election: One process is designated as the coordinator, responsible for

synchronizing the clocks of other processes.

Time Request: The coordinator periodically polls all other processes to request
their local clock times.

Time Collection: Each process responds with its current time. The coordinator
collects these timestamps.

Calculate Average Time: The coordinator computes the average time based on the
received timestamps. It may discard extreme values to reduce the impact of
outliers.

Time Adjustment: The coordinator sends messages back to each process with the
difference between the average time and the process's local time. Each process then
adjusts its clock accordingly.

Q.(2) How would you compare Network, Distributed & Multiprocessor Operating
System.

Network Operating Systems (NOS), Distributed Operating Systems (DOS), and

Multiprocessor Operating Systems (MPOS) are three distinct types of operating
systems designed to manage resources and processes in different computing
environments. Here’s a comparison of these systems:

1. Network Operating System (NOS):

Definition: NOS manages a network of computers, allowing them to communicate and
share resources (like printers and files) over a local area network (LAN).
Architecture: Each computer operates independently but connects to a central server
for resource management.
Examples: Windows Server, Novell NetWare.
Key Features: Focus on file sharing, user management, and network security; minimal
interaction among systems.
2. Distributed Operating System (DOS):
Definition: DOS manages a group of independent computers that appear to users as a
single coherent system.
Architecture: Resources are shared transparently across the network, with processes
running on different machines as if they are part of a single system.
Examples: Google’s Spanner, Apache Hadoop.
Key Features: Enhanced resource sharing, load balancing, and fault tolerance;
designed for seamless communication and coordination.
3. Multiprocessor Operating System (MPOS):
Definition: MPOS is designed for systems with multiple processors that share a
common memory space.
Architecture: All processors work on a shared task, utilizing shared memory and
resources for efficient computation.
Examples: Linux, Windows NT.
Key Features: Focus on process synchronization, scheduling, and resource management
for multiple CPUs; provides high performance for computationally intensive tasks.