Operating Systems - General Concepts

A thread that is accessible only by the thread that created it. Other threads cannot access or modify its data.

A mechanism where multiple processes or threads can communicate by sending and receiving messages through a common queue. This allows for asynchronous communication and decoupling of senders and receivers.

A set of tasks is considered deadlocked when they are all waiting for each other to release a resource. None of the tasks can progress because they are all blocked.

A technique used in operating systems to temporarily store data in memory for faster access. Buffering allows data to be transferred between devices and applications without waiting for each other.

A set of rules for ensuring that only one thread can access a shared resource at a time, preventing data corruption and race conditions.

A method of communication where data is sent in a continuous stream without a defined message structure. Often used for multimedia and real-time applications.

A method of communication where data is sent in discrete messages with a defined structure. Often used for email and other message-based applications.

A mechanism for integrating input/output devices into the operating system by defining a standard interface that applications can use to interact with devices.

Tasks done by the device driver immediately after an interrupt, focusing on quick response and preparation for another interrupt.

Tasks performed by the device driver after the immediate response to an interrupt, handling data processing and informing the OS.

A situation where one process's assumptions about the state of shared resources are invalidated by actions of another process.

A method to improve performance by distributing data across multiple physical disks.

A method to enhance reliability by creating a full copy of the data on a separate disk.

A programming practice that ensures a single instruction modifying a shared variable completes without interruptions.

A deadlock avoidance rule that emphasizes preventing circular dependencies among processes waiting for shared resources.

A concept that refers to fairness in scheduling, ensuring that different processes or threads get a fair share of resources.

Replacing an unmodified page in memory with a new page avoids writing the old page to disk, saving time and resources.

Replacing a modified page is advisable when it's no longer needed and keeping it in memory provides no benefit. This frees up memory space for other pages.

Busy waiting is acceptable when the waiting time is extremely short, typically in synchronization between processors within critical sections. It's used when the processor has nothing else to do while waiting.

Memory-mapped I/O unifies memory and I/O addressing, simplifying programming, but it consumes address space.

Port-mapped I/O uses dedicated instructions for I/O operations, offering efficient use of instructions, but requires separate instructions for I/O, complicating programming.

Dynamic allocation reduces fragmentation by allocating memory as needed, while efficient utilization avoids predefined partition sizes, allowing flexible allocation.

Page size should be a power of two for efficient hardware implementation. A large page size minimizes page table size, but increases internal fragmentation. A small page size reduces internal fragmentation but increases page table size.

Scheduling determines how tasks are allocated to resources according to policies for competing tasks. A schedule maps tasks to resources at specific times.

The portion of memory allocated to a process, providing a logical view of memory that's isolated and virtual.

The actual physical memory available in the system, shared by all running processes.

A signal sent from hardware or software to the CPU, temporarily halting the current process to handle a specific event.

The interrupt handling process involves saving the current state, executing the interrupt service routine (ISR) - a specific code for the event, and then restoring the previous state to resume execution.

When small files are stored in a file system, they often lead to internal fragmentation, wasting storage space due to unused space in fixed-sized blocks.

Using inode structures with direct, indirect, and small block sizes to efficiently store smaller files, optimizing storage space.

The process of making decisions about which process to execute next, based on factors like priority and available resources.

A process that allows communication between different processes by providing a shared memory space accessible to both. This facilitates data exchange.

Each process has its own unique memory address space, preventing interference between processes.

DMA allows the processor to perform other tasks while data is being transferred between memory and I/O devices, improving efficiency.

A context switch involves saving the executing process's state (registers, PC, files, I/O status) in its Process Control Block (PCB) and loading the state of another process.

Stream I/O devices provide a continuous flow of data, such as keyboard input, mouse movements, sensor readings, and actuator commands. Block I/O devices transfer data in fixed-size blocks, like hard drives, SSDs, tapes, and USB sticks.

Swapping out a process waiting for input can corrupt the memory address space of another process loaded in its place, as unexpected data changes may occur.

The system call interface is the lowest level of abstraction for interacting with the operating system, translating high-level API requests into low-level OS instructions.

Memory-mapped I/O allows access to device registers as if they were memory locations. Port-mapped I/O uses specific I/O instructions to access registers directly.

A process control block (PCB) maintains vital information about a running process. This includes the process's current state, memory allocation, and resource usage.

A context switch involves saving the state of the currently running process and restoring the state of the next process scheduled to run.

Logical I/O provides an abstract view of devices, allowing applications to interact with files and streams without worrying about specific hardware.

Device I/O manages low-level interactions with hardware devices through drivers, handling communication and data transfer.

An interrupt is a signal from a device to the CPU, requesting attention. The CPU then transfers control to an interrupt service routine (ISR) to handle the interrupt.

APIs provide portability, ensuring code can run on different operating systems with minimal changes. APIs also simplify application development by abstracting complex system calls.