Memory Management Concepts in Operating Systems

A unique number assigned to each byte of memory, allowing the CPU to access specific data locations.

An address used by a program, which might not be directly mapped to a physical memory location.

A hardware component that translates logical addresses used by programs into physical addresses used by the memory.

A technique where memory is allocated in contiguous blocks, starting from a specific address.

Unused memory space within a memory block that has been allocated to a process.

Unused memory space between allocated memory blocks.

A system where memory is divided into fixed-size pages, allowing programs to be stored non-contiguously.

A small, fast cache that stores recently used page table entries to speed up address translation.

The process of associating a logical (virtual) memory address with a physical memory address. This binding can occur at different stages, including compile time, load time, or execution time.

The memory addresses used by the CPU to access data, which are independent of the physical addresses used by the memory hardware.

The process of loading a program's code into memory, creating a process, and making it eligible for execution.

The separation of memory into distinct spaces for each process. This prevents processes from accessing each other's data, providing isolation and security.

A register used to store the starting address of a process's memory space.

A register used to specify the size or the limit of a process's memory space.

A mechanism used by hardware to prevent a process from accessing memory outside of its allocated space.

A special instruction that can only be executed by the operating system in kernel mode. This privilege allows the operating system to control critical system functions.

A special mode of operation where the operating system has full access to the system and all of its resources.

An exceptional event that occurs during program execution, usually resulting from an error or violation, leading to the transfer of control to the operating system.

A special type of memory that is located close to the CPU for fast access. It is used to store frequently accessed data and instructions, improving program performance.

A technique where a program's code is dynamically linked to libraries during execution, reducing code size and allowing sharing of resources.

A collection of pre-compiled code that can be shared among multiple programs. This promotes code reusability and reduces memory overhead.

A process where code is loaded into memory only when it is needed, improving memory usage.

Addresses that are symbolic and are usually assigned by a compiler.

Addresses that are generated by the compiler, which can be moved around in memory.

Addresses that are fixed and specific to a particular memory location.

The process of converting symbolic addresses to relocatable addresses.

The process of converting relocatable addresses to absolute addresses.

The process where binding of logical and physical addresses occurs at compile time, which means the program's location in memory is fixed.

The process where binding of logical and physical addresses occurs at load time. The program's location in memory is flexible yet defined before execution.

The process where binding of logical and physical addresses occurs at execution time. It allows the program to be moved in memory during execution.

The memory space seen by the program, which is composed of logical addresses.

The actual physical memory space, composed of physical addresses.

A type of logical address used during execution-time address binding, which is not necessarily the same as the physical address.

It's a routine that is loaded only when it's needed, optimizing memory usage.

Large amounts of code are loaded only when required, especially for infrequent events like error handling.

A system library linked to user programs at runtime, meaning the linking happens when the program is running.

A system library linked to a user program at compile time, before the program is run.

Dynamically linked libraries can be shared among multiple processes, reducing memory usage.

A mechanism to update shared libraries without relinking all programs that use them, enhancing software maintenance.

Version information in programs and libraries ensures compatibility when using updated versions.

Operating systems are required for dynamic linking and shared libraries to work correctly.

The memory is divided into two sections: one for the operating system and one for user processes.

Relocation and limit registers are used to dynamically map logical addresses to physical addresses, ensuring memory protection.

A type of memory allocation where processes are assigned to variable-sized memory partitions. The operating system keeps track of available and occupied memory blocks using a table.

A large block of unused memory space. This is the initial state of memory before any processes are loaded.

The process of dynamically allocating and managing memory space during program execution. This ensures efficient usage of available memory.

A strategy for selecting a free memory block from the available set. It chooses the first hole that is large enough to accommodate the requesting process.

A strategy for selecting a free memory block from the available set. It chooses the smallest hole that is large enough to accommodate the requesting process.

A strategy for selecting a free memory block from the available set. It chooses the largest hole to accommodate the requesting process.

The process of removing a program's data and code from memory, freeing up the memory space for other processes.

A waiting queue where processes that cannot be immediately allocated memory are placed. They are then assigned memory when it becomes available.

A memory management technique that aims to prevent excessive fragmentation by compacting free memory spaces together. This creates larger contiguous memory blocks.

A mechanism that allows the operating system to dynamically adjust its size in memory. This flexibility is helpful for loading and unloading device drivers as needed.

Memory that is unusable due to fragmentation, representing a significant portion of memory that cannot be allocated to processes.

Fixed-size blocks of physical memory where pages of a process reside.

Fixed-size blocks of a process's logical memory, corresponding to memory frames in physical memory.

A special table that stores the base address of each frame in physical memory, used to translate logical addresses to physical addresses during paging.

The process of converting a logical address generated by a program into a physical address used by the memory system.

The high-order bits of a logical address that identify the specific page containing the requested data.

The low-order bits of a logical address that specify the offset within a page where the data is located.

A data structure used by the operating system to keep track of available and allocated memory pages. It contains information about which page frames are free, and if allocated, which process uses them.

