Operating Systems - 2

Waiting time specifically refers to the cumulative time a process spends in the ready queue waiting for CPU allocation or other resources to become available. It's distinct from turnaround time (total time from submission to completion) and throughput (amount of work completed per unit time).

Turnaround time measures the total time from when a program is submitted until it completes, including all waiting periods, execution time, and I/O operations. The formula is Turnaround Time = Completion Time - Arrival Time.

Processor utilisation is the ratio of busy time to total time, expressed as a fraction or percentage. It measures how efficiently the CPU is being used - the higher the utilisation, the more productive the system.

The short-term scheduler (also called CPU scheduler) is responsible for allocating the CPU to processes that are ready to run. It makes decisions frequently - typically every few milliseconds - selecting which process from the ready queue gets to execute next.

Throughput measures the amount of work completed in a given time period - the number of processes completed per unit time. Higher throughput means more work is getting done, indicating better system performance.

Swapping is the process of moving a suspended process from main memory to secondary storage (disk) and back. This allows the system to free up memory for other processes when RAM is limited.

The medium-term scheduler handles swapping - it decides which processes to swap out of memory and which to swap back in. It manages the degree of multiprogramming by moving processes between main memory and secondary storage.

Operating systems have three types of schedulers: long-term (job scheduler) admits processes, medium-term (memory scheduler) handles swapping, and short-term (CPU scheduler) allocates the CPU to ready processes.

The long-term scheduler (job scheduler) works with the batch queue to select which processes to admit into the system. It controls the degree of multiprogramming by deciding when the system should accept new processes.

A thread is a lightweight process within a program - it shares the same resources (code, data, files) with other threads but has its own program counter, stack, and registers. Threads enable parallel execution within a single process.

The scheduler is the OS module responsible for selecting which process gets to run next. It manages process allocation, decides job admission, and ensures efficient CPU and resource utilisation.

A mode switch occurs when transitioning from user mode to kernel mode (or vice versa). This happens during system calls, interrupts, or exceptions - the process changes privilege levels but remains the same process.

In multi-programming systems, the terms 'task switch' and 'process switch' are used interchangeably to describe the operation of saving the state of one memory-resident process and restoring another. Both terms correctly identify this fundamental context-switching operation.

The ready list (also called the ready queue) is the operating system data structure that holds the Process Control Blocks (PCBs) of all processes that are ready to execute. These processes have all required resources except the CPU and are waiting for processor time.

Both 'process descriptor' and 'process control block' are valid terms for the data structure that contains all information about a process. PCB is the more common textbook term, while 'process descriptor' is used in some systems like UNIX. They represent the same concept.

A suspended process is one that has been swapped out of main memory to secondary storage (typically disk). While suspended, the process lacks memory and other resources but remains in the system. It can be resumed later by being swapped back into memory.

The global system state represents the complete snapshot of all processes and all system resources at a given moment. This includes the state of every process (running, ready, blocked, suspended) and the allocation/status of all resources (memory, I/O devices, files).

A running process is one that is currently executing on the processor. It has been allocated all necessary resources including the CPU, memory, I/O devices, and required files. The running state is when the process instructions are actively being executed.

A ready process has all required resources allocated (memory, files, I/O permissions) except the processor. It is waiting in the ready queue for CPU time. Once the scheduler assigns it the processor, it transitions to the running state.

A dormant process is not known to the operating system; it has not been created yet or has been terminated. Dormant processes exist only as potential programs on disk without an active PCB. The OS only tracks processes that have been created and admitted to the system.

In explicit tasking, programmers manually create and configure processes using system calls. The developer specifies process attributes such as priority, memory requirements, and scheduling parameters. This provides fine-grained control but requires more programming effort.

Processes have attributes such as priority, state (running, ready, blocked), PID, memory allocation, and resource holdings. These attributes are stored in the Process Control Block (PCB) and enable the OS to schedule, manage, and control process execution.

Process priority levels are software-defined values set by the OS or applications. They are not hardware or firmware settings. Software priorities determine scheduling order; higher priority processes get CPU time before lower priority ones. Priority levels are part of the scheduler's software algorithm.

In implicit tasking, the operating system automatically defines and manages processes without explicit programmer control. The system determines process creation, termination, and attributes based on runtime conditions and system policies. This reduces programming burden but offers less control.

Response time measures how quickly a system responds to user input - specifically from when you finish entering a command until the first output appears. It differs from turnaround time (total time from submission to completion), throughput (tasks completed per time unit), and waiting time (time spent in ready queue).