操作系统:模拟内存回收算法

简介: 操作系统:模拟内存回收算法

内存回收有四种情况:


32efe56944354153a1cdcfa3eaab9e29.png

实例:某系统内存容量为800K,下 面分别给出中的空闲分区表和分配分区表,系统采用动

态分区存储管理策略。现有按照如下顺序释放作业空间:


(1)释放作业:Task2[情况D];


(2)释放作业:Task4 [情况A];


(3)释放作业:Task6[情况B];


(4)释放作业:Task7[情况C];


(5)释 放作业:Task9 [不存在]


并打印每次回收分配空间后的空闲分区表和分配分区表。


分配分区表:


image.png


空闲分区表:


2c6515c4ce7945629ca8d4d3b64ee4b6.png

1.动态地任意顺序输入“分配分区表项”,按照地址递增方式建立“分配分区表”:

输入:


2d819e09940f4ba4a62c45aca3c50a54.png


2. 动态地任意顺序输入“空闲分区表项"”,按照地址递增方式建立“空闲分区表”

输入:

7f8a718e475c4c7b856fab6007245b6b.png


3.共内存回收5次:

输入:

e18a93b3b637401bb213e37e73f5672c.png


4.回收内存分配区,模拟第一次内存回收:TASK2 【情况D】

输入:

 6eda7dec7bf84ca1a840f388ea19f046.png


分配成功,输出:

81ab780f1a5d4001b3aa65f4a4039806.png


回收内存分配区,模拟第二次内存回收: Task4 , 【情况A】。

输入:

0e7d5185ed7e408fb36c3c81b78a1a80.png

分配成功,输出:

24b1cb28de9f432690bbc238c271154a.png


回收内存分配区,模拟第三次内存回收: Task6 [ 情况B]。

输入:

0a73f56a62c041dcb4aa46bba55fbfb5.png

分配失败,输出:

eaae04606c9348f0b7f3d32a3d19252e.png

回收内存分配区,模拟第四次内存回收: Task7 , 【情况C】。

输入:

dd7361f0b7fa44b18d0d7a5ace85ff56.png


分配成功,输出:

a61fba2573a74ecbaebc5cf8bb6c0e0d.png


回收内存分配区,模拟第五次内存回收: Task9[ 不存在 ]。

输入:

e546f5bb1b0e467eb1f9b36fa9ac9def.png


分配成功,输出:

7e643b92fabf4fe2967c71c5b077cf36.png


实现代码 :

