Memory Management is an important function of an Operating System that manages the system's Primary Memory (Main Memory).
It manages the allocation and deallocation of memory for processes, keeps track of which memory locations are allocated and which are free, and manages the movement of data between Primary Memory and Secondary Memory when required.
Memory Management helps the Operating System achieve better concurrency, system performance, and memory utilization.
Functions of Memory Management
1. Memory Allocation and Deallocation: The Operating System allocates memory to processes when they need it and releases the memory when the processes finish or no longer need it.
2. Tracking Memory Usage: The Operating System keeps track of the status of memory locations, identifying which parts of memory are allocated and which parts are free.
3. Process Movement: Memory Management can move processes or data between Primary Memory and Secondary Memory when required, allowing the system to manage limited Main Memory efficiently.
4. Memory Protection: The Operating System protects the memory allocated to one process from being improperly accessed or corrupted by another process. This helps prevent unexpected or faulty system behavior.
5. Memory Sharing: Memory Management allows processes to share memory spaces when required. This can help multiple programs use shared memory resources efficiently.
Goals of Memory Management
1. Efficient Memory Utilization: To use the available Primary Memory efficiently and reduce unnecessary memory wastage.
2. Better Concurrency: To allow multiple processes to reside in memory and execute efficiently, improving the overall concurrency of the system.
3. Better System Performance: To manage memory efficiently so that processes can execute smoothly and the system can provide better performance.
4. Memory Protection: To prevent one process from interfering with or corrupting the memory allocated to another process.
5. Support for Large Programs: To enable programs that require more memory than the currently available Primary Memory by moving data between Primary and Secondary Memory when necessary.
6. Efficient Memory Sharing: To allow processes to share memory spaces when required while maintaining proper memory management.

What is Swapping?
Swapping is a Memory Management technique in an Operating System in which a Process is temporarily moved between Main Memory (RAM) and Secondary Memory (Hard Drive) to manage limited memory efficiently.

Suppose several Processes such as P1, P2, P3, and P4 are ready to be executed. If P1 and P2 consume a large amount of memory, there may not be enough Main Memory available for P3 and P4. In such a situation, the Operating System can temporarily move a suitable Process from Main Memory to Secondary Memory to make memory available for another Process.
The area of Secondary Memory where swapped-out Processes are stored is called Swap Space.
When sufficient Main Memory becomes available, the swapped-out Process can be brought back into Main Memory and its execution can continue.
Swap In
Swap In is the process of bringing a Process from Secondary Memory (Hard Drive) into Main Memory (RAM) so that it can be executed or its execution can continue.
Secondary Memory → Main Memory
Swap Out
Swap Out is the process of moving a Process from Main Memory (RAM) to Secondary Memory (Hard Drive) to free Main Memory for another Process.
Main Memory → Secondary Memory
Medium-Term Scheduler
The Medium-Term Scheduler (MTS) manages the swapping of Processes between Main Memory and Secondary Memory.
Advantages of Swapping
1. Maximum CPU Utilization: Swapping helps keep suitable Processes available for execution so that the CPU can remain busy as much as possible.
2. Memory Availability: Swapping creates free space in Main Memory for Processes that need to be executed.
3. Avoids Process Starvation: Swapping can help provide execution opportunities to waiting Processes by making the required memory available.
4. Supports Multiple Processes: Swapping allows the Operating System to manage more Processes even when the available Main Memory is limited.
5. Proper RAM Utilization: It helps the Operating System utilize Main Memory efficiently by temporarily moving Processes to Secondary Memory.
6. Swap Space: Swapping uses a dedicated area of Secondary Memory, called Swap Space, to store swapped-out Processes.
7. Supports Priority-based Scheduling: In priority-based scheduling, a suitable Low-Priority Process may be swapped out so that a High-Priority Process can be brought into Main Memory for execution.
8. Economical Memory Management: Swapping helps manage limited Main Memory by using available Secondary Memory when required.
Disadvantage of Swapping:
Swapping can affect system performance because transferring Processes between Main Memory and Secondary Memory requires additional time.

