- \n
- It makes sure that every process gets an ideal amount of memory and at the right time.<\/span><\/li>\n
- It updates the system by checking the inventory\u2019s status as vacant or engaged.\u00a0<\/span><\/li>\n
- Provides space to application routines<\/span><\/li>\n
- Coordinates to avoid interference between applications<\/span><\/li>\n
- Protects processes from each other<\/span><\/li>\n
- Ensures memory utilization by placing programs in the memory<\/span><\/li>\n<\/ul>\n
Requirements of memory management<\/h3>\n
1. Relocation<\/h4>\n
There are many files and processes that exist together as a multiprogramming system, but it’s hard to know if a program will be in the memory during execution. Swapping is the main concept here which we study in detail below.<\/p>\n
Swapping enables the operating system to have a better execution of the process. But this process after removing an item from the main memory, and the chances of it getting the same location at return are very less. Thus the idea of relocation becomes important.<\/p>\n
2. Protection<\/h4>\n
Storing many processes together leads to a mix up in writing the address. This causes interference between the programs affecting their functioning. Thus every process needs protection from these kinds of situations.<\/p>\n
Memory cannot predict the locations thus the absolute address is not accessible too. There is a dynamic calculator during the execution by the processor checking the validity of memory references.<\/p>\n
3. Sharing<\/h4>\n
There is sharing in the main memory by many processes allowing them to access the same copy of the programs instead of having an unique one. <\/span><\/p>\n
The memory management allows control over shared areas of memory while protecting them. The relocation is in a way to support sharing capabilities.<\/span><\/p>\n
4. Logical organization<\/h4>\n
The main memory follows a linear organisation with one-dimensional address space made of bytes or words. They may be editable or readable only but an effective operating system and computer hardware sports all basic modules. <\/span><\/p>\n
They are ideal because –\u00a0<\/span><\/p>\n
- \n
- Each module is independent and only the system resolves the references between them.\u00a0<\/span><\/li>\n
- There is a different degree of protection for each module.\u00a0<\/span><\/li>\n
- The mechanism allows sharing of modules with a program allowing users to experiment.\u00a0<\/span><\/li>\n<\/ul>\n
5. Physical organization<\/h4>\n
There is a physical organisation between the main and the secondary memory. Main one faster and costlier but the secondary is long term and non volatile. The flow of information between the two is very important for the programmer as they may engage in overlaying during insufficient space in the memory.<\/p>\n
Many modules can stay in the same region of the memory. But it is time consuming for the user as they are unaware about the space inside the memory and the coding time.<\/p>\n
Computer Memory Allocation<\/h3>\n
The main memory of the device usually has a partition. There is <\/span>low memory<\/span> where the operating system functions. And there is <\/span>high memory<\/span> for user processes. The operating system has two mechanisms for memory allocation –\u00a0<\/span><\/p>\n
1. Single-partition allocation<\/h4>\n
This type of mechanism follows a relocation-register scheme to protect the user\u2019s processes while changing code and data on the system. The smallest value logical address goes to the relocation register while the range of these addresses goes to the limit register.\u00a0<\/span><\/p>\n
2. Multiple-partition allocation \/ Contiguous Memory Allocation<\/h4>\n
Here, there are fixed space partitions of the main memory and each of them has only one process. When there is a vacant partition, the process from the input gets uploaded here.<\/p>\n
And once this process terminates, the partition becomes vacant again. The holes are the free block in the memory and each of them undergoes a test to see their capability before assignment.<\/p>\n
They are of three types –<\/p>\n
- \n
- First Fit<\/b> – It is the first hole with a large size for program allocation.\u00a0<\/span><\/li>\n
- Best Fit <\/b>– It is the smallest hole with a large size for program allocation.\u00a0<\/span><\/li>\n
- Worst Fit <\/b>– It is the largest hole with a large size for program allocation.<\/span><\/li>\n<\/ol>\n
Process Address Space<\/h3>\n
The logical space set is a process address with references in its code. An address with 32 bits can be in the range of 0 to 0x7fffffff with 2^31 possible numbers of 2 gigabytes size. The process of mapping a logical address to a physical one during allocation is by the operating system. The addresses are of three types –<\/p>\n
Symbolic addresses<\/strong> – the source code is the address with variable, constant, and instruction labels in the address space.
\nRelative addresses<\/strong> – The compiler converts the symbolic address into relative during the compilation.
\nPhysical addresses<\/strong> – The loaders make these during program loading in the memory.<\/p>\nDuring compilation and loading, virtual and physical addresses are the same and are different during execution-time and address-binding schemes. All the logical addresses that a program generates are logical address spaces.<\/p>\n
The Memory Management Unit takes care of transferring virtual addresses to a physical one using certain mechanisms. The base register has all user-generated addresses, the users only interact with virtual addresses and not the physical ones.<\/p>\n
Loading in Memory<\/h3>\n
The process of transferring secondary memory to main memory is Loading. It is mainly of two types, static loading, and dynamic loading. The decision of either one comes during computer program development.\u00a0\u00a0<\/span><\/p>\n
The <\/span>static loading<\/b> compiles programs without leaving any external program or module dependency. There is linking of object programs with other necessary object modules creating an absolute program with logical addresses. At the loading stage, the absolute program needs to be in memory for final execution.\u00a0<\/span><\/p>\n
In the case of <\/span>dynamic loading<\/b>, the compiling is done for all the modules with only references, and the rest is done during execution. The dynamic routes of the library enter the memory through a relocatable disk only when the program needs it.\u00a0<\/span><\/p>\n
Linking<\/h3>\n
Enabling program execution, linking brings together modules or the functions of the program. It is also of two types – static linking and dynamic linking. The <\/span>static linking <\/b>leads to combining all the modules of the program into one executable document to save users from runtime dependency.<\/span><\/p>\n
While <\/span>dynamic linking<\/b>, instead of compiling all the programs, a reference to the dynamic module is there during compilation and linking. Dynamic Link Libraries and Shared Objects are a few examples of dynamic libraries.<\/span><\/p>\n
Swapping<\/h3>\n
The process of removing a process temporarily out of the main memory to secondary storage and making it accessible for a new process is swapping.<\/p>\n
After the work is done, the original process goes back to the main memory. This impacts the device performance but helps to run multiple and processes in parallel. The time is taken to do this process from the start till the end is process swapping.<\/p>\n
<\/p>\n
![\"Swapping](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/04\/Basics-of-MEmory-Management-image01.jpg\")
<\/a><\/p>\nFor example –<\/strong><\/p>\n
Process Size – 2048KB
\nTransfer Rate – 1 MB\/per second.
\nActual Transfer – 1000K<\/p>\n2048KB \/ 1024KB per second
\n= 2 seconds
\n= 2000 milliseconds \/ one way<\/p>\nSome of its benefits are –<\/p>\n
- \n
- High degree of multiprogramming<\/span><\/li>\n
- Can follow a dynamic location leading to better functioning<\/span><\/li>\n
- Efficient use of the memory<\/span><\/li>\n
- Follows priority based schedule improving performance<\/span><\/li>\n
- There is minimum wastage of CPU<\/span><\/li>\n<\/ul>\n
Fragmentation<\/h3>\n
In the process of loading and removing, the free space in the memory gets into pieces. After a point, these pieces don’t accept any processes due to their small size and memory blocks. This problem is called fragmentation.<\/span><\/p>\n
<\/p>\n
![\"Fragmentation](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/04\/Basics-of-MEmory-Management-image02.jpg\")
<\/a><\/p>\nIt is of two types – External fragmentation and Internal fragmentation.\u00a0<\/span><\/p>\n
1. External fragmentation<\/h4>\n
It has enough memory space for process residence but it is not contiguous becoming useless. Compaction of all free memory together in a block can reduce this.\u00a0<\/span><\/p>\n
2. Internal fragmentation<\/h4>\n
It is when the process gets a bigger block than needed leaving extra space left unused. Effective assigning of the process into a small partition but enough for it can reduce this problem as well.\u00a0<\/span><\/p>\n
Paging<\/h3>\n
<\/p>\n
- Can follow a dynamic location leading to better functioning<\/span><\/li>\n
- Best Fit <\/b>– It is the smallest hole with a large size for program allocation.\u00a0<\/span><\/li>\n
- There is a different degree of protection for each module.\u00a0<\/span><\/li>\n
- It updates the system by checking the inventory\u2019s status as vacant or engaged.\u00a0<\/span><\/li>\n