The operating system maintains a copy of the page table for each process, used to translate logical addresses to physical addresses. It plays a role in the CPU dispatcher.

The operating system maintains a copy of the page table for each process, used to translate logical addresses to physical addresses. It plays a role in the CPU dispatcher.

A register pointing to the start of the page table in main memory. Switching page tables only requires changing the value in this register, greatly reducing context-switch time.

Occurs when the requested page table entry is not found in the TLB. Address translation requires a slower memory access to the page table.

Selecting an entry from the TLB to be replaced when it becomes full. Policies like Least Recently Used (LRU), round-robin, or random are used.

Entries in the TLB can be marked as 'wired down', indicating they cannot be removed, typically used for important kernel code.

A situation where a program can access addresses outside its allocated memory range, leading to errors or security breaches.

A register that indicates the size of the page table for a process, ensuring that memory accesses are within the valid range.

The ability to share code (like libraries) among multiple processes, reducing memory usage and improving efficiency.

Code that can be executed concurrently by multiple processes without interfering with each other.

A two-level hierarchical page table where the page table itself is paged to manage large address spaces efficiently.

A page table that is organized as a hash table, providing faster address translation by efficiently searching for entries.

A page table structure where entries are stored in a single table and accessed through a search algorithm.

The process of moving a page from memory to secondary storage (like a hard drive).

The process of moving a page from secondary storage (like a hard drive) back into memory.

A technique used in operating systems where, instead of swapping entire processes, only individual pages of a process are swapped between memory and secondary storage.

The practice of mobile operating systems where applications voluntarily relinquish allocated memory when free memory is low.

A technique used by Android where the state of a process is saved to flash memory before it is terminated, allowing for quick restarting.

A situation where there are more active processes than available physical memory, resulting in the need to swap pages to secondary storage.

A situation where a program uses more memory than it needs, leading to inefficient use of resources.

A common practice in mobile systems where applications are terminated if they fail to relinquish sufficient memory.

The programmer's view of memory is divided into fixed-size units called pages, while physical memory is divided into frames of the same size.

A logical address is the address used by a program, while a physical address is the actual location in physical memory.

A page table is a data structure used to map logical page numbers to physical frame numbers.

The operating system uses a page table to translate logical addresses into physical addresses.

The process of translating logical addresses to physical addresses is done by hardware using the page table.

Paging allows for greater flexibility in memory allocation, as pages can be placed anywhere in physical memory.

Internal fragmentation refers to wasted space within a frame when a process's memory requirements do not exactly align with the page size.

Paging eliminates external fragmentation because any free frame can be allocated to a process that needs it.

Small page sizes can reduce internal fragmentation, but increase the overhead of maintaining the page table.

Paging can address a much larger logical memory space than the physical memory size.

The operating system manages the physical memory allocation, keeping track of free frames, allocated frames, and process memory requirements.

The process of loading a program's code into memory and making it ready for execution, involves allocating pages and setting up the page table.

Paging provides a layer of abstraction, where the programmer sees a single, contiguous address space, while the physical memory is actually fragmented.

The page table ensures that a program can only access memory that is allocated to it, providing protection against unauthorized access.

Paging is a key component of virtual memory systems, allowing programs to execute using a larger virtual memory space than the physical memory available.

A unique identifier assigned to each process to distinguish its address space from others. Helps the TLB to store entries for multiple processes without confusing them.

An important performance metric when paging is used, indicating the percentage of times the desired page entry is found in the TLB. A higher hit ratio implies faster memory access.

Process of emptying the TLB, ensuring that the next process using the system doesn't rely on outdated or invalid address translations.

Bits associated with each memory frame, indicating the type of access allowed (e.g., read-only, read-write, execute-only). These bits are checked during memory accesses to enforce security.

A mechanism that traps the program's execution to the operating system when an illegal access attempt is detected. Used for memory protection and handling errors.

A bit associated with each entry in the page table, indicating whether the corresponding page is currently valid and part of the process's address space.

When a program attempts to access a page that isn't marked as valid, leading to a trap to the operating system.

A hierarchical page table structure with multiple levels, where each level points to the next level's entries. This approach enables a large virtual address space and efficient address translation.

A common implementation of paging, where the outer page table is divided into smaller pieces, creating multiple levels of page tables. This optimizes memory usage and improves efficiency.

A variation of hashed page tables, where each entry in the hash table refers to a cluster of pages, typically 16 pages. This is particularly beneficial for sparse address spaces.

A memory management technique that identifies each page with a unique combination of process ID, segment number, and page number. This allows the system to efficiently identify and access pages across different processes.

A memory management technique in which the entire process is moved from main memory to a backing store and later brought back into memory when needed.

This occurs when a process attempts to access a memory location that is not currently mapped into physical memory. This usually happens due to a page not being loaded from the backing store into main memory.

A memory management technique that involves moving entire processes between main memory and a backing store (like disk). This technique helps to improve the degree of multiprogramming by allowing more processes to run concurrently, even if there is limited physical memory available.

A memory management strategy where the available memory is divided into partitions, each containing a single process. It provides memory protection and avoids fragmentation.