#include <malloc.h>
#include <stdio.h>
#include <string.h>
#define NULL 0
typedef struct table
{
    int address; /*存储分区起始地址*/
    int length; /*存储分区长度*/
    int flag; /*存储分区标志,0 为空闲,1 为被作业占据*/
    char name[10]; /*当 flag==1 时存储分区占用标志作业名,否则存储空 nil*/
    struct table *next;
} node;
node *work; /*设置一个全局变量 work:定位需要释放的结点*/
char type; /*设置一个全局变量 type:标注回收类型*/
bool success; /*设置一个全局变量 success:标注回收结点是否在分配分区表中*/
void insert(node *head, node *p) /*按照“地址递增方式”将 p 结点插入链表相应位置*/
{
    node *q,*w;
    if(head->next->address>p->address)
    {
        p->next=head->next;
        head->next=p;
        return;
    }
    q=head->next->next;
    w=head->next;
    while(q)
    {
        if(q->address>p->address)
            break;
        w=q;
        q=q->next;
    }
    w->next=p;
    p->next=q;
    return;
}
node *creat() /*根据地址递增方式建立分配分区表(flag==1)或空闲分区表(flag==0)*/
{
    printf("address length flag(0 or 1):\n");
    node *head,*p;
    head=NULL;
    head=(node *)malloc(sizeof(node));
    head->next=NULL;
    int a,b,c;
    if(head->next==NULL)
    {
        p=(node *)malloc(sizeof(node));
        scanf("%d%d%d",&a,&b,&c);
        if(a==0&&b==0)
            return head;
        p->address=a;
        p->length=b;
        p->flag=c;
        if(p->flag==1)
        {
            printf("\tinput job_name:");
            scanf("%s",p->name);
        }
        else
            strcpy(p->name,"nil");
        head->next=p;
        head->next->next=NULL;
    }
    while(scanf("%d%d%d",&a,&b,&c)!=EOF)
    {
        if(a==0&&b==0&&c==0)
            break;
        p=(node *)malloc(sizeof(node));
        p->address=a;
        p->length=b;
        p->flag=c;
        if(p->flag==1)
        {
            printf("\tinput job_name:");
            scanf("%s",p->name);
        }
        else
            strcpy(p->name,"nil");
        insert(head,p);
    }
    return head;
}
node *found(node *distributedhead,char workn[10]) /*查找已分配表中要回收的分区位置*/
{
    success=false;
    node *p,*q,*w;
    p=distributedhead->next;
    q=distributedhead;
    w=(node *)malloc(sizeof(node));
    w=NULL;
    while(p)
    {
        if(strcmp(p->name,workn)==0)
            break;
        q=p;
        p=p->next;
    }
    if(p)
    {
        success=true;
        w=p;
        w->flag=0;
        strcpy(w->name,"nil");
        q->next=p->next;
    }
    return w;
}
void release(node *freehead,node *work) /*分四种情况完成空闲分区回收过程*/
{
    if(freehead->next->address>(work->address+work->length))
    {
        printf("\nThe type of release is D!\n");
        work->next=freehead->next;
        freehead->next=work;
        return;
    }
    else if(freehead->next->address==(work->address+work->length))
    {
        printf("\nThe type of release is A!\n");
        freehead->next->address=work->address;
        freehead->next->length+=work->length;
        return;
    }
    node *p;
    p=freehead->next;
    while(p)
    {
        if(p->next&&work->address==(p->address+p->length)&&(work->address+work->length)<p->next->address)
        {
            printf("\nThe type of release is A!\n");
            p->length+=work->length;
            return;
        }
        if(p->next&&work->address==(p->address+p->length)&&(work->address+work->length)==p->next->address)
        {
            printf("\nThe type of release is C!\n");
            p->length+=p->next->length+work->length;
            p->next=p->next->next;
            return;
        }
        if(p->next&&work->address>(p->address+p->length)&&(work->address+work->length)==p->next->address)
        {
            printf("\nThe type of release is B!\n");
            p->next->address-=work->length;
            p->next->length+=work->length;
            return;
        }
        if(p->next&&work->address>(p->address+p->length)&&(work->address+work->length)<p->next->address)
        {
            printf("\nThe type of release is D!\n");
            work->next=p->next;
            p->next=work;
            return;
        }
        p=p->next;
    }
    work->next=(node *)malloc(sizeof(node));
    work->next=NULL;
    p=work;
    return;
}
void print (node *head) /*输出链表*/
{
    node *p;
    p=head->next;
    while(p)
    {
        printf("%d,%d,%d,%s\n",p->address,p->length,p->flag,p->name);
        p=p->next;
    }
}
int main()
{
    int i,sum;
    struct table *dtable,*ftable;
    char workn[10];
    printf("The distributed table is:\n");
    dtable=creat(); /*dtable 输入已分配情况表*/
    printf("The free table is:\n");
    ftable=creat(); /*ftable 输入未分配情况表*/
    /*以下模拟逐个内存回收过程*/
    printf("Input the released work segment sum:");
    scanf("%d",&sum);
    i=1;
    while(sum--)
    {
        printf("%d: input the released work segment name:",i++);
        scanf("%s",workn);
        work=(node *)malloc(sizeof(node));
        work=found(dtable,workn);
        if(success)
        {
            printf("\n要回收的分区存在!\n");
            release(ftable,work);
            printf("\ndistributed table is:\n");
            print(dtable);
            printf("\nfree table is:\n");
            print(ftable);
        }
        else
        {
            printf("\n要回收的分区不存在!\n");
        }
    }
    return 0;
}


