操作系统实验三 动态分区存储管理

一、目的与任务
目的：熟悉并掌握动态分区分配的各种算法，熟悉并掌握动态分区中分区回收的各种情况，并能够实现分区合并。
任务：用高级语言模拟实现动态分区存储管理。
二、内容、要求与安排
1、实验内容
分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。
分区的初始化——可以由用户输入初始分区的大小。（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小）
分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。
分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。（注意：不存在的作业号要给出错误提示！）
分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大的分区时空闲的，或者占用的，能够显示出来）。
2、实验要求
（1）内存空间不足的情况，要有相应的显示；
（2）作业不能同名，但是删除后可以再用这个名字；
（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。
（4）要求实现FF、BF、WF算法中至少两种算法。
（5）实验完成后要参加实验答辩。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef struct job *List;
struct job
{
    int num;
    int m_begin;
    int m_size;
    int m_end;
    bool status;
    List Next;
    void set_date(int num, int m_begin, int m_size, bool status)
    {
        this->num = num;
        this->m_begin = m_begin;
        this->m_size = m_size;
        this->m_end = m_begin + m_size - 1;
        this->status = status;
    }
};

List Using, Free;
int algType;
job *Map[10000];

void in_it();
void solve();
void FF();
void m_malloc();
void m_free();
void merge_check(List L, job* t);
void show();
List MakeEmpty();
void Insert(List L, job *t);
void Delete(List L, job *t);
int menu();

int main()
{
    in_it();
    solve();

}

void in_it()
{
    Using = MakeEmpty();
    Free = MakeEmpty();
    for(int i=0; i<10000; i++)
        Map[i] = NULL;
    printf("Input memory size:");
    int m;
    while(scanf("%d", &m), m<=0)
        printf("!!! Illegal, input again:");
    job *t = (job*)malloc(sizeof(struct job));
    t->set_date(-1, 0, m, false);
    t->Next = NULL;
    Insert(Free, t);
}
void solve()
{
    printf("FF,1\n");
    printf("WF,2\n");
    while(scanf("%d", &algType), algType!=1&&algType!=2)
        printf("!!! Illegal, input again:");
    int flag;
    while( (flag = menu()) )
    {
        switch(flag)
        {
        case 1:
            m_malloc();
            break;
        case 2:
            m_free();
            break;
        case 3:
            show();
            break;
        case -1:
            printf("!!! Illegal, input again:\n");
            break;
        }
    }
}
void m_malloc()
{
    int num, m_size;
    printf("Input job num and size:");
    scanf("%d%d", &num, &m_size);
    if(Map[num] != NULL)
    {
        printf("!!! Num repeat, input again:\n");
        return;
    }
    List Temp = Free;
    if(algType == 1)
    {
        while(Temp->Next != NULL)
        {
            Temp = Temp->Next;
            if(Temp->m_size >= m_size)
            {
                job *t = (job*)malloc(sizeof(struct job));
                t->set_date(num, Temp->m_begin, m_size, true);
                t->Next = NULL;
                Map[num] = t;
                Insert(Using, t);
                Temp->m_begin += m_size;
                Temp->m_size -= m_size;
                if(Temp->m_size == 0)
                    Delete(Free, Temp);
                printf("Create succeed\n");
                return;
            }
        }
    }
    else
    {
        job* Max = Temp;
        while(Temp->Next != NULL)//与FF唯一的区别就是在空闲内存块中取内存最大的
        {
            Temp = Temp->Next;
            if(Temp->m_size >= Max->m_size)
                Max = Temp;
        }
        Temp = Max;
        if(Temp->m_size >= m_size)
        {
            job *t = (job*)malloc(sizeof(struct job));
            t->set_date(num, Temp->m_begin, m_size, true);
            t->Next = NULL;
            Map[num] = t;
            Insert(Using, t);
            Temp->m_begin += m_size;
            Temp->m_size -= m_size;
            if(Temp->m_size == 0)
                Delete(Free, Temp);
            printf("Create succeed\n");
            return;
        }
    }
    printf("!!! Memory full\n");
}
void m_free()
{
    int num;
    printf("Input job num:");
    scanf("%d", &num);
    if(Map[num] == NULL)
    {
        printf("!!! Num miss, input again:\n");
        return;
    }
    job* Temp = Map[num];

    job *t = (job*)malloc(sizeof(struct job));
    t->set_date(-1, Temp->m_begin, Temp->m_size, false);
    t->Next = NULL;
    Insert(Free, t);
    Delete(Using, Temp);
    Map[num] = NULL;
    printf("Free succeed\n");
    merge_check(Free, t);
}
void merge_check(List L, job* t)
{
    List Temp = L;
    while(Temp->Next != t)
        Temp = Temp->Next;
    if(t->Next != NULL && t->m_end+1 == t->Next->m_begin)//向下合并
    {
        t->m_end = t->Next->m_end;
        t->m_size += t->Next->m_size;
        t->Next = t->Next->Next;
        printf("Down Merge succeed\n");
    }
    if(Temp->m_end+1 == Temp->Next->m_begin)//向上合并
    {
        Temp->m_end = t->m_end;
        Temp->m_size += t->m_size;
        Temp->Next = t->Next;
        free(t);
        printf("Up Merge succeed\n");
    }
}
void show()
{
    printf("%s\t%s\t%s\t%s\t%s\n", "num", "begin", "end", "size", "use");
    List t1 = Using->Next, t2 = Free->Next;
    while(t1 != NULL && t2 != NULL)
    {
        if(t1->m_begin < t2->m_begin)
        {
            printf("%d\t%d\t%d\t%d\t%d\n", t1->num, t1->m_begin, t1->m_end, t1->m_size, t1->status);
            t1 = t1->Next;
        }
        else
        {
            printf("%d\t%d\t%d\t%d\t%d\n", t2->num, t2->m_begin, t2->m_end, t2->m_size, t2->status);
            t2 = t2->Next;
        }
    }
    while(t1 != NULL)
    {
        printf("%d\t%d\t%d\t%d\t%d\n", t1->num, t1->m_begin, t1->m_end, t1->m_size, t1->status);
        t1 = t1->Next;
    }
    while(t2 != NULL)
    {
        printf("%d\t%d\t%d\t%d\t%d\n", t2->num, t2->m_begin, t2->m_end, t2->m_size, t2->status);
        t2 = t2->Next;
    }
}

List MakeEmpty()
{
    List L;
    L = (List)malloc(sizeof(struct job));
    L->Next = NULL;
    return L;
}
void Insert(List L, job *t)
{
    if(L->Next == NULL)
    {
        L->Next = t;
        return;
    }
    List Temp = L;
    while(t->m_begin > Temp->Next->m_begin)
    {
        Temp = Temp->Next;
        if(Temp->Next == NULL)
        {
            Temp->Next = t;
            return;
        }
    }
    t->Next = Temp->Next;
    Temp->Next = t;
    return;
}
void Delete(List L, job *t)
{
    List Temp = L;
    while(Temp->Next != t)
        Temp = Temp->Next;
    Temp->Next = t->Next;
    free(t);
}

int menu()
{
    printf("--------------------\n");
    printf("Create:1\n");
    printf("Free:2\n");
    printf("View Info:3\n");
    printf("Over Input:0\n");
    printf("Plase Input A Num:");
    int m;
    scanf("%d",&m);
    switch(m)
    {
    case 0:
    case 1:
    case 2:
    case 3:
        return m;
        break;
    default:
        return -1;
    }

    return m;
}
/*
50
1
1 1 5
3
1 2 5
3
1 3 5
3
2 2
3
1 4 3
3
*/