OS

~ Tushar Bhanushali

1. Define the essential properties of the following types of operating

systems: Batch system, Time-sharing, Real-time, Distributed OS

Batch System: A Batch System collects and processes a batch of jobs at once without user

interaction. It is efficient for repetitive tasks and makes good use of system resources. Job

scheduling is based on priority or other criteria, and there is no real-time interaction with

users.

Time-Sharing System: A Time-Sharing System allows multiple users to use the system

simultaneously by allocating small time slices to each user. This ensures fair resource

allocation and real-time interaction with the system. It is designed to support multi-user

environments, providing each user with a responsive experience.

Real-Time System: A Real-Time System processes data immediately as it comes in,

guaranteeing a response within a strict time limit. It must be highly reliable and consistent,

making it suitable for critical applications like medical systems and industrial control where

timely and accurate processing is crucial.

Distributed OS: A Distributed Operating System manages multiple computers as a single

cohesive system. It allows for resource sharing across different machines and supports

parallel processing to enhance performance. Additionally, it provides fault tolerance,

meaning that failures of individual machines do not affect the overall system operation.
2. What is a thread? What are the differences between user-level threads

and kernel-supported threads?

A thread is the smallest unit of processing that can be performed in an

operating system. It is a sequence of programmed instructions that can be

managed independently by a scheduler. Here are some key points about

threads:

● Lightweight: Threads are lighter than processes, meaning they

consume fewer resources.

● Shared Resources: Threads within the same process share the same

memory and resources, which allows for efficient communication

and data sharing.

● Concurrency: Threads enable concurrent execution within a single

process, improving the application’s responsiveness and

performance.

● Independent Execution: Each thread runs independently but can

interact with other threads in the same process.

● Multithreading: This is the ability of a CPU or an operating system to

execute multiple threads simultaneously, allowing for better

utilization of system resources.

3. Thread Life Cycle

● New State: A thread is in the new state after it's created but before

`start()` is called. Its code is ready to run but hasn't started execution.
 ● Runnable State: Once `start()` is called, the thread enters the

runnable state. It can execute if the scheduler assigns CPU time or

waits in a queue for its turn.

● Blocked State: A thread enters the blocked state when it waits for a

lock to enter a synchronized block or method. It stays here until the

lock is available, then moves back to runnable.

● Waiting State: Threads enter this state when they call `wait()`, `join()`,

or `sleep()` without a timeout. They remain here until another thread

notifies them or the condition they are waiting for is met.

● Timed Waiting State: Threads enter timed waiting when they call

methods like `sleep(timeout)` or `wait(timeout)`. They stay here for a

specified period or until they receive a notification, then move back

to runnable.

● Terminated State: A thread enters the terminated state when its

`run()` method completes normally or due to an unhandled

exception. Once terminated, it cannot be restarted or run again.

4. What is a process? Give the difference between a process and a

program.

In operating systems, a process is a running instance of a program. It

includes the program code, current activity (execution state), and a set of

resources allocated by the operating system (like memory, CPU time, etc.).

A process is the dynamic execution of a program.

5. Process Life Cycle

1. Creation: A process is created either by a user request or by another

process. This involves allocating memory and resources.

2. Ready: The process is ready to run and waits in a queue for the CPU to

start executing its instructions.

 3. Running: The CPU executes the process instructions. During this phase,

the process actively uses CPU resources.

4. Blocked (Wait): The process may need to wait for an event (like user input

or data from a disk), causing it to temporarily stop executing and enter a

blocked state.

5. Termination: The process finishes executing either by completing its

tasks or being terminated by the operating system. Resources used by the

process are released.

6. Explain process control block.

A Process Control Block (PCB) is a data structure that is used by an

Operating System to manage and regulate how processes are carried out.

In operating systems, managing the process and scheduling them properly

play the most significant role in the efficient usage of memory and other

system resources. In the process control block, all the details regarding the

process corresponding to it like its current status, its program counter, its

memory use, its open files, and details about CPU scheduling are stored.
 With the creation of a process, a PCB is created which controls how that

process is being carried out. The PCB is created with the aim of helping the

OS to manage the enormous amounts of tasks that are being carried out in

the system. PCB is helpful in doing that as it helps the OS to actively

monitor the process and redirect system resources to each process

accordingly. The OS creates a PCB for every process which is created, and it

contains all the important information about the process. All this

information is afterward used by the OS to manage processes and run

