Operating Systems: Processes and Threads

Processes are instances of programs running in a computer system. They are dynamic entities, while programs are static collections of instructions. Processes are virtualized representations of the CPU, meaning they share the CPU's resources but have their own independent execution environment.

The Process Control Block (PCB) is a data structure that contains crucial information about a process, including its ID, memory space, state, and resources. It acts like a passport for each process, enabling the operating system to manage and track it effectively.

Threads are units of execution within a process. They are essentially lightweight processes that share the same memory space and resources as their parent process. This allows for concurrency and parallelism within a single program, making it more efficient.

Interrupts are signals from hardware or software components that interrupt the normal execution flow of the CPU to handle a specific event, such as an I/O request or an error condition. These signals allow the CPU to switch tasks and handle urgent events promptly.

A context switch is the process of saving the current state of one process and restoring the state of another process. This mechanism allows the CPU to switch between multiple running processes efficiently without losing their progress.

The property of a set of operations that guarantees either all operations complete successfully, or none of them do. This ensures consistency and reliability in multithreaded environments.

A mechanism that ensures only one thread can access a shared resource at a time, preventing data corruption caused by multiple threads modifying it concurrently.

A code segment where shared resources are accessed. It needs protection to ensure data integrity in multithreaded environments.

A type of lock where a thread continuously checks a flag until it becomes available, consuming CPU cycles while waiting.

A mechanism that allows threads to wait for specific conditions to become true before proceeding, improving synchronization and resource management.

A synchronization primitive that uses a counter to control access to shared resources, allowing a specified number of threads to enter a critical section at any given time.

A memory management technique that divides logical memory into fixed-size units (pages) and physical memory into frames. It allows for non-contiguous memory allocation and virtual memory.

A cache that stores recently used page table entries to speed up address translation, reducing the number of accesses to the slower main memory.

mmap() is a function that maps a file or device into the process's virtual memory, providing a direct way to access file data without using explicit read and write system calls. This can boost performance by minimizing system overheads.

Shell redirection allows you to redirect the input or output of a command to a file or another command. This uses special symbols like <, >, >>, and | to change the flow of data.

Pipes are used for interprocess communication, allowing data to flow from the output of one process to the input of another. This enables chaining commands together, with each process passing data to the next.

File descriptors are numerical identifiers that represent open files within a process. They are used to reference files for I/O operations. Each process maintains a file descriptor table (part of the process table) mapping these descriptors to file table entries.

Low-level APIs provide basic functions like reading/writing blocks of data directly, while high-level APIs offer user-friendly operations like creating files, directories, and navigating file systems. This abstraction simplifies file system interactions for developers.

Hierarchical Paging is a memory management technique that divides virtual memory into multiple levels of pages. It allows for efficient memory management and address translation by creating a hierarchy of page tables.

Two-Level Paging is a type of hierarchical paging where the virtual address space is divided into two levels of pages. The first level page table maps virtual pages to physical frames, while the second level page table maps physical frames to physical addresses.

An Inverted Page Table is a memory management technique where instead of having a separate page table for each process, a single table is used to store all page entries. It maps physical frames to virtual pages.

Segments are logical units of memory that represent a specific portion of a program or data structure. Each segment can have a variable size, making it suitable for managing code, data, and stack independently.

Paged Segmentation is a combined memory management technique that combines both segmentation and paging. It divides the virtual address space into segments and further divides each segment into pages. This approach provides both logical structure (segmentation) and efficient memory management (paging).

Demand Paging is a memory management technique where pages are loaded into memory only when they are actually needed. This saves memory space and allows for efficient execution of larger programs.

A Page Fault occurs when a process tries to access a page that is not currently loaded in memory. This causes an interrupt, and the operating system handles the fault by loading the missing page into memory.

Page Replacement is a critical aspect of memory management. It handles situations where the main memory is full, forcing some pages to be swapped out to secondary storage to make room for new pages. The goal is to minimize the number of page faults and ensure efficient program execution.

A scheduling algorithm that uses multiple queues with different priorities based on the process's CPU burst length. Processes are moved between queues based on their behavior, allowing for more efficient resource allocation.

The process of saving the state of a currently running process and restoring the state of another process, allowing the CPU to switch between processes seamlessly.

The ability for multiple tasks or processes to appear to execute simultaneously, even if they are truly taking turns on the resources.

The coordination of multiple threads to access and modify shared resources in a safe and predictable manner, preventing race conditions and data inconsistency.

Segmentation divides virtual memory into logical units called segments, each with a variable size. This allows for flexible memory allocation and structuring of programs and data.

Virtual addresses in segmentation include the segment number and offset within the segment, while physical addresses directly map to the physical memory location. This allows for non-contiguous memory allocation.

Advantages include flexible memory allocation, protection, and sharing. Disadvantages include fragmentation and overhead for managing segment tables.

Paged Segmentation combines segmentation with paging. It further divides each segment into fixed-size pages and allocates these pages to physical memory frames.

The Translation Lookaside Buffer (TLB) is a cache that stores recently used page table entries. This speeds up address translation by reducing accesses to the slower main memory.

A page fault occurs when a process tries to access a page that's not in memory. The OS handles this by loading the missing page from secondary storage.

Page replacement is needed because the main memory is limited. When new pages need to be loaded, some existing pages must be swapped out to secondary storage.