Operating System Memory Management

The functionality of an operating system that manages the primary memory, including the movement of processes between main and secondary memory during execution.

A fixed-length block of main memory. It's like a shelf in a library.

A fixed-length block of data residing in secondary memory. Imagine a section of a book.

A variable-length block of data residing in secondary memory. Think of a whole chapter in a book.

Temporarily moving a process from main memory to secondary memory to free up space for others. Think of moving a book to a shelf to make space for another.

This occurs when free memory spaces are broken down into smaller fragments due to the continuous loading and removal of processes. It's like having lots of small gaps on a bookshelf.

This occurs when the allotted memory blocks are of varying sizes, leading to unused spaces. It's like having shelves of different sizes, leaving gaps.

This occurs when the allotted memory blocks are of fixed size, and a process requires more or less space than what is allocated. It's like having books that are too big or too small for the shelves.

The operating system's responsibility to manage the main memory, ensuring efficient use and protection of resources.

The ability for programs to be moved within the main memory without affecting their functionality.

The ability of the memory management system to prevent unauthorized access to a process's memory.

Organized structure within a program, dividing it into manageable units like instructions and data.

How the operating system manages the flow of information between the main memory and secondary memory.

A type of memory organization where the main memory is divided into fixed-size blocks.

A memory management technique where each process is loaded into a partition of the same size as the process itself. This avoids internal fragmentation, offering efficient memory use.

This algorithm picks the smallest available memory block that is just large enough to hold the requested process, maximizing memory utilization.

The first available memory block that is large enough to accommodate the process is chosen, offering a simple implementation.

The memory is searched sequentially starting from the last placement point, picking the next available memory block big enough for the process.

A technique that divides both memory and processes into equal-sized units (frames and pages). It supports virtual memory and reduces external fragmentation.

A memory management strategy where a process is divided into segments of variable sizes, and then loaded into dynamic partitions. It eliminates internal fragmentation, but can lead to external fragmentation.

An abstract representation of main memory that gives processes and the kernel the illusion of unlimited private memory. It's managed by the operating system and the processor.

Virtual memory allows multiple processes to run concurrently, each with its own address space. This prevents them from interfering with each other.

A method of memory management that divides the virtual address space into fixed-size blocks called pages, loaded on demand.

A method of memory management that divides the virtual address space into variable-sized blocks called segments, loaded on demand.

The process of selecting a task to be executed by the CPU.

A queue that holds all the processes in the system, waiting to be executed.

A queue that holds processes ready to be executed, residing in main memory.

A queue that holds processes waiting for a specific I/O device to become available.

The scheduler that selects which processes are admitted to the system, controlling the degree of multiprogramming.

The scheduler that selects the next process to execute, switching between the ready and running states.

These applications prioritize quick response times, often handling interactions with external systems or users.

These applications focus on intense calculations, with long processing times.

A process running on a system can be interrupted and put back into the waiting pool, allowing other processes to run.

A process keeps running until it finishes or it blocks itself (e.g., waiting for input).

This scheduling algorithm prioritizes the process that arrived in the system first, regardless of its workload.

This algorithm chooses the process with the shortest estimated processing time to execute first, aiming to minimize overall waiting time.

This algorithm uses preemption: if a new process arrives with a shorter remaining processing time, it can interrupt the currently running process and execute instead.

It is a non-preemptive algorithm that prioritizes processes based on their arrival time in the system.

A scheduling algorithm where the process with the shortest expected remaining processing time is always chosen and executed.

A scheduling algorithm that breaks the CPU time into fixed-length intervals called 'quantum'. Each process is given a 'quantum' to execute before being preempted. This happens in a round-robin fashion.

A scheduling algorithm where each process is assigned a priority, and the scheduler selects the process with the highest priority to execute.

A scheduling problem where lower-priority processes may never get executed due to a constant stream of higher-priority processes.

A scheduling algorithm that uses a time interrupt to periodically preempt the currently running process and place it back in the ready queue. The next ready process is then selected.

The fixed amount of time each process gets to execute in Round Robin scheduling.

The time elapsed during the execution of a process, including any overhead caused by scheduling or service calls.

The process of changing the priority of a process based on its age or execution history, often used to address starvation.