them efficiently.

7. What is a semaphore? Give the implementation of the Readers-Writers

problem using semaphores.

In computer science, a semaphore is a synchronization primitive used to

control access to shared resources by multiple processes or threads in a

concurrent environment. It acts like a flag or counter that regulates access

to prevent race conditions and ensure data integrity.

Key Operations:

● Wait (P): This operation attempts to acquire the semaphore. If the

semaphore's value is greater than zero, it decrements the value and
allows the process to proceed. If the value is zero, the process is
blocked until the semaphore becomes available.

● Signal (V): This operation releases the semaphore. It increments the

semaphore's value, potentially allowing a blocked process waiting
with wait to proceed.
 Readers-Writers Problem with Semaphores

This is a classic synchronization problem where multiple readers and a

single writer need controlled access to a shared data structure. The
challenge is to ensure:

● Mutual exclusion: Only one writer can access the data at a time (no
simultaneous reads and writes).
● Reader preference: If multiple readers are waiting and no writer is
accessing the data, readers shouldn't be blocked unnecessarily.

8. Define the difference between preemptive and nonpreemptive

scheduling.
9. Explain the Priority scheduling algorithm.
10. What is a deadlock? Explain deadlock prevention in detail.

A deadlock in operating systems occurs when two or more processes are

unable to proceed because each is waiting for a resource held by the

other(s). This results in a situation where no progress can be made.

11. How does deadlock avoidance differ from deadlock prevention? Write

about deadlock avoidance algorithms in detail.

● Deadlock Prevention: Stop deadlocks by setting strict rules on how processes can

request and use resources. Processes must follow rules like asking for all resources

at once and not taking resources from others. Guarantees no deadlocks, but can be

rigid and waste resources.

● Deadlock Avoidance: Avoid deadlocks by predicting if giving a resource will cause a

deadlock. Uses smart algorithms to decide if giving a resource is safe based on the

current state of the system. Allows more flexibility in resource use but needs clever

algorithms to work well

Deadlock Avoidance Algorithms :

12. Differentiate between external fragmentation and internal

fragmentation.

[Link] the best fit, first fit, and worst fit algorithm.
[Link] virtual memory.

[Link] the concept of virtual machines. Benefits of virtual machines.

[Link] virtual machines and non-virtual machines.
[Link] the difference between security and protection.

[Link] is access control? Explain access control lists.

● Access Control in Operating Systems: Access control is a security

mechanism in operating systems that regulates which users or

processes can access resources and what actions they can perform

on them. It ensures that only authorized entities can access sensitive

information or perform privileged operations, thereby protecting

system integrity and data confidentiality.

● Access Control List (ACL): An ACL is a specific implementation of

access control used in operating systems. It is a list attached to each

resource (such as a file or directory) that enumerates the users or

groups permitted to access the resource and specifies the actions

(read, write, execute) they can perform. ACLs provide fine-grained

control over resource access, allowing administrators to define

detailed permissions for different users and groups, thus enhancing

security and managing resource usage effectively.

------------------------------------------------------------------------------------------------------------------

[Link] are the allocation methods of disk space?

[Link] between CPU bounded and I/O bounded processes.

[Link] are pages and frames? What is the basic method of segmentation?
[Link] explain and compare fixed and dynamic memory partitioning

schemes.
[Link] is a monitor? Explain the solution for the producer-consumer

problem using a monitor.

[Link] the terms related to IPC: Race condition, Critical section, Mutual

exclusion, Semaphore
[Link] is “inode”? Explain file and directory management of Unix

Operating System.
[Link] disk arm scheduling algorithms.

Disk arm scheduling algorithms are a crucial part of operating systems,

specifically in managing disk access. They determine the order in which the

operating system serves read/write requests to different locations on a

disk. The goal is to minimize the total head movement (seek time) and

optimize disk access performance.

------------------------------------------------------------------------------------------------------------------

[Link] multi-threading. Explain its benefits.

Multi-threading is a programming technique where a single process can

have multiple threads of execution running independently. These threads

share the same memory space and can perform tasks concurrently,

allowing for efficient use of resources and improved program performance.

[Link] are the components of Linux systems?
[Link] a short note on the Unix kernel.
[Link] a Linux script to find out all prime numbers between a given

range
[Link] any four functions of an operating system.

[Link] of the following UNIX commands: grep, cat, cmp, wc, diff.