Dynamic partition allocation
1, Experimental objectives
Develop a C language program to realize the dynamic partition allocation scheme of memory space management.
2, Experimental principle
Dynamic partition allocation: according to the actual needs of the process, dynamically create partitions to allocate memory space. When realizing dynamic partition allocation, it will involve the data structure used in partition allocation, partition allocation algorithm, partition allocation and recycling operations.
1) Data structure in partition allocation
free partition table: a data table used to record the status of each free block, such as starting address, size, usage, etc;
free partition linked list: link all free partitions into a linked list to facilitate memory space viewing, allocation and recycling.
2) Memory allocation process
Use the allocation algorithm to find the memory block that meets the requirements, and set the requested memory size as size:
if the size of the found free partition is equal to size, it is fully allocated;
if the size of the found free partition is greater than size, and the remaining size is less than 1K after being divided into two, it will not be divided and allocated as a whole; Otherwise, it is divided into two parts, and the remaining part still exists as a free partition;
if there is no free partition meeting the requirements, the allocation fails
3) Allocation algorithm
first adaptation method: the free partition is organized according to the increasing order of the first address. Each time, start from the head of the chain to find the memory block that meets the requirements.
best fit method: free partitions are organized according to the increasing order of free partition size and address. Each time, starting from the head of the chain, find the smallest memory block that meets the requirements for allocation.
worst case adaptation method: free partitions are organized in descending order of free partition size, and whether the maximum free partition meets the requirements is directly judged during each search.
4) Memory recycling
According to the first address and size of the free zone, look up the free partition list / linked list to judge whether there are adjacent free partitions:
the release area is adjacent to the front free area: merge the release area and the front free area into one free area. The first address is still the first address of the previous free area, and the size is the sum of the size of the free area and the size of the free area.
the release area is adjacent to the front and rear free areas: combine the three areas into one free area, the first address is the first address of the front free area, and the size is the sum of the sizes of the three areas, and cancel the list of the original and rear free areas.
the release area is adjacent to the post free area: the release area is merged into the post free area. The first address is the first address of the release area, and the size is the sum of the two sizes.
the free area is not adjacent to any free area: take the free area as a free area, and insert its size and first address into the appropriate position of the free area table.
Experiment purpose or requirements: through this experiment, we can deeply understand the idea and implementation method of paging technology of continuous allocation mode or discrete allocation mode of computer memory management, so that we can better analyze and master the characteristics of continuous or paging memory management, and achieve the basic practical ability, problem analysis, design The training of professional core competence realized by algorithm.
Develop a C language program to realize the dynamic partition allocation scheme of memory space management. According to the actual needs of the process, dynamically create partitions to allocate memory space. When realizing dynamic partition allocation, it will involve the data structure used in partition allocation, partition allocation algorithm, partition allocation and recycling operation and so on. Design the data structure in partition allocation, realize the memory allocation process, use the first adaptation method to allocate memory space, and deal with various situations in various memory recycling, such as the release area is adjacent to the front free area, the release area is adjacent to the front and rear free areas, and so on.
#include <stdio.h> #include <stdlib.h> int memory = 0; //Size of storage space int count = 0; //Record the total number of jobs typedef struct Storage{ int number; //Job number int start; int last; int size; int state; //Distinguish whether memory space is allocated or unallocated. Idle is 0 struct Storage *next; }Storage; int add(Storage *head,int number,int size){ Storage *add1 = head->next; //ergodic while(add1 != NULL){ //A free area greater than or equal to the insertion job was found if(add1->number==-1 && add1->size>=size){ break; } add1 = add1->next; } if(add1 == NULL){ //No suitable free area was found return 0; } //Divide the free area into two parts int sizeOld = add1->size; //Storage job add1->number=number; add1->size = size; add1->state = 1; add1->last = add1->start + size - 1; //New free area section Storage *add2 = (Storage *)malloc(sizeof(Storage)); add2->number = -1; add2->size = sizeOld - size; add2->start = add1->last + 1; if(add2->start >= memory - 1){ add1->next = NULL; return 1; } add2->state = 0; add2->last = add2->start + add2->size - 1; add2->next = add1->next; add1->next = add2; return 1; } int deleted(Storage *head,int id){ Storage *del1 = head->next; Storage *del2 = del1->next; int temp1 = -1,temp2 = -1; while(del1 != NULL){ if(id == del2->number){ temp1 = 0; temp2 = 0; //Adjacent to the previous free area if(del1->state == 0){ temp1 = 1; } //Adjacent to the next free area if(del2->next->state == 0){ temp2 = 1; } break; } del1 = del1->next; del2 = del2->next; } //Discuss the free area before and after the free area //There are free areas in front of and behind if(temp1 == 1 && temp2 == 1){ del1->last = del2->next->last; del1->size = del1->size + del2->size + del2->next->size; del1->state = 0; del1->number = -1; del1->next = del2->next->next; } //Ahead is the free area else if(temp1 == 1){ del1->number = -1; del1->size = del1->size + del2->size; del1->state = 0; del1->last = del2->last; del1->next = del2->next; } //Then there is the free area else if(temp2 == 1){ del2->number = -1; del2->size = del2->size + del2->next->size; del2->state = 0; del2->last = del2->next->last; del2->next = del2->next->next; } //Neither front nor back is a free area else{ del2->number = -1; del2->state = 0; } return 1; } //View memory allocation void viewinformation(Storage *head){ Storage *p = head->next; while(p != NULL){ if(0 == p->state){ printf("Free area \tstart = %d\tlast = %d\tsize = %d\n",p->start,p->last,p->size); } else{ printf("task id = %d\tstart = %d\tlast = %d\tsize = %d\n",p->number,p->start,p->last,p->size); } p = p->next; } } void firstview(){ printf("1: Allocate memory for new jobs\n"); printf("2: Reclaim jobs to free memory\n"); printf("3: View memory allocation\n"); printf("4: sign out\n"); printf( "Please enter an action: " ); } int main(){ printf("Please enter the storage space size (unit) K): "); scanf("%d",&memory); //initialization Storage *head = (Storage *)malloc(sizeof(Storage)); Storage *storage = (Storage *)malloc(sizeof(Storage)); head->next = NULL; storage->number = -1; storage->size = memory; storage->start = 0; storage->last = memory-1; storage->state = 0; storage->next = NULL; head->next = storage; while(1){ int chioce, id, size; firstview(); scanf("%d", &chioce); switch(chioce){ //Four options to do different things case 1 : { //Assign a new job printf("Please enter a job id And job size size:\n"); printf("id = "); scanf("%d",&id); printf("size = "); scanf("%d",&size); if(add(head,id,size)){ printf("Space allocation succeeded!\n"); //Each time space is allocated, the number of jobs is increased by one count++; } else{ printf("Space allocation failed!\n"); } break; } case 2 : { //Recycling operation printf("Please enter the name of the recycle job id: "); scanf("%d",&id); if(deleted(head,id)){ //Recycling succeeded count--; printf("Job recycling succeeded!\n"); } else{ //Recycling failed printf("Job recycle failed!\n"); } break; } case 3 : { //View allocation viewinformation(head); break; } case 4 : { //Exit program return 0; } } } return 0; }