Operating Systems - 4

A message is the fundamental unit of information exchanged between processes in inter-process communication (IPC). The sender process sends a message containing data, and the receiver process reads it. Monitors are synchronization constructs, not data units, while deadlock is a condition where processes wait indefinitely.

In synchronous message passing, the sending process blocks until the receiving process is ready to accept the message. This rendezvous requires both processes to be actively involved at the same time. Asynchronous messaging allows the sender to continue without waiting.

Asynchronous message passing allows the sender to continue execution immediately after sending, without blocking for a corresponding receive operation. The system typically buffers messages until the receiver retrieves them. Synchronous messaging would block the sender.

Reusable resources (like memory blocks, printers, or files) can be used by multiple processes over time, but only by one process at any given moment. They must be explicitly allocated and deallocated. After use, they return to the available pool for future allocation.

Consumable resources are created by one process and destroyed by another during execution. Examples include signals, messages in a buffer, or interrupts. Unlike reusable resources, consumable resources cease to exist once consumed and must be regenerated for another use.

Internal fragmentation occurs when a memory partition is allocated to a process but the process doesn't use the entire block. The unused portion within the partition is wasted and cannot be allocated to other processes. This happens in fixed-size partition schemes.

Contiguous memory allocation places a process in a single continuous block of memory with consecutive addresses. This simplifies address translation but can lead to fragmentation. Non-contiguous allocation (like paging) allows a process to occupy non-adjacent blocks.

Wasted memory refers to the fraction of physical memory that remains unused due to internal or external fragmentation. This metric helps evaluate memory allocation efficiency. Lower wasted memory indicates better utilization of available physical memory.

Time complexity in memory management measures the computational cost of operations like allocating memory blocks, locating free space, or deallocating used blocks. Efficient allocation algorithms (like buddy systems) reduce this complexity, improving overall system performance.

Transient processes are loaded into memory and executed only when invoked by user commands or events. Unlike resident processes (like OS kernel components), transient processes terminate after completing their task and are removed from memory, freeing resources.

Table fragmentation refers to the physical memory consumed by memory management data structures like page tables, segment tables, or allocation maps. This overhead is necessary for virtual memory translation but reduces available memory for actual processes.

Memory access overhead correctly describes the extra time spent on memory management operations like address translation, protection checks, and page table walks. Time complexity refers to algorithm analysis, while wasted memory refers to space inefficiency.

A fence register is a dedicated hardware register used in early memory protection systems to mark the boundary between operating system memory and user process memory. This prevents user processes from accessing or modifying OS code and data.

The fence register establishes a clear boundary line separating the operating system's protected memory area from the transient (temporary) process area. This hardware mechanism is fundamental to memory protection in early systems.

Memory partitioning can indeed be static (partitions fixed at system initialization) or dynamic (partitions created and sized as needed during runtime). Both approaches are valid memory management strategies.

The partition allocation strategy is specifically responsible for selecting which memory partition to assign to a particular process. This decision can be based on various algorithms like first-fit, best-fit, or worst-fit.

Swapping is the correct term for moving suspended or preempted processes out of main memory to secondary storage (swap space) and bringing them back when needed. This allows more processes to run than physical memory can hold.

First-fit allocation selects the first free partition that is large enough to accommodate the process. It's simple and fast but may lead to external fragmentation. Best-fit and worst-fit are alternative strategies.

The swapper (part of the OS memory manager) is responsible for selecting which process to swap out of memory. This decision is typically based on factors like process priority, waiting time, and memory requirements.

The swapper also selects which process to swap IN from secondary storage into main memory. This typically happens when a swapped-out process becomes ready to run again and memory space is available.

The swapper allocates and manages swap space.

There are two basic types of relocation: static relocation (done at load/compile time, addresses are fixed) and dynamic relocation (done at runtime, addresses can change). This is fundamental to how programs are loaded and executed in memory.

Relocation refers to the ability to load and execute a program at any arbitrary location in memory, not just the address for which it was originally compiled. This is essential for efficient memory utilization in modern systems.