Operating Systems Practice Flashcards

Comprehensive vocabulary flashcards covering basic system organization, protection, processes, scheduling, memory management, I/O, and the Linux case study.

Operating system

Software that controls and coordinates the use of hardware resources among various application programs for various users.

Fetch-Execute Cycle

The cycle where the CPU repeatedly fetches and decodes the next instruction, generating control signals and operand information.

Arithmetic Logic Unit (ALU)

A functional unit inside the Execution Unit that reads registers, performs operations, and writes results back.

Bus

Shared communication wires used to transfer information between the CPU, memory, and devices.

Bootstrap program

A bootloader, traditionally stored in ROM as BIOS or now UEFI, that initializes the system and loads the kernel when the machine is powered on.

Interrupt vector

A table containing the addresses of all the Interrupt Service Routines (ISRs) used to handle raised interrupts.

Trap (Exception)

A software-generated interrupt caused either by an error or a deliberate user request.

Word

A computer architecture's native unit of data, typically comprising one or more bytes, such as $64$-bit for a $64$-bit register architecture.

Kilobyte (kB)

A unit of storage equal to $1,024$ bytes ($2^{10}$ bytes).

Layering

A means to manage complexity by arranging components in a stack and restricting interactions to adjacent layers.

Multiplexing

A method where one resource is consumed by multiple consumers simultaneously.

Latency

A metric of system performance defined by how long a specific operation takes to complete.

Bandwidth

The rate at which operations or data transfers occur, also known as throughput.

Jitter

The variation or statistical dispersal in latency or frequency.

Caching

The use of a small amount of higher-performance storage to mask the performance impact of a lower-performance component.

Buffering

The introduction of memory between two components to soak up small, variable imbalances in bandwidth.

80/20 rule

A system concept stating that $80\%$ of time is typically spent in $20\%$ of the code.

Kernel

The core program of the operating system that always runs on the computer, providing mechanisms to implement policies.

Dual-mode operation

A hardware-supported method using a mode bit to distinguish between User mode and Kernel mode to protect the system from buggy or malicious code.

System Call

A standard interface to OS services, invoked via a trap, that transitions the CPU from user mode to kernel mode.

Microkernel

A kernel architecture that moves OS services into local servers and relies on message passing for communication.

Virtulization

A technology allowing multiple operating systems to run alongside each other above a hypervisor.

Principle of least privilege

A security principle stating that objects should be given just enough privileges to perform their tasks.

Access Control List (ACL)

An implementation of an access matrix organized by object, storing an ordered list of domains and their rights.

Capability

An implementation of an access matrix organized by domain, acting as a protected, unmodifiable secure pointer to an object and its permitted operations.

Salt

Data used in authentication to hash passwords, making them easy to compute but hard to invert.

Process

A program in execution; a dynamic unit of protection and resource allocation.

Process Control Block (PCB)

A data structure representing a process, containing its ID, state, program counter, registers, and memory management information.

Thread

An individual execution context within a process, sharing the process's address space but having its own stack and program counter.

Context switching

The process of saving the context of a currently executing process and restoring the context of a new process being resumed.

Zombie process

A process that has finished executing but whose parent has not yet waited for it to obtain its status.

Inter-Process Communication (IPC)

Mechanisms allowing processes to communicate and synchronize their actions, primarily through shared memory or message passing.

Signal

A simple form of IPC consisting of asynchronous notifications sent between processes.

CPU I/O Burst Cycle

The pattern of process execution that interleaves CPU execution with waiting for I/O.

Short-term scheduler

The CPU scheduler that selects which process from the ready queue should execute next and allocates the CPU to it.

Dispatcher

The module that gives control of the CPU to the process selected by the short-term scheduler, involving a context switch.

Pre-emptive scheduling

Scheduling where the OS can force a process to enter the scheduler via hardware-supported timer interrupts.

Symmetric multiprocessing (SMP)

A multiprocessing architecture where each processor is self-scheduling and all processes can inhabit a single ready queue.

Non-Uniform Memory Access (NUMA)

A system where different CPUs have varying access speeds to different parts of memory, affecting processor affinity.

First-Come First-Served (FCFS)

A scheduling algorithm where processes are executed in the order they arrive, which can lead to the 'convoy effect'.

Shortest Job First (SJF)

An optimal scheduling algorithm that selects the process with the shortest next CPU burst to minimize average waiting time.

Round Robin (RR)

A pre-emptive scheduling scheme where each process is given a fixed time slice (quantum) and returned to the ready queue if not finished.

Aging

A technique in priority scheduling where the priority of a process increases as it waits, used to prevent starvation.

Completely Fair Scheduler (CFS)

The Linux scheduler since version $2.6.23$ that allocates CPU weighting to tasks based on a 'vruntime' variable to ensure proportional fairness.

Memory Management Unit (MMU)

Hardware that maps logical (virtual) addresses to physical addresses at run time.

External Fragmentation

A condition where total free memory exists to satisfy a request, but it is not contiguous.

Internal Fragmentation

A condition where allocated memory is slightly larger than the requested amount, leaving unused space within a partition.

Paging

A memory management scheme that divides physical memory into frames and logical memory into pages to allow non-contiguous allocation.

Translation Lookaside Buffer (TLB)

A special hardware cache used to speed up the translation of logical page numbers to physical frame numbers.

Demand paging

A system where a page is only brought into memory when a reference is made to it, causing a page fault if it is non-resident.

Copy-on-Write (COW)

An optimization where parent and child processes initially share the same pages until one process modifies a page, at which point the page is copied.

Bélády’s Anomaly

The counter-intuitive phenomenon where increasing the number of physical frames results in more page faults, seen in FIFO replacement.

Thrashing

A state where a process spends more time handling page faults than executing instructions because it lacks enough page frames.

Direct Memory Access (DMA)

A technique allowing high-speed I/O devices to transfer blocks of data directly to or from main memory without continuous CPU intervention.

Vectored I/O

A scatter-gather method allowing a single system call to perform multiple I/O operations into multiple buffers.

Shortest Seek Time First (SSTF)

A disk scheduling algorithm that services the request with the shortest distance from the current head position.

Inode

A data structure in UNIX file systems that acts as a File Control Block, containing pointers to data blocks and file metadata.

Superblock

A filesystem component containing metadata such as total and free blocks and the start of free-block lists.

Mounting

The process of making a filesystem accessible by attaching it to a specific mount-point in the global directory tree.

Slab allocation

A kernel memory allocation method that uses a cache for frequently used objects to improve efficiency.

Virtual File System (VFS)

An abstraction layer in the Linux kernel that manages different file systems using common objects like inodes, files, and dentries.

Pipe

A method for passing information from one process to another in Unix-like systems, facilitating inter-process communication (IPC).

Named Pipe (FIFO)

A type of pipe that allows unrelated processes to communicate with each other by creating a special file in the filesystem known as a FIFO.

Anonymous Pipe

A type of pipe used for communication between related processes, such as a parent and child process, without requiring a name in the filesystem.

Pipe Buffer

A temporary storage area for data being transmitted through a pipe, allowing data to be read and written asynchronously.

Stream

A continuous flow of data that can be sent or received through pipes, sockets, or files, allowing processing of data in a sequential manner.

Blocking I/O

An input/output operation that halts the execution of a process until the operation is complete, often used in conjunction with pipes.

Non-blocking I/O

An input/output operation that allows a process to continue executing while the operation completes, often used in event-driven or asynchronous programming.