Operating Systems Overview

A mechanism that hides the complexity of lower-level hardware and software from applications, making them easier to use and develop.

The ability to perform multiple tasks seemingly at the same time by efficiently switching between them. This makes better use of system resources.

The ratio of logical data blocks (how the data is organized for the user) to physical data blocks (how the data is actually stored on the disk).

A technique where a program breaks down its work into multiple threads, allowing it to handle multiple tasks simultaneously.

The set of physical memory pages currently being used by a running process.

A technique where a process repeatedly checks if a condition is met, even if it's not necessary. Less efficient than other methods when not needed.

A variable that is only accessible within a particular function or block of code. It doesn't affect the program's overall state.

A specific sequence of steps executed when a process returns from a system call or interrupt to user space. It checks if the process is allowed to continue.

A scheduling metric is a measured property of a task that results from applying scheduling policies. It reflects the effect of the scheduling decisions on that task.

The phenomenon where a high-priority process gets blocked by a lower-priority process because both share a resource that is currently held by the lower-priority process.

A locking mechanism that allows only one process to access a shared resource at a time, and it does not use any explicit wait queues. Processes keep checking the lock until it is available.

The probability that a system is operational and performs its intended functions correctly.

The issue that occurs when multiple concurrent programs interact in a way that leads to incorrect behavior. One program's action may invalidate the assumptions made by another program.

A mechanism that allows processes to wait for a condition to become true before proceeding.

The sequence of steps involved when a process makes a request to the operating system to perform an action.

The time taken to process a task from its arrival until it is completed.

A part of a device driver that handles the immediate response to an interrupt. It quickly re-enables interrupts, saves critical state information, and removes volatile data from the interrupting device.

A part of a device driver that performs the full processing of an interrupt after the initial response. It handles tasks such as processing data, returning from the interrupt, and managing processes waiting for data.

A technique that increases storage performance by distributing data across multiple physical disks. This allows for simultaneous access to different parts of the data, speeding up operations.

A technique that improves data reliability by creating a complete copy of the data on a separate physical disk. If one disk fails, the data can be recovered from the backup.

A situation where multiple processes or threads are waiting for each other to release resources, leading to a standstill. This occurs when there are cycles in the dependencies between processes and the resources they need.

One process or thread unknowingly modifies the state of another process or thread, potentially leading to incorrect behavior. This occurs when processes make assumptions about the state of shared resources.

An assignment operation is considered atomic if it is guaranteed to happen as a single indivisible operation, meaning it completes entirely without interruption. This is usually achieved by disabling interrupts during the assignment.

The concept of fairness in concurrent systems ensures that all processes or threads have a reasonable chance of being executed and making progress. This means no single process should be starved or indefinitely delayed.

The operating system saves the state of the current process, including its registers, program counter, and any open files, and then loads the state of the next process. This allows the system to seamlessly switch between multiple programs running concurrently.

This model maps multiple user threads to a single kernel thread. This means that multiple user threads are managed by one kernel thread, which can result in performance limitations when execution occurs on a single processor.

A block I/O device accesses data in fixed-size blocks, while a stream I/O device allows continuous data flow.

Direct Memory Access (DMA) allows the CPU to delegate memory transfers directly to a peripheral device without needing the CPU's constant involvement.

If a process waiting for input is swapped out, it can corrupt the memory space of another process being loaded into its place. This can cause unpredictable behavior and data corruption.

The logical memory space assigned to a process, isolated and virtual. It provides a process with its own view of memory, independent of other processes.

The actual physical memory available in the system. It's shared by all processes and is the physical space where data is stored.

A signal sent from hardware or software to the CPU. It interrupts the CPU's current task to handle an urgent event.

The CPU saves the state of the current process, executes the corresponding interrupt service routine (ISR), and then restores the previous state to resume execution. This allows the CPU to handle the event without disrupting the main workflow.

A problem caused by storing small files in fixed-sized blocks. Unused space within these blocks leads to wasted storage.

Using inode structures with varying block sizes to store small files more efficiently. This helps reduce wasted space by optimally allocating storage for them.

Communication channels between processes. Examples include pipes and sockets.

Memory space reserved by the kernel. It's accessible by both processes involved in communication. Allows processes to share data directly.

A process is the basic unit of work in a computer system, representing a running program with its own resources and execution context.

An Operating System (OS) has two main modes: User Mode and Kernel Mode. Kernel Mode is where the OS runs with full privileges, while User Mode is where applications run with limited access to system resources.

System calls are requests from user programs to the OS to perform actions such as reading files or allocating memory. They are executed in Kernel Mode for greater control and security.

A web server should not run as a single-threaded process because it can only handle one request at a time. This leads to poor performance when multiple users are accessing the website.

The operating system kernel is the core program of an OS. It manages the hardware resources, handles system calls, and controls low-level operations.

A thread pool is a group of reusable threads that can execute tasks. This reduces the overhead of creating and destroying threads for each task, making the system more efficient.

A critical region is a section of code that accesses shared resources. It involves four steps: entry, critical section, exit, and remainder.

Device drivers are software programs that allow the OS to communicate with different hardware devices, even if they have different interfaces. This ensures compatibility and flexibility.