Operating Systems: Processes, Threads, and CPU Scheduling

Comprehensive vocabulary flashcards covering process concepts, state transitions, PCB, scheduling queues, interprocess communication, multithreading models, and CPU scheduling algorithms.

Process

A program under execution whose current activity is represented by the program counter and CPU registers.

Stack

The section of process memory used to store temporary data, including local variables, function parameters, return addresses, and function return values; it grows downwards towards the heap.

Heap

The memory section used for dynamic memory allocation during process runtime; it grows upwards towards the stack.

Data Section

The part of process memory that contains global and static variables.

Text Section

The part of process memory comprising the compiled program code, located at the lowest address base ($0$).

Process in Memory Structure

The structural layout of a process in memory consisting of the text section at address $0$, followed by data, dynamic heap growing upwards, and stack growing downwards from maximum address space.

New State

The state when a process is in the stage of being created.

Ready State

The state where a process has all resources it needs to run and is waiting in memory to be assigned to the processor.

Running State

The state in which process instructions are actively being executed by the CPU.

Waiting State

The state where a process is waiting for an event to occur, such as keyboard input, disk access, inter-process messages, or timer expiration.

Terminated State

The state reached when a process has completed its execution.

Process State Diagram

A state machine illustrating the transitions between the five process states: new, ready, running, waiting, and terminated.

Process Control Block (PCB)

A data structure storing all information specific to a process, including process state, program counter, CPU registers, scheduling parameters, memory limits, accounting data, and I/O status.

Job Queue

A queue that stores all processes admitted to the computer system.

Ready Queue

A queue of processes residing in main memory that are ready and waiting to execute on the CPU, typically maintained as a linked list of PCBs.

Device Queue

A queue containing processes that are waiting for a specific I/O device to become available.

Ready Queue and I/O Device Queues

Linked-list structures maintained with header head and tail pointers that point to PCBs waiting for the CPU or specific device units.

Long-Term Scheduler (Job Scheduler)

A scheduler that selects jobs from the secondary memory job pool on disk and loads them into main memory, controlling the degree of multiprogramming.

Short-Term Scheduler (CPU Scheduler)

A scheduler that frequently selects a process from main memory that is ready to execute and allocates the CPU to it.

Medium-Term Scheduler

A scheduler used in time-sharing systems that swaps processes out of memory to disk to reduce the degree of multiprogramming and swaps them back in when system load decreases.

I/O-Bound Process

A process that spends more time performing I/O operations than computations, generating many short CPU bursts.

CPU-Bound Process

A process that spends more time executing calculations than doing I/O operations, generating few, long CPU bursts.

Degree of Multiprogramming

The number of processes currently present in main memory.

Context Switch

The operating system mechanism of saving the CPU register state of the currently running process into its PCB and restoring the state of another process from its PCB.

fork() System Call

A UNIX system call that creates a duplicate child process, returning the child PID to the parent process, $0$ to the child process, and $-1$ upon failure.

Cascading Termination

The automatic termination of all child and descendant processes by the operating system when the parent process exits.

Zombie Process

A process that has finished execution via exit() but remains in the process table because its parent has not yet called wait().

Orphan Process

A process whose parent terminated without waiting; it is subsequently adopted by the init process (PID $1$) which periodically reaps it.

Shared Memory System

An interprocess communication model where communicating processes share a mapped memory segment within their address spaces to read and write large blocks of data without kernel system calls after setup.

Message Passing System

An interprocess communication model where processes exchange information by sending and receiving messages through operating system kernel primitives.

Direct Communication

A message-passing mechanism where the sender and receiver processes must explicitly name each other to communicate (e.g., send(P, message)).

Indirect Communication

A message-passing mechanism where messages are dispatched to and retrieved from shared mailboxes or ports that possess unique IDs.

Blocking Send

A synchronous communication operation where the sender process waits until the message is received by the destination process or mailbox.

Non-blocking Send

An asynchronous communication operation where the sender transmits the message and immediately continues execution without waiting.

Thread

The basic unit of CPU utilization, comprising a thread ID, program counter, register set, and a stack, sharing address space and open files with other threads in the process.

Many-to-One Model

A multithreading model where many user-level threads map to a single kernel thread, causing the entire process to block if one thread executes a blocking system call.

One-to-One Model

A multithreading model where each user thread maps to a dedicated kernel thread, allowing concurrent execution across multiple CPUs but introducing higher thread-creation overhead.

Many-to-Many Model

A multithreading model that multiplexes many user threads onto an equal or smaller number of kernel threads, balancing developer flexibility with kernel efficiency.

Lightweight Process (LWP)

An intermediate structure between user and kernel threads in many-to-many systems that acts as a virtual processor upon which user-thread libraries schedule threads.

Thread-Local Storage (TLS)

Data storage allocated such that each individual thread within a process maintains its own unique instance of variables across function calls.

Upcall

A notification sent by the operating system kernel to the user thread library to inform it that a specific thread is about to block or is ready to run.

CPU-I/O Burst Cycle

The recurring pattern in program execution consisting of cycles of CPU processing (CPU burst) followed by periods of waiting for input/output completion (I/O burst).

Non-Preemptive Scheduling

A scheduling scheme where a process keeps control of the CPU until it explicitly yields it by either terminating or entering the waiting state.

Preemptive Scheduling

A scheduling scheme where the operating system can forcibly take the CPU away from an executing process and reassign it to another process.

Dispatcher

The operating system module responsible for transferring control of the CPU to the process selected by the short-term scheduler through context switching, mode switching, and program restarting.

Dispatch Latency

The amount of time taken by the dispatcher to stop one process and start executing another.

CPU Utilization

The percentage of time that the CPU is actively performing work, typically ranging from $40\%$ to $90\%$ in real operating systems.

Throughput

A scheduling criterion measuring the total number of processes completed per unit of time.

Turnaround Time

The entire interval from process submission to process completion, calculated as the sum of periods spent waiting in queues, executing on the CPU, and performing I/O.

Waiting Time

The total cumulative time a process spends sitting in the ready queue waiting to be assigned CPU time.

Response Time

The duration of time from the submission of a request until the very first response is produced.

Convoy Effect

An inefficiency in FCFS scheduling where multiple short processes wait behind one long CPU-bound process, depressing overall CPU and I/O device utilization.

Shortest-Job-First (SJF) Scheduling

An optimal scheduling algorithm that allocates the CPU to the process with the shortest next CPU burst length to produce the minimum average waiting time.

Starvation

A situation in priority scheduling where low-priority processes remain blocked indefinitely because high-priority processes continually arrive and seize the CPU.

Aging

A technique used to prevent starvation by gradually incrementing the priority of processes that wait in the ready queue for extended periods.

Round-Robin (RR) Scheduling

A preemptive scheduling algorithm that assigns each ready process a fixed time quantum ($10$ to $100\,\text{ms}$) in circular FIFO queue order.

Multilevel Queue Scheduling

A scheduling algorithm that partitions the ready queue into multiple distinct queues permanently assigned to specific process types, each with its own scheduling algorithm.

Multilevel Feedback-Queue Scheduling

A dynamic queue scheduling method that allows processes to move between priority queues based on CPU burst history, demoting long bursts and aging long-waiting jobs.