Memory Management in Operating Systems

The multi-programming nature of an operating system demands effective memory management, balancing efficient resource utilization and process allocation.
Memory Management oversees partitioning and allocation of memory to ready processes, ensuring both processor and memory are used effectively.
Memory is categorized into Main Memory (Real Memory) and Secondary Memory.
Memory Allocation is achieved through two methods: Static Allocation and Dynamic Allocation.

Static Allocation takes place before process execution.
Two specific instances where static allocation is implemented:
- Compile-Time Absolute Code Generation: Process location in memory is known at compile time, resulting in absolute code.
- Relocatable Code Generation: Process location is unknown at compile time. The compiler doesn't generate actual memory addresses but instead produces relocatable code - addresses are relative to a known point.

Dynamic Allocation, in contrast, postpones memory allocation until the process begins execution.
This approach is favored by modern operating systems in a multi-programming environment.
Dynamic Allocation leads to the generation of two address types: Logical Addresses and Physical Addresses.

Logical addresses are generated by the processor during compilation.
The set of all logical addresses generated for a process constitutes its logical address space.
Logical addresses are relative and do not directly correspond to physical memory locations.

Logical addresses are converted into absolute physical addresses during process execution.
The collection of these physical addresses forms the physical address space.
The memory management component maps logical addresses to physical addresses.

Swapping is a memory management technique employed when there's insufficient memory to execute a new process.
It involves temporarily moving a running process from main memory to secondary memory to free up memory for the new process.
Swapping can lead to disk I/O overhead due to the movement of processes between main memory and secondary memory.
Processes in memory are often swapped out to disk when memory becomes scarce.
Secondary storage can be used for swapping.

Fragmentation occurs when memory is divided into small, unusable portions, leading to inefficient memory utilization.
There are two types of fragmentation:
- Internal Fragmentation
  - Space within a partition that is allocated to a process, but not used by the process.
  - Occurs when the process size is smaller than the allocated partition.
- External Fragmentation
  - Available memory is broken into small, non-contiguous blocks.
  - Occurs when there are free memory spaces but they are not large enough to satisfy a new process's request.

Compaction is a technique to overcome external fragmentation.
It involves shifting all processes in memory to one end, creating a single larger block of contiguous free memory.
Compaction can be computationally expensive and require relocation of processes during runtime.

Contiguous Memory Allocation involves assigning a continuous block of memory to each process.
It has the advantage of simplicity but can lead to fragmentation.
Memory Allocation Techniques for contiguous allocation:
- First Fit: Allocate the first available partition that is large enough for the process.
- Best Fit : Allocate the smallest available partition that is large enough for the process.
- Worst Fit : Allocate the largest available partition for the process.

The Paging technique allows for non-contiguous memory allocation, addressing the issue of fragmentation in contiguous memory allocation.
It divides logical memory into fixed-size units called pages.
Physical memory is also divided into units called frames that match the size of pages.
Pages of a process are not required to be stored in contiguous frames.

Segmentation is a memory allocation technique where the program is divided into logical segments, each representing a distinct program unit like code, data, or stack.
Segments are not necessarily of fixed size, allowing for more flexibility in memory allocation.

Virtual Memory is a sophisticated memory management technique that allows processes to access more memory than physically available.
It provides an illusion of a larger address space to processes.
Virtual memory uses the concept of demand paging, where pages are loaded into memory only when they are needed.
It employs page replacement algorithms to manage the movement of pages between main and secondary memory.

Page Replacement Algorithms are essential for managing virtual memory systems. They determine which page should be swapped out when a new page needs to be loaded.
Some common page replacement algorithms include:
- FIFO (First In First Out): Replaces the oldest page in memory.
- LRU (Least Recently Used): Replaces the page that has not been accessed for the longest time.