目录
相关文章
|
13天前
|
程序员 开发者
分代回收和手动内存管理相比有何优势
分代回收和手动内存管理相比有何优势
|
1月前
|
缓存 算法 Java
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
这篇文章详细介绍了Java虚拟机(JVM)中的垃圾回收机制,包括垃圾的定义、垃圾回收算法、堆内存的逻辑分区、对象的内存分配和回收过程,以及不同垃圾回收器的工作原理和参数设置。
65 4
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
|
15天前
|
算法
虚拟内存的页面置换算法有哪些?
【10月更文挑战第25天】不同的页面置换算法各有优缺点,在实际应用中,操作系统会根据不同的应用场景和系统需求选择合适的页面置换算法,或者对算法进行适当的改进和优化,以平衡系统的性能、开销和资源利用率等因素。
35 5
|
21天前
|
算法 大数据 Linux
深入理解操作系统之进程调度算法
【10月更文挑战第24天】本文旨在通过浅显易懂的语言,带领读者深入了解操作系统中的进程调度算法。我们将从进程的基本概念出发,逐步解析进程调度的目的、重要性以及常见的几种调度算法。文章将通过比喻和实例,使复杂的技术内容变得生动有趣,帮助读者建立对操作系统进程调度机制的清晰认识。最后,我们还将探讨这些调度算法在现代操作系统中的应用和发展趋势。
|
24天前
|
并行计算 算法 IDE
【灵码助力Cuda算法分析】分析共享内存的矩阵乘法优化
本文介绍了如何利用通义灵码在Visual Studio 2022中对基于CUDA的共享内存矩阵乘法优化代码进行深入分析。文章从整体程序结构入手,逐步深入到线程调度、矩阵分块、循环展开等关键细节,最后通过带入具体值的方式进一步解析复杂循环逻辑,展示了通义灵码在辅助理解和优化CUDA编程中的强大功能。
|
1月前
|
算法 Java 程序员
内存回收
【10月更文挑战第9天】
43 5
|
1月前
|
分布式计算 算法 大数据
探索操作系统的核心:调度与内存管理机制
【10月更文挑战第11天】 本文深入探讨了操作系统中两大核心功能——调度与内存管理机制。通过分析调度算法、进程状态转换及内存分配策略等关键方面,揭示了它们如何共同维护系统性能和稳定性。旨在为读者提供对操作系统内部运作的深刻理解,同时引起对优化策略的思考。
59 5
|
1月前
|
Java 测试技术 Android开发
让星星⭐月亮告诉你,强软弱虚引用类型对象在内存足够和内存不足的情况下,面对System.gc()时,被回收情况如何?
本文介绍了Java中四种引用类型(强引用、软引用、弱引用、虚引用)的特点及行为,并通过示例代码展示了在内存充足和不足情况下这些引用类型的不同表现。文中提供了详细的测试方法和步骤,帮助理解不同引用类型在垃圾回收机制中的作用。测试环境为Eclipse + JDK1.8,需配置JVM运行参数以限制内存使用。
32 2
|
1月前
|
算法 调度 UED
深入理解操作系统的进程调度算法
【10月更文挑战第7天】在操作系统的心脏——内核中,进程调度算法扮演着至关重要的角色。它不仅影响系统的性能和用户体验,还直接关系到资源的合理分配。本文将通过浅显易懂的语言和生动的比喻,带你一探进程调度的秘密花园,从最简单的先来先服务到复杂的多级反馈队列,我们将一起见证算法如何在微观世界里编织宏观世界的和谐乐章。
|
1月前
|
算法 Java
JVM进阶调优系列(4)年轻代和老年代采用什么GC算法回收?
本文详细介绍了JVM中的GC算法,包括年轻代的复制算法和老年代的标记-整理算法。复制算法适用于年轻代,因其高效且能避免内存碎片;标记-整理算法则用于老年代,虽然效率较低,但能有效解决内存碎片问题。文章还解释了这两种算法的具体过程及其优缺点,并简要提及了其他GC算法。
 JVM进阶调优系列(4)年轻代和老年代采用什么GC算法回收?

热门文章

最新文章