内存动态分区分配和回收的模拟实现

实验目的

1. 加深对内存管理的理解，进而对连续分配和离散分配有更深刻的认识。
2. 通过内存管理，进一步理解进程等操作系统概念。

实验内容

• 模拟实现内存动态分区分配和回收
  • 建立一个长度为1024的一维数组，用以模拟内存。
  • 建立空闲分区表或空闲分区链，用来记录内存的使用情况。
  • 为请求进入内存的作业分配内存，回收运行完成的作业所占内存。
  • 键盘输入：表示一个请求进入内存的作业的三元组： （作业号（0–9），作业大小（1—1024），作业运行时间）
  • 程序接受键盘输入，进行内存分配，返回分配或其它信息（在屏幕显示）

实验代码

//首次适应算法
#include<iostream>
#include<ctime>
#include<windows.h>

using namespace std;

int memory[1024]={0};//1024的模拟内存，初始化置0，空闲状态 ，为1说明该内存被作业0所使用，以此类推
clock_t start[10];//存进程开始时间 

struct process
{
    int size;
    int time;
}x[10];

struct state_table
{
    int address;
    int size;
    state_table * next;
};//未分配分区状态表 

int search_memory(int n);//遍历内存中有无n号进程 ，有返回1
void new_state_table(state_table *first,state_table *end);//更新未分配分区状态表
int search_state_table(int a,int size,state_table *first,state_table *end);
void recovery();
void delete_state_table(state_table *first,state_table *end);

int main()
{
    state_table *first,*end;
    first=new state_table;
    end=new state_table;
    first->next=end;
    end->next=NULL;
    new_state_table(first,end);
    while(1)
    {
        int a;
        cout<<"请输入进入内存的作业号（如果输入-1，结束程序）："<<endl;
        cin>>a;
        if(a==-1) break;
        cout<<"请输入进入内存的作业大小："<<endl;
        cin>>x[a].size;
        cout<<"请输入进入内存的作业运行时间："<<endl;
        cin>>x[a].time;
        if(search_memory(a))
        {
            cout<<"此作业不能二次进入内存！"<<endl;
            continue;
        }
        if(search_state_table(a,x[a].size,first,end));
        else
        {
            cout<<"无足够内存加载作业，进行内存回收"<<endl;
            recovery();
            delete_state_table(first,end);
            new_state_table(first,end);
            if(search_state_table(a,x[a].size,first,end));
            else cout<<"回收完毕，仍无足够内存，此作业不能加入内存"<<endl;
        }
    }
    delete_state_table(first,end);
    delete first;
    delete end;
    return 0;
}

int search_memory(int n)
{
    n++;
    for(int i=0;i<1024;i++)
    {
        if(n==memory[i]) return 1;
    }
    return 0;
}

void new_state_table(state_table *first,state_table *end)
{
    for(int i=1023;i>=0;i--)
    {
        if(memory[i]==0)
        {
            int k=0;
            int j=i;
            for(;j>=0;j--)
            {
                if(memory[j]==0) k++;
                else break;
            }
            state_table *temp;
            temp=new state_table;
            temp->address=i+1-k;
            temp->size=k;
            temp->next=first->next;
            first->next=temp;
            i=j;
        }
    }
}

int search_state_table(int a,int size,state_table *first,state_table *end)
{
    state_table *t;
    t=first->next;
    while(t->next!=NULL)
    {
        if(t->size>=size)
        {
            int i=0;
            for(;i<size;i++)
            {
                memory[t->address+i]=a+1;
            }
            start[a]=clock();
            cout<<"进程"<<a<<"已加载进内存。"<<endl;
            t->address=i;
            t->size-=size;
            return 1;
        }
        t=t->next;
    }
    return 0;
}

void recovery()
{
    int i=0,j;
    for(;i<1024;i++)
    {
        if(memory[i])
        {
            if((clock()-start[memory[i]-1])>=(x[memory[i]-1].time)*CLOCKS_PER_SEC)
            {
                for(j=i;j<i+x[memory[i]-1].size;j++)
                {
                    memory[j]=0;
                }
                i=j-1;
            }
        }
    }
}

void delete_state_table(state_table *first,state_table *end)
{
    state_table *t;
    t=first->next;
    while(t->next!=NULL)
    {
        first->next=t->next;
        delete t;
        t=first->next;
    }
}

• 内存动态分区分配和回收的模拟实现
  • 实验目的
  • 实验内容
  • 实验代码