Memory Allocation is the process of assigning memory space to a process or program by the Operating System. There are two main types of memory allocation strategies: Contiguous Memory Allocation and Non-Contiguous Memory Allocation.
1. Contiguous Memory Allocation
Contiguous Memory Allocation refers to assigning sequential physical memory blocks to a process or program. In this technique, a process is allocated a single continuous block of memory rather than scattered blocks.
When a process requests memory, the Operating System searches for a free continuous memory area large enough to hold the process. Since the allocated memory addresses are adjacent, memory addressing and access are relatively simple and fast.
Important Points:
Contiguous Memory Allocation makes memory addressing easier and can improve memory access speed.
When processes are loaded and removed, small gaps may be created between allocated blocks. This causes External Fragmentation.
External Fragmentation may prevent a large process from being allocated even when the total amount of free memory is sufficient.
The Operating System can use techniques such as Compaction to rearrange memory and reduce fragmentation.
2. Non-Contiguous Memory Allocation
Non-Contiguous Memory Allocation allows a process to be stored in multiple dispersed or non-adjacent memory regions. Unlike Contiguous Memory Allocation, the entire process does not need to occupy one continuous block of physical memory.
This technique is useful when memory has fragmented free spaces or when processes have variable memory requirements. The Operating System uses data structures such as tables or linked structures to keep track of available memory blocks.
Important Points:
Non-Contiguous Memory Allocation provides greater flexibility because a process can use scattered memory areas.
It can help reduce External Fragmentation because available gaps can be used more flexibly.
Memory management is more complex because the Operating System must track multiple memory locations.
Allocation may be slower because the Operating System needs to search for suitable memory areas and manage additional information.
This approach is commonly associated with systems having dynamic memory requirements.
Difference Between Contiguous and Non-Contiguous Memory Allocation

Aspect	Contiguous Memory Allocation	Non-Contiguous Memory Allocation
Memory Layout	Memory blocks are sequentially adjacent.	Memory blocks can be scattered throughout memory.
Fragmentation	External Fragmentation may occur due to changing block sizes.	Can reduce External Fragmentation by using available gaps more flexibly.
Allocation	Generally simpler and faster.	More complex because scattered memory areas must be managed.
Memory Access	Relatively simple and fast because addresses are contiguous.	More complex because memory locations may be scattered.
Flexibility	Less flexible because a continuous block is required.	More flexible because multiple memory areas can be used.
Usage	Suitable for systems with simpler or fixed memory requirements.	Suitable for systems with dynamic memory requirements.

In Contiguous Memory Allocation, whenever a process needs memory space, the Operating System allocates a continuous empty block of memory to the process.
Contiguous Memory Allocation can be done in two ways:
1. Fixed-size Partition Scheme
2. Variable-size Partition Scheme
Fixed-size Partition Scheme
Fixed-size Partition Scheme is a Contiguous Memory Allocation technique in which each process is allocated a fixed-size continuous block in Main Memory.
In this method, the entire memory is divided into a number of continuous fixed-size partitions. When a new process is loaded, each partition can hold exactly one process.

Since the partition size is fixed, every process is allocated the same-size memory block regardless of the actual size of the process. Therefore, this technique is also called Fixed Partitioning or Static Partitioning.

Example:
Suppose there are three processes of sizes 3 MB, 1 MB, and 4 MB, and each memory partition has a fixed size of 5 MB.
The 3 MB process is allocated a 5 MB partition.
The 1 MB process is allocated another 5 MB partition.
The 4 MB process is also allocated another 5 MB partition.
Thus, the actual process size does not determine the partition size; the partition size is fixed.
Degree of Multiprogramming
The number of processes that can stay in Main Memory at the same time is called the Degree of Multiprogramming.
In Fixed-size Partitioning, the degree of multiprogramming is determined by the number of partitions created in Main Memory.
Advantages of Fixed-size Partition Scheme
1. It is simple to implement because the memory is divided into fixed-size blocks and processes are assigned to those blocks.
2. It is easy to keep track of available memory blocks, which determines how many more processes can be loaded into memory.
3. Multiple processes can remain in Main Memory at the same time, so it supports Multiprogramming.
Disadvantages of Fixed-size Partition Scheme
1. A process whose size is greater than the partition size cannot be allocated to any partition.
2. The number of partitions determines the Degree of Multiprogramming, so only that many processes can remain in Main Memory at a time.
3. If a process is smaller than its allocated partition, the unused portion of that partition is wasted. This causes Internal Fragmentation.

In this type of contiguous memory allocation technique, no fixed blocks or partitions are made in the memory. Instead, each Process is allotted a variable-sized block depending upon its requirements. Whenever a new Process needs memory space, the required amount is assigned from the available free memory. Therefore, the size of each block depends on the size and requirements of the Process occupying it.
In this scheme, there are no fixed-size partitions. For example, if the first Process needs 3MB of memory space, it is allotted 3MB only. Similarly, other Processes are allotted only the amount of space required by them. As a result, the allocated memory blocks have different sizes.
As the block sizes are variable and are decided as Processes arrive, this scheme is also called Dynamic Partitioning.
Advantages
1. As Processes are allotted memory space according to their requirements, there is no Internal Fragmentation. Hence, there is no memory wastage due to Internal Fragmentation.
2. The number of Processes that can be present in memory at the same time depends on how many Processes are in memory and how much space they occupy. Therefore, it can be different for different cases and is dynamic.
3. As there are no fixed-size blocks, even a large Process can be allotted the required memory space if a sufficiently large contiguous space is available.
Disadvantages
1. Because this approach is dynamic, a Variable-size Partition Scheme is difficult to implement.
2. It is difficult to keep track of Processes and the remaining free space in memory. Dynamic Partitioning can suffer from External Fragmentation, where free memory is split into small gaps between allocated blocks.
Even when there is enough total free memory, a large new Process may not fit unless the free spaces are compacted into one sufficiently large contiguous block.

