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

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

内存回收有四种情况:


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;
}


目录
相关文章
|
3天前
|
算法 调度 UED
深入理解操作系统内存管理:原理与实践
【4月更文挑战第23天】 在现代计算机系统中,操作系统的内存管理是保证系统高效、稳定运行的关键组成部分。本文旨在深入探讨操作系统中内存管理的理论基础、关键技术以及实际操作过程,通过对内存分配策略、虚拟内存技术、分页与分段机制等核心概念的详细解析,为读者提供一个清晰、全面的内存管理视角。此外,文章还将通过案例分析,展示内存管理在解决实际问题中的应用,以期加深读者对操作系统内存管理复杂性的认识和理解。
|
18天前
|
算法 程序员
深入理解操作系统内存管理:分页系统的优势与挑战
【4月更文挑战第7天】 在现代操作系统中,内存管理是一项至关重要的任务,它确保了计算机能够高效、安全地运行各种程序。分页系统作为内存管理的一种技术,通过将物理内存分割成固定大小的单元——页面,为每个运行的程序提供了一种独立且连续的内存地址空间。该技术不仅简化了内存分配,还允许更高效的内存使用和保护。本文探讨了分页系统的核心原理,优势以及面临的挑战,旨在为读者揭示其在操作系统设计中的重要性。
|
1月前
|
监控 安全 算法
深入理解操作系统的内存管理机制
【2月更文挑战第30天】 本文旨在探讨操作系统中至关重要的一环——内存管理。与传统摘要不同,本文将直接点出核心议题:操作系统是如何通过复杂的数据结构和算法实现对计算机内存的有效管理和优化。文章将详细阐述内存管理的关键组成部分,包括内存分配、虚拟内存技术、分页和段机制等,并探讨它们如何共同协作以支持多任务处理和保护系统安全。通过对这些机制的深入了解,读者可以更好地把握操作系统设计之精髓及对现代计算环境的深远影响。
|
1月前
|
缓存 算法 内存技术
深入理解操作系统的内存管理
【2月更文挑战第30天】 在现代计算机系统中,操作系统的内存管理是确保系统高效稳定运行的关键。本文将深入探讨操作系统中的内存管理机制,包括物理内存与虚拟内存的映射关系、分页系统的工作原理以及内存分配策略等方面。通过本文,读者可以对操作系统如何处理复杂的内存请求有一个清晰的理解,并了解如何优化内存使用以提高整体系统性能。
|
1月前
|
缓存 分布式计算 算法
深入理解操作系统的内存管理
【2月更文挑战第30天】 本文旨在探讨操作系统中的内存管理机制,通过对其核心原理的剖析和现代操作系统中内存管理技术的讨论,提供一个全面且深入的视角。文章首先概述了内存管理的基本原理,然后详细分析了分页、分段以及段页式结合等技术,并探讨了虚拟内存的概念及其在现代操作系统中的应用。最后,文章还涉及了内存管理的优化策略和未来可能的发展趋势,为读者提供了一个关于操作系统内存管理的全景视图。
|
2天前
|
存储 算法
深入理解操作系统的内存管理机制
【4月更文挑战第24天】 在现代计算机系统中,操作系统扮演着资源管理者的角色,其中内存管理是其核心职责之一。本文将探讨操作系统如何通过内存管理提升系统性能和稳定性,包括物理内存与虚拟内存的概念、分页机制、内存分配策略以及内存交换技术。我们将透过理论与实践的结合,分析内存管理的关键技术及其对系统运行效率的影响。
|
9天前
|
存储 算法 数据安全/隐私保护
深入理解操作系统的内存管理机制
【4月更文挑战第17天】 在现代计算机系统中,操作系统扮演着资源管理者的角色,其中内存管理是其核心职能之一。本文探讨了操作系统内存管理的关键技术,包括虚拟内存、物理内存分配与回收、分页和分段机制,以及内存交换技术。通过分析这些机制的原理和实现,我们旨在加深读者对操作系统如何有效管理和保护内存资源的理解。
9 1
|
10天前
|
算法
深入理解操作系统的内存管理机制
【4月更文挑战第15天】 本文将探讨操作系统中至关重要的一环——内存管理。不同于通常对内存管理概念的浅尝辄止,我们将深入研究其核心原理与实现策略,并剖析其对系统性能和稳定性的影响。文章将详细阐述分页系统、分段技术以及它们在现代操作系统中的应用,同时比较它们的效率与复杂性。通过本文,读者将获得对操作系统内存管理深层次工作机制的洞见,以及对设计高效、稳定内存管理系统的理解。
|
13天前
|
算法 安全 Java
内存分配与回收策略
内存分配与回收策略
19 0
内存分配与回收策略
|
14天前
|
存储 大数据 量子技术
深入理解操作系统的内存管理
【4月更文挑战第12天】 在现代计算机系统中,操作系统扮演着关键角色,它负责协调和管理硬件资源,确保系统运行的高效与稳定。其中,内存管理是操作系统的核心功能之一,它涉及物理内存的分配、虚拟内存的映射以及内存保护等关键操作。本文旨在深入剖析操作系统内存管理的基本原理与实践,探讨其对系统性能和安全性的影响,并简述当前的挑战与创新方向。