精华内容
下载资源
问答
  • 动态分区存储管理

    千次阅读 2019-05-06 13:45:28
    动态分区存储管理 实验目的:熟悉并掌握动态分区分配的各种算法。 熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。 实验内容:用高级语言模拟实现动态分区存储管理,要求: 分区分配算法至少...

    动态分区存储管理

    实验目的:熟悉并掌握动态分区分配的各种算法。

              熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。

    实验内容:用高级语言模拟实现动态分区存储管理,要求:

    1. 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。
    2. 分区的初始化——可以由用户输入初始分区的大小。(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)
    3. 分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。
    4. 分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!)
    5. 分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)

    要求考虑:(1)内存空间不足的情况,要有相应的显示;

                       (2)作业不能同名,但是删除后可以再用这个名字;

                       (3)作业空间回收是输入作业名,回收相应的空间,如果这个作业名不存在,也要有相应的提示。

    此次代码实现了首次适应算法、最佳适应算法。

    #include<bits/stdc++.h>
    #include<iostream>
    #include<cstring>
    #include<string>
    #include<queue>
    #include<stack>
    #include<algorithm>
    using namespace std;
    int Maxsize;
    int k[50];
    typedef struct LinkNode
    {
        bool flage;//1为分配 0为空闲
        string name;
        int start;//起始地址
        int size;
        LinkNode *front;//前指针
        LinkNode *next;//后指针
    } LinkList;
    LinkList *line = new LinkList;
    
    
    void init()//初始化
    {
        line->flage = 0;
        line->name = "free";
        line->start = 0;
        line->size = Maxsize;
        line->front = NULL;
        line->next = NULL;
    }
    void show()
    {
        LinkList *lineshow = new LinkList;
        lineshow = line;
        cout <<"分配状态\t"<< "作业名称\t"<<"起始地址\t"<<"分区大小\t"<<endl;
    
        stack<LinkList*> a;
        while(lineshow!=NULL)
        {
            a.push(lineshow);
            lineshow = lineshow->next;
        }
        while (!a.empty())
        {
            LinkList *lin = new LinkList;
            lin=a.top();
            cout << lin->flage << "\t\t" << lin->name << "\t\t" << lin->start << "\t\t" << lin->size << endl;
            a.pop();
        }
    }
    
    void firstfit()
    {
        cout << "请输入申请的主存大小:  " << endl;
        cin >> Maxsize;
        init();//初始化
        show();//首次展示
        while (true)
        {
            string operate;//操作字符串
            LinkList *node = new LinkList;
            node->front = NULL;
            node->next = NULL;
            node->flage = 1;
            cout << "请求类型( 请输入申请或删除或over)" << endl;
            cin >> operate;
            if (operate.compare("over")==0)
            {
                cout << "此次首次适应算法分配结束!" << endl;
                return ;
            }
            if (operate == "申请")
            {
                cout << "请求进程名称" << endl;
                cin >> node->name;
                int flag=0;
                LinkList *adjust = new LinkList;
                adjust=line;
                while(adjust!=NULL)
                {
                    if(adjust->name==node->name)
                        flag=1;
                    adjust=adjust->next;
                }
                if(flag==1)
                {
                    cout<<"名字已经被使用,请重新输入!"<<endl;
                    cin >> node->name;
                }
                node->start = 0;
                cout << "请求大小" << endl;
                cin >> node->size;
                LinkList *index = new LinkList;
                index = line;
                while (index != NULL)
                {
                    if (index->flage==0 && index->size >= node->size)
                    {
                        node->start = index->start;
                        index->start = index->start+node->size;
                        index->size -= node->size;
                        if (index->next != NULL)
                        {
                            node->next=index->next;
                            index->next->front=node;
                        }
                        node->front = index;
                        index->next = node;
                        break;
                    }
                    index = index->next;
                }
                show();
            }
            else if (operate == "删除")
            {
                cout << "请求进程名称" << endl;
                cin >> node->name;
                LinkList *ad = new LinkList;
                ad=line;
                int flge=0;
                while(ad!=NULL)
                {
                    if(ad->name==node->name)
                        flge=1;
                    ad=ad->next;
                }
                if(flge==0)
                {
                    cout << "不存在该进程,请重新输入!" << endl;
                    cin >> node->name;
                }
                LinkList *op = new LinkList;
                op = line;
                while (op != NULL)
                {
                    if (op->name == node->name)
                    {
                        LinkList *q = new LinkList;
                        q->flage = 0;
                        q->name = "free";
                        q->start = 0;
                        q->size = Maxsize;
                        q->front = NULL;
                        q->next = NULL;
    
                        if (op->front != NULL)
                        {
                            q = op->front;
                            if (op->front->front != NULL)
                                q->front = op->front->front;
                            else
                                q->front = NULL;
                        }
                        if (!q->flage) //空 op 空 的情况
                        {
                            q->size += op->size;
                            q->start=min(q->start,op->start);
                            op->flage=0;
                            if (op->next != NULL && !op->next->flage)
                            {
                                q->size += op->next->size;
                                q->start=min(q->start,op->next->start);
                                if (q->next->next->next != NULL)
                                {
                                    q->next->next->next->front = q;
                                    q->next = q->next->next->next;
                                }
                                else
                                {
                                    q->next = NULL;
                                    op=q->next;
                                    break;
                                }
                            }
                            else if(q->front!=NULL && !q->front->flage)//空 空 op
                            {
                                q->size += q->front->size;
                                q->start=min(q->start,q->front->size);
    
                            }
                            else if (op->next != NULL)
                            {
                                q->next = op->next;
                                op->next->front=q;
                            }
                            op = q->next;
                            cout<<op->name<<" "<<endl;
                        }
                        else if (op->next != NULL && !op->next->flage)//op 空
                        {
                            op->size += op->next->size;
                            op->start=min(op->next->start,op->start);
                            op->flage = 0;
                            op->name = "free";
                            if (op->next->next != NULL)
                            {
                                op->next->next->front = op;
                                op->next = op->next->next;
                            }
                            else
                                op->next=NULL;
                        }
                        else if (((op->front != NULL && op->front->flage) || (op->front == NULL) && ((op->next != NULL && op->next->flage) || (op->next == NULL))))//单独op
                        {
                            op->flage = 0;
                            op->name = "free";
                        }
                        if(op->front != NULL && op->next==NULL && !op->front->flage && node->name == op->name)
                        {
                            op->flage = 0;
                            op->name = "free";
                            op->front->next=NULL;
                        }
                    }
                    op = op->next;
                }
                show();
            }
        }
    }
    void bestfit()
    {
        cout << "请输入申请的主存大小:  " << endl;
        cin >> Maxsize;
        init();//初始化
        show();//首次展示
        while (true)
        {
            string operate;//操作字符串
            LinkList *node = new LinkList;
            node->front = NULL;
            node->next = NULL;
            node->flage = 1;
            cout << "请求类型( 请输入申请或删除或 over)" << endl;
            cin >> operate;
            if (operate.compare("over")==0)
            {
                cout << "此次最佳适应算法分配结束!" << endl;
                return ;
            }
            if (operate == "申请")
            {
                cout << "请求进程名称" << endl;
                cin >> node->name;
                LinkList *adjust = new LinkList;
                adjust=line;
                int flag=0;
                while(adjust!=NULL)
                {
                    if(adjust->name==node->name)
                        flag=1;
                    adjust=adjust->next;
                }
                if(flag==1)
                {
                    cout<<"名字已经被使用,请重新输入"<<endl;
                    cin >> node->name;
                }
                node->start = 0;
                cout << "请求大小" << endl;
                cin >> node->size;
                memset(k,0,sizeof(k));
                int i = 0;
                int ok;
                LinkList *order = new LinkList;
                order = line;
                while (order != NULL)
                {
                    if(!order->flage)
                        k[i++] = order->size;
                    order=order->next;
                }
                sort(k, k + i);
                for (int j = 0; j < i; j++)
                {
                    if (k[j] >= node->size)
                    {
                        ok = k[j];
                        break;
                    }
                }
                LinkList *q = new LinkList;
                q->front = NULL;
                q->next = NULL;
                q->size = 0;
                q->flage = 0;
                q->start = 0;
                q->name = node->name;
    
                LinkList *p = new LinkList;
                p = line;
                i = 0;
                while (p != NULL)
                {
                    if (p->size==ok)
                    {
                        q = p;
                        break;
                    }
                    p = p->next;
                }
    
                if (q->size >= node->size)
                {
                    node->start = q->start;
                    q->start = q->start+node->size;
                    q->size -= node->size;
                    cout << node->start << "  " << q->size << "  " << line->size << endl;
                    if (q->next != NULL)
                    {
                        node->next = q->next;
                        q->next->front = node;
                    }
                    else
                    {
                        node->next = NULL;
                    }
                    node->front = q;
                    q->next = node;
                }
                else
                {
                    cout << "申请失败!!!" << endl;
                }
                show();
            }
            else if (operate == "删除")
            {
                cout << "请求进程名称" << endl;
                cin >> node->name;
                LinkList *ad = new LinkList;
                ad=line;
                int flge=0;
                while(ad!=NULL)
                {
                    if(ad->name==node->name)
                        flge=1;
                    ad=ad->next;
                }
                if(flge==0)
                {
                    cout << "不存在该进程,请重新输入!" << endl;
                    cin >> node->name;
                }
                LinkList *op = new LinkList;
                op = line;
                while (op != NULL)
                {
                    if (op->name == node->name)
                    {
                        cout<<op->name<<" "<<endl;
                        LinkList *q = new LinkList;
                        q->flage = 0;
                        q->name = "free";
                        q->start = 0;
                        q->size = Maxsize;
                        q->front = NULL;
                        q->next = NULL;
    
                        if (op->front != NULL)
                        {
                            q = op->front;
                            cout<<q->name<<" "<<q->flage<<endl;
                            if (op->front->front != NULL)
                                q->front = op->front->front;
                            else
                                q->front = NULL;
                        }
                        if (!q->flage) //空 op 空 的情况
                        {
                            q->size += op->size;
                            q->start=min(q->start,op->start);
                            op->flage=0;
                            if (op->next != NULL && !op->next->flage)
                            {
                                q->size += op->next->size;
                                q->start=min(q->start,op->next->start);
                                if(q->next->next->next != NULL)
                                {
                                    q->next->next->next->front = q;
                                    q->next = q->next->next->next;
                                }
                                else
                                {
                                    q->next = NULL;
                                    op=q->next;
                                    break;
                                }
                            }
                            else if(q->front!=NULL && !q->front->flage)//空 空 op
                            {
                                q->size += q->front->size;
                                q->start=min(q->start,q->front->size);
    
                            }
                            else if (op->next != NULL)
                            {
                                q->next = op->next;
                                op->next->front=q;
                            }
                            op = q->next;
                        }
                        else if (op->next != NULL && !op->next->flage)//op 空
                        {
                            op->size += op->next->size;
                            op->start=min(op->next->start,op->start);
                            op->flage = 0;
                            op->name = "free";
                            if (op->next->next != NULL)
                            {
                                op->next->next->front = op;
                                op->next = op->next->next;
                            }
                            else
                                op->next=NULL;
                        }
                        else if (((op->front != NULL && op->front->flage) || (op->front == NULL) && ((op->next != NULL && op->next->flage) || (op->next == NULL))))//单独op
                        {
                            op->flage = 0;
                            op->name = "free";
    
                        }
                        if(op->front != NULL && op->next==NULL && !op->front->flage && node->name == op->name)
                        {
                            op->flage = 0;
                            op->name = "free";
                            op->front->next=NULL;
                        }
                    }
                    op = op->next;
                }
                show();
            }
        }
    }
    
    int  main()
    {
        cout << "      本次为动态内存分配算法" << endl;
        cout << " 请选择算法1.首次适应算法2.最佳适应算法" << endl;
        int n;
        scanf("%d",&n);
        switch(n)
        {
        case 1:
            firstfit();
            break;
        case 2:
            bestfit();
            break;
        default :
            cout<<"请输入正确的序号!"<<endl;
        }
        return 0;
    }
    

     

    展开全文
  • 任务:用高级语言模拟实现动态分区存储管理。 二、内容、要求与安排 1、实验内容 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 分区的初始化...

    一、目的与任务
    目的:熟悉并掌握动态分区分配的各种算法,熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。
    任务:用高级语言模拟实现动态分区存储管理。
    二、内容、要求与安排
    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
    */
    
    
    展开全文
  • 任务:用高级语言模拟实现动态分区存储管理。 二、实验内容: 1、实验内容 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 分区的初始化——...

    一、 实验目的:
    目的:熟悉并掌握动态分区分配的各种算法,熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。

    任务:用高级语言模拟实现动态分区存储管理。
    二、实验内容:

    1、实验内容

    分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。

    分区的初始化——可以由用户输入初始分区的大小。(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)

    分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。
    分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!)

    分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)。

    2、实验要求
    (1)内存空间不足的情况,要有相应的显示;
    (2)作业不能同名,但是删除后可以再用这个名字;
    (3)作业空间回收是输入作业名,回收相应的空间,如果这个作业名不存在,也要有相应的提示。
    (4)要求实现FF,BF,WF算法中至少两种算法

    实现代码:

    import copy
    class Memory(object):
        def __init__(self, start, end, length, state=1, ID=0):#__init__()方法是一种特殊的方法,被称为类的初始化方法,当创建这个类的实例时就会调用该方法
                                                              # self 代表类的实例,self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数
            self.start = start
            self.end = end
            self.length = length
            self.state = state  # state为1:内存未分配
            self.Id = ID  ##ID为0是未分配,其余为任务编号
    def show_memory(list):
        print("分配状态    分区号    起始地址   终止地址  分区大小")
        for i in range(0, len(list)):
            p = list[i]
            if p.state == 1:
                print("%s%s%s%11.d%11.d%10.d"%('空闲',"          ", p.Id,  p.start, p.end, p.length))
            else:
                print("%s%s%s%11.d%11.d%10.d"%('已分配',"        ", p.Id,  p.start, p.end, p.length))
    # 首次适应算法
    def FF(work_id, work_length, list):
    
        for i in list:
            if i.Id == work_id:
                print('作业已存在')
                return
        for i in range(0, len(list)):
            p = list[i]
            if p.state == 1 and p.length > work_length:  # p是当前未分配内存的大小
                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 剩下的未分配的
                a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)  # a是已分配的
                del list[i]
                list.insert(i, node2)
                list.insert(i, a)
                show_memory(list)
                return
            if p.state == 1 and p.length == work_length:
                p.state = 0
                show_memory(list)
                return
        print("内存空间不足")
    def free1(work_id, li):
        for i in range(0, len(li)):
            p = li[i]
            if p.Id == work_id:
                p.state = 1
                target = i
                p.Id=0
                break
        # 向前合并空闲块
        if target - 1 > 0:
            if li[target - 1].state == 1:
    
                a = Memory(li[target - 1].start, li[target].end, li[target - 1].length + li[target].length, 1, 0)
                del li[target - 1]
                del li[target - 1]
                li.insert(target - 1, a)
                target = target - 1
        # 向后合并空闲块
        if target + 1 < len(li):
            if li[target + 1].state == 1:
                a = Memory(li[target].start, li[target + 1].end, li[target].length + li[target + 1].length, 1, 0)
                del li[target]
                del li[target]
                li.insert(target, a)
        show_memory(li)
    ##最佳适应算法
    def bubble_sort(list):
        # 冒泡排序
        count = len(list)
        for i in range(0, count):
            for j in range(i + 1, count):
                if list[i].length < list[j].length:
                    list[i], list[j] = list[j], list[i]
        return list
    def BF(work_id, work_length, li):
        for i in li:
            if i.Id == work_id:
                print('作业已存在')
                return
        q = copy.copy(li)
        q = bubble_sort(q)  # 从小到大排序,给所有已分配和未分配的排序
        s = -1
        ss12 = -1
        for i in range(0, len(q)):
            p = q[i]
            if p.state == 1 and p.length > work_length:  # p.state == 1 已分配的不参与分配
                s = p.start  # s得到起始位置
            elif p.state == 1 and p.length == work_length:
                ss12 = p.start
        if s == -1 and ss12 == -1:
            print("内存空间不足")
            return
        for i in range(0, len(li)):
            p = li[i]
            if p.start == s:
                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 未分配
                a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)
                del li[i]
                li.insert(i, node2)
                li.insert(i, a)
                show_memory(li)
                return
            elif p.start == ss12:
                p.state = 0
                show_memory(li)
                return
    if __name__ == '__main__':
        print("输入内存大小:")
        size = int(input())
        a = Memory(0, size - 1, size, state=1, ID=0)
        b = []
        b.append(a)
        print('*******1:初始化******')
        print('*******2:分配空间****')
        print('*******3:回收********')
        print('*******4:查看********')
        print('*******5:退出********')
        while (True):
            select = input('请输入想要执行的功能:')
            if select == '5':
                break
            elif select == '1':
                print("输入内存大小:")
                size = int(input())
                a = Memory(0, size - 1, size, state=1, ID=0)
                b = []
                b.append(a)
            elif select == '2':
                print("1.首次适应算法:FF")
                print("2.最佳适应算法:BF")
                x = input("请输入分配执行的算法:")
                x = float(x)
                repit = 'Y'
                while (repit == 'Y'):
                    if x == 1:
                        work_size = input('请输入作业id和大小:').split()
                        FF(work_size[0], int(work_size[1]), b)
                        repit = input('是否继续Y/N')
                    elif x == 2:
                        work_size = input('请输入作业id和大小:').split()
                        BF(work_size[0], int(work_size[1]), b)
                        repit = input('是否继续Y/N')
            elif select == '3':
                id_delete = input('请输入删除作业id:')
                free1(id_delete, b)
            else:
                show_memory(b)
    

    在这里插入图片描述

    展开全文
  • 动态分区存储管理模拟系统 几周前,我写了一篇文章,解释了如何使用Kubernetes创建Neo4j因果集群,以及……我想弄清楚如何模拟网络分区,该分区将使领导者处于少数席位并迫使选举。 我们已经使用iptables命令在...

    动态分区存储管理模拟系统

    几周前,我写了一篇文章,解释了如何使用Kubernetes创建Neo4j因果集群,以及……我想弄清楚如何模拟网络分区,该分区将使领导者处于少数席位并迫使选举。

    我们已经使用iptables命令在AWS的内部工具上完成了此操作,但是不幸的是,在我的容器中不可用,该容器仅具有BusyBox提供的实用程序。

    幸运的是,其中之一是route命令,它将使我们能够实现相同的目的。

    回顾一下,我有3个Neo4j Pod已启动并正在运行:

    $ kubectl get pods
    NAME      READY     STATUS    RESTARTS   AGE
    neo4j-0   1/1       Running   0          6h
    neo4j-1   1/1       Running   0          6h
    neo4j-2   1/1       Running   0          6h

    我们可以检查route命令是否可用:

    $ kubectl exec neo4j-0 -- ls -alh /sbin/route 
    lrwxrwxrwx    1 root     root          12 Oct 18 18:58 /sbin/route -> /bin/busybox

    让我们看一下每个服务器当前扮演的角色:

    $ kubectl exec neo4j-0 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "FOLLOWER"
     
    Bye!
    $ kubectl exec neo4j-1 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "FOLLOWER"
     
    Bye!
    $ kubectl exec neo4j-2 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "LEADER"
     
    Bye!

    稍微说一下:我可以在没有用户名和密码的情况下调用cypher-shell ,因为我通过将以下内容放在conf / neo4j.conf中来禁用授权:

    dbms.connector.bolt.enabled=true

    回到网络分区……我们需要通过运行以下命令将neo4j-2与其他两台服务器分开

    $ kubectl exec neo4j-2 -- route add -host neo4j-0.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-2 -- route add -host neo4j-1.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-0 -- route add -host neo4j-2.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-1 -- route add -host neo4j-2.neo4j.default.svc.cluster.local reject

    如果我们查看neo4j-2的日志,可以看到它与其他两台服务器断开连接后已退出:

    $ kubectl exec neo4j-2 -- cat logs/debug.log
    ...
    2016-12-04 11:30:10.186+0000 INFO  [o.n.c.c.c.RaftMachine] Moving to FOLLOWER state after not receiving heartbeat responses in this election timeout period. Heartbeats received: []
    ...

    谁被接任领导?

    $ kubectl exec neo4j-0 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "LEADER"
     
    Bye!
    $ kubectl exec neo4j-1 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "FOLLOWER"
     
    Bye!
    $ kubectl exec neo4j-2 -- bin/cypher-shell "CALL dbms.cluster.role()"
    role
    "FOLLOWER"
     
    Bye!

    看起来像neo4j-0! 让我们将一些数据放入数据库中:

    $ kubectl exec neo4j-0 -- bin/cypher-shell "CREATE (:Person {name: 'Mark'})"
    Added 1 nodes, Set 1 properties, Added 1 labels
     
    Bye!

    让我们检查该节点是否到达其他两个服务器。 我们希望它在neo4j-1上,而不在neo4j-2上:

    $ kubectl exec neo4j-1 -- bin/cypher-shell "MATCH (p:Person) RETURN p"
    p
    (:Person {name: "Mark"})
     
    Bye!
    $ kubectl exec neo4j-2 -- bin/cypher-shell "MATCH (p:Person) RETURN p"
     
     
    Bye!

    在neo4j-2上,当其选举超时触发时,我们将在日志中反复看到这些类型的条目,但无法获得对其发出的投票请求的任何响应:

    $ kubectl exec neo4j-2 -- cat logs/debug.log
    ...
    2016-12-04 11:32:56.735+0000 INFO  [o.n.c.c.c.RaftMachine] Election timeout triggered
    2016-12-04 11:32:56.736+0000 INFO  [o.n.c.c.c.RaftMachine] Election started with vote request: Vote.Request from MemberId{ca9b954c} {term=11521, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467} and members: [MemberId{484178c4}, MemberId{0acdb8dd}, MemberId{ca9b954c}]
    ...

    我们通过查看raft-messages.log可以看到那些投票请求,可以通过在conf / neo4j.conf中设置以下属性来启用:

    causal_clustering.raft_messages_log_enable=true
    $ kubectl exec neo4j-2 -- cat logs/raft-messages.log
    ...
    11:33:42.101 -->MemberId{484178c4}: Request: Vote.Request from MemberId{ca9b954c} {term=11537, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
    11:33:42.102 -->MemberId{0acdb8dd}: Request: Vote.Request from MemberId{ca9b954c} {term=11537, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
     
    11:33:45.432 -->MemberId{484178c4}: Request: Vote.Request from MemberId{ca9b954c} {term=11538, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
    11:33:45.433 -->MemberId{0acdb8dd}: Request: Vote.Request from MemberId{ca9b954c} {term=11538, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
     
    11:33:48.362 -->MemberId{484178c4}: Request: Vote.Request from MemberId{ca9b954c} {term=11539, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
    11:33:48.362 -->MemberId{0acdb8dd}: Request: Vote.Request from MemberId{ca9b954c} {term=11539, candidate=MemberId{ca9b954c}, lastAppended=68, lastLogTerm=11467}
    ...

    要“修复”网络分区,我们只需要删除我们之前运行的所有命令:

    $ kubectl exec neo4j-2 -- route delete neo4j-0.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-2 -- route delete neo4j-1.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-0 -- route delete neo4j-2.neo4j.default.svc.cluster.local reject && \
      kubectl exec neo4j-1 -- route delete neo4j-2.neo4j.default.svc.cluster.local reject

    现在,让我们检查一下neo4j-2现在是否具有我们先前创建的节点:

    $ kubectl exec neo4j-2 -- bin/cypher-shell "MATCH (p:Person) RETURN p"
    p
    (:Person {name: "Mark"})
     
    Bye!

    目前为止就这样了!

    翻译自: https://www.javacodegeeks.com/2016/12/kubernetes-simulating-network-partition.html

    动态分区存储管理模拟系统

    展开全文
  • 深入了解动态分区存储管理方式主存分配回收的实现。 二.实验要求 1.使用动态分区存储管理方式分配回收内存。 2.使用最优适应算法完成主存空间的分配。 3.输出空闲表,分配表,内存的分配情况。 三.实验设计 ...
  • 今天上机要求Linux下实现动态分区存储管理的内存分别配回收现在把源码贡献出来 #include<stdlib.h> #include <stdio.h> #include <string.h> #define MAX 600 //设置总内存大小为512k ...
  • 动态分区存储管理: 首次适应--最佳适应-最坏适应算法1.背景多个应用程序请求主存空间是一个多对多的问题,在分区存储分配方法中由多个空闲区组成了空闲队列。对一个要进入主存的应用程序而言,主存分配程序在多个...
  • 操作系统:动态分区存储管理

    千次阅读 2020-05-17 17:09:04
    致读者: 博主是一名数据科学与大数据专业大二的学生,真正的一个互联网萌新,写博客...熟悉并掌握动态分区分配的各种算法,熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。用高级语言模拟实现动态分区.
  • 分区存储管理又有三种不同的方式:静态分区、可变分区、可重定位分区 。 静态分区 静态分区存储管理是预先把可分配的主存储器空间分割成若干个连续区域,每个区域的大小可以相同,也可以不同。为了说明各分区的...
  • 杨哥视频资源存储管理Ⅱ逻辑卷的创建lvm在线扩容 lvm缩容、删除lv(课下作业) swap交换分区文件系统修复mount命令详解链接文件一、逻辑卷LVMLVM管理理论: LVM:逻辑分区管理 PV(physical volume):物理卷在逻辑卷管理...
  • 初始状态:动态分区管理方式预先不将主存划分区域。而是把主存除操作系统占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区。并按照特定的算法选择一合适的空闲区,按...
  • 设物理内存320KB,输入进程名,进程长度,到达时间以及执行时间来自动模拟动态分区管理,并显示可用表与分区说明表的变化情况 例如: 进程 进程长度(KB) 到达时间 执行...
  • Python|模拟实现动态分区存储管理 完整代码 free_list = [] allocated_list = [] class FreeAreaTable: # 空闲区表 def __init__(self, start, length, status): ''' :param start: 起址 :param length: 长度 :param...
  • 1. 古老方法之单道程序存储管理内存分为系统区和用户区,每次装一个程序到用户区,和操作系统共享内存;运行结束后再装另一个程序把它覆盖。优点:简单、开销小、易于管理,适用于单用户、单任务OS。缺点:不能并行...
  • 初始状态:动态分区管理方式预先不将主存划分区域。而是把主存除操作系统占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区。并按照特定的算法选择一合适的空闲区,按...
  • 操作系统的内存的分配与回收连续存储管理主要介绍了,内存管理中连续存储管理的三种方法,重点掌握动态分区分配的分配算法。主要的重点冷月做出了标识,知识点如下图(pdf版或xmind源文件请私聊我:操作系统)。冷月点...
  • ////////////////////////////////////////////////////////////// 功能:// 《计算机操作系统》实验// 首次适应性算法// 摸拟 动态分区 存储管理方式的主存 分配 和 回收// 时间:// 2005-11-14/////////////////...
  • 此次查错结论:对于单链表节点删除要考虑 :该节点是 表头,表尾,还是表间的节点 。对于一个指针不对其申请内存,该指针是空的。对空指针去进行操作会导致程序崩溃的。#include #include #include ...
  • #!/usr/bin/python ... #空闲分区表 #0:开始地址 1:长度 freeTable = [] #占用分区表 #0:程序名 1:开始地址 2:长度 useTable = [] def __init__(self): print '初始化内存使用情况...
  • 动态分区分配存储管理 目录 1、 课程设计任务、要求、目的…3 1.1 课程设计任务…3 1.2 课程设计目的和要求…3 2、 开发环境…3 3、 相关原理及算法…3 3.1 首次适应算法…3 3.2 循环首次适应算法…4 3.3 最佳适应...
  • 可变分区存储管理:1、可变分区:为了解决固定分区因作业装入前,分区的数量和大小确定而造成的内部碎片问题,所以引入了可变分区存储管理。目的就是根据作业对存储空间实际的需求量来划分存储分区。也就是每一个...
  • 动态分区存储管理模拟系统

    千次阅读 2015-08-22 00:07:37
    设计题目三:动态分区存储管理模拟系统 —— 一、设计题目要求  1、对理论课中学习的内存管理当中的概念做进一步的理解;  2、了解内存管理任务的主要实现方法;  3、掌握内存的分配,回收等主要算法...
  • 实验:动态分区式存储管理实验内容:编写程序模拟完成动态分区存储管理方式的内存分配和回收。实验具体包括:首先确定内存空闲分配表;然后采用最佳适应算法完成内存空间的分配和回收;最后编写主函数对所做工作进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 929
精华内容 371
关键字:

动态分区存储管理