Fragmentation in memory is a condition where the available memory is divided into small and non-contiguous blocks after allocating and deallocating memory to various Processes. In simpler words, fragmentation means there are some gaps in memory after running multiple Processes at different memory locations.
Fragmentation can lead to wastage of memory. Even though there is enough total memory available, it may not be possible to allocate memory to a new Process due to fragmentation.
Types of Fragmentation
Fragmentation can be classified into two types:
1. Internal Fragmentation
2. External Fragmentation
Internal Fragmentation
Internal Fragmentation occurs when a Process gets more memory than it actually needs. The Operating System allocates memory in fixed-size blocks or frames. If a Process uses only a part of the allocated memory, some memory will be wasted.

In the figure, Process P1 is allocated F1, F2, and F3 frames of memory. But it is only using F1 and F2 frames. The F3 frame is wasted because the Process does not need it. Similarly, the F6, F7, and F9 frames are also wasted because Processes P2 and P3 are holding them.
Causes of Internal Fragmentation
Fixed Size Memory Allocation: Some Operating Systems allocate memory in fixed-size blocks or frames. If a Process requires less memory than the allocated block size, the remaining memory will be wasted. For example, consider a system that allocates memory to all Processes in blocks of 4 KB. If a Process requires 6 KB of memory, the Operating System should allocate 8 KB of memory, which means two blocks. Therefore, 2 KB of memory will be wasted.
Management Overheads: Some systems reserve a part of the allocated memory for purposes such as bookkeeping and management. Sometimes this reserved memory may not be used by the Process.
Memory Alignment: Some systems require memory to be aligned to certain boundaries, such as 4-byte or 8-byte boundaries. This can lead to wastage of memory and Internal Fragmentation.
External Fragmentation
External Fragmentation refers to gaps generated in memory when multiple Processes are loaded and unloaded from memory.
To understand this, suppose Process P1 is allocated three frames of memory: F1, F2, and F3. Process P2 is allocated one frame F4 and Process P3 is allocated two frames F5 and F6. Now, if P2 is terminated, frame F4 will be free. This introduces a gap in memory between the memory allocated to P1 and P3.
The gaps generated in memory will add up over time as more Processes are loaded and unloaded from memory. This can lead to a situation where, even though there is enough total memory available, the system will not be able to allocate memory to a new Process because the available memory is scattered in small non-contiguous blocks.
Causes of External Fragmentation
Dynamic Memory Allocation: Some systems use Dynamic Memory Allocation. In such systems, memory is allocated to Processes when they request it and deallocated when they are done. This can cause fragmentation as there is no fixed rule to allocate memory.
Process Termination: When a Process is completed, it is terminated from memory. This will create gaps in memory if the terminated Process was allocated memory between other Processes.
Variable Size Memory Allocation: Some systems allocate memory to Processes in variable sizes. This can lead to fragmentation as there is no fixed rule to allocate memory.
How to Reduce Fragmentation?
Compaction: Compaction is a technique where the Operating System rearranges the memory contents to place all free memory together in one large block. This removes the gaps in memory and reduces fragmentation.
Paging: Paging is a memory management technique that uses virtual memory to store the Process and then maps it to frames of physical memory. This can eliminate External Fragmentation as the Process can be stored in non-contiguous frames of memory.
Segmentation: Segmentation divides memory into variable-sized segments based on the logical structure of a program. This can reduce fragmentation as the segments can be allocated in non-contiguous memory locations.

Watch Video: First Fit, Next Fit, Best Fit, Worst Fit | Fixed Size Partition
Placement Algorithm in Operating System determines where a Process or Data should be placed in memory. It helps to use available memory efficiently, reduce memory fragmentation, and improve system performance.
Types of Placement Algorithms
First Fit: Allocates the first available memory block that is large enough for the Process.
Best Fit: Allocates the smallest available block that can accommodate the Process.
Worst Fit: Allocates the largest available memory block, leaving larger free spaces for future allocations.
Next Fit: Similar to First Fit, but the search starts from the last allocated position.
Method to Solve Placement Problems
Understand the memory layout and block sizes → identify Process sizes → select the required Placement Algorithm → allocate Processes step by step → consider Internal or External Fragmentation → evaluate memory efficiency.


Advantages
Efficient memory utilization, reduced idle memory slots, support for multitasking, improved system throughput, and adaptability to different memory demands.
Disadvantages
May cause External or Internal Fragmentation, can require memory compaction, and some algorithms may be computationally expensive or complex.

Watch Video: First Fit, Next Fit, Best Fit, Worst Fit | Variable Size Partition|