Operating Systems Quiz

Introduction to KTU Notes

• KTU Notes is a learning companion providing KTU study materials, syllabus, live notifications, and solved question papers.
• The website address is www.ktunotes.in.

Module II: Processes and Process Scheduling

• This module covers processes, process control blocks, threads, scheduling, operations on processes, process creation, termination, inter-process communication, shared memory systems, and message passing systems.
• Basic concepts of process scheduling including scheduling criteria and algorithms are included.
• Specific algorithms covered include First Come First Served (FCFS), Shortest Job First (SJF), Priority Scheduling, and Round Robin Scheduling.

Processes

• A process is a program in execution.
• It includes program counter values, register contents, and variables.
• Conceptually, each process has its own virtual CPU.
• In reality, the CPU rapidly switches between processes, a concept called multiprogramming.
• Batch systems execute jobs, while time-shared systems handle user programs or tasks.
• A process has a text section (program code), current activity (program counter and processor registers), a stack (for temporary data like function parameters), a data section (for global variables), and a heap (for dynamically allocated memory).

Process Concept (Continued)

• A program becomes a process when the executable file is loaded into memory.
• Processes can be created through GUI clicks, command-line entries, or other methods.
• Multiple instances of a single program can run concurrently as separate processes.
• The data, heap, and stack sections of a process vary even if the text sections are equivalent.

Process State

• Processes change states as they execute: new, running, waiting, ready, and terminated.
• A diagram illustrating process states and transitions is included.

Process Control Block (PCB)

• Each process is represented by a PCB (also called a task control block).
• The PCB contains process state, process number, program counter, registers, memory limits, and a list of open files.
• The PCB also holds CPU-scheduling information (priority, pointers to scheduling queues) and memory-management information (base and limit registers or page tables).
• Additional information includes I/O status (allocated I/O devices, open files), accounting information (CPU and real time used, job/process numbers), and so on.

Process Control Block (Context Switch)

• A diagram illustrates the context switch process, where the operating system saves the state of the running process into its PCB and loads the state of the next process to run.

Process Scheduling

• Multiprogramming aims for maximum CPU utilization.
• Time-sharing allows multiple users to interact with programs concurrently.
• The process scheduler selects an available process for CPU execution.
• Only one process can run at a time on a single-processor system.

Scheduling Queues

• Processes enter the system into a job queue.
• Ready processes reside in a ready queue.
• Other queues exist for different devices (e.g., I/O device queues).
• A diagram of scheduling queues and their interactions is provided.

Scheduling Queues (Events)

• A process in execution may issue an I/O request, create a new child process, or be interrupted requiring it to be returned to the ready queue.

Schedulers

• The operating system uses different schedulers:
  • Long-term scheduler (job scheduler): For batch systems; it selects processes from a pool and loads them into memory.
  • Short-term scheduler (CPU scheduler): Selects processes from the ready queue to run on the CPU.
  • Medium-term scheduler: Adds processes from memory to a swap area and back to memory, a technique called swapping.

Schedulers (Distinction)

• Short-term schedulers run more frequently than long-term schedulers.
• The CPU-bound processes may influence I/O-bound processes in a system.

Schedulers (I/O and CPU Bound)

• A process is either I/O-bound or CPU-bound.
• I/O-bound processes spend more time waiting for I/O, while CPU-bound processes use more CPU time.
• An appropriate mix of I/O-bound and CPU-bound processes leads to optimal system performance.

Medium-Term Scheduler

• The medium-term scheduler temporarily removes processes from memory (swapping).
• This creates space and allows other processes to run.

Context Switch

• When an interrupt occurs, the current process's context is saved, allowing the system to resume the process at a later time.
• The context includes CPU registers, process state, and memory-management information.
• Context switching is purely overhead.

Operations on Processes

• The operating system supports process creation and termination.

Process Creation

• A parent process creates child processes.
• A process tree illustrates the hierarchical relationship between processes.
• Each process has a unique process identifier (PID).
• Processes might share or not share resources (memory, files, etc.).

Process Termination

• A process ends by completing its final statement and using the exit() system call.
• The parent process can be notified of the child's exit status.
• The operating system deallocates the child's resources.

Process Termination-Cascading Termination

• Some systems require a child process to terminate when the parent terminates.

Process Termination-Zombie Process

• A terminated process whose parent hasn't yet received its exit status remains in the process table as a zombie process.

Process Termination-Orphans

• Orphans are child processes whose parent terminates without calling wait.
• The init process adopts orphans in Linux/UNIX systems.

Interprocess Communication

• Processes may be independent or cooperate.
• Independent processes are unaffected by each other; cooperating processes might share data.
• Mechanisms for cooperating processes include shared memory and message passing.

Shared-Memory Systems

• Shared memory allows processes to communicate by reading/writing to a common area of memory.
• The producer-consumer problem highlights the need for synchronization when multiple processes access shared resources.
• Two types of buffers for shared memory are unbounded and bounded.

Message-Passing Systems

• In message passing, processes communicate by exchanging messages.
• Two fundamental models for message passing: - direct and indirect.
• Message passing can be blocking or non-blocking, and buffering methods are used for communication.

CPU Scheduling

• The CPU scheduler selects a waiting process when the CPU is idle. This scheduler uses different scheduling algorithms.
• Common criteria include increasing CPU utilization, throughput, turnaround time, waiting time, and response time.

CPU Scheduling: Preemptive vs. Non-preemptive

• Preemptive scheduling allows interruption of running processes.
• Non-preemptive scheduling requires the process to release the CPU voluntarily.
• The dispatcher gives the CPU to the selected process. Specific scheduling algorithms exist for prioritizing processes, such as based on arrival time and burst time.

Scheduling Algorithms (FCFS)

• First-Come, First-Served (FCFS): Processes are executed in the order they arrive.
• FCFS can lead to the convoy effect if one long-running process blocks many shorter processes.

Scheduling Algorithms (SJF)

• Shortest Job First (SJF): The process with the shortest burst time is selected next.
• SJF can be either preemptive or non-preemptive.

Scheduling Algorithms (SRTF)

• Shortest Remaining Time First (SRTF) is a preemptive version of SJF.
• It prioritizes processes with the shortest remaining time.

Scheduling Algorithms (Priority)

• Priority scheduling gives higher priority to specific processes based on an assigned priority.
• Priority scheduling might lead to starvation of low-priority processes if they are consistently interrupted.

Scheduling Algorithms (Round Robin)

• Round Robin (RR): A time-slicing approach; each process gets a fixed time quantum.
• If a process's burst time is longer than q, it's moved to the end of the ready queue.

Threads

• A thread is a lightweight unit of execution within a process.
• Multiple threads within the same process share common resources (e.g., code, data, open files).
  • Context switching between threads is faster than between processes.

Test your knowledge on key concepts of operating systems, focusing on multiprogramming, process control blocks, and scheduling algorithms. This quiz covers essential topics that are fundamental for understanding OS behavior and performance. Challenge yourself with questions about process states, CPU usage, and prioritization in scheduling.