存储管理实验

最新推荐文章于 2023-12-05 22:40:09 发布
最新推荐文章于 2023-12-05 22:40:09 发布
阅读量180 收藏
点赞数 1
文章标签： c++ 算法 java
原文链接：https://blog.csdn.net/qq_44765647/article/details/107006163
版权

测试数据：

Pi：进程名称，a：内存分配， f：回收分区，130：分区大小

P1,a,130

P2,a,60

P3,a,100

P2,f,60

P4,a,200

P3,f,100

P1,f,130

P5,a,140

P6,a,60

P7,a,50

P6,f,60

【注：当第一次选择一种分配算法，则下次需分配内存时需一直使用第一次选择的算法，也就是全程只能用一种算法】

1.考虑到需要连续分配或回收分区，故添加了一个操作次数。

代码：

#include<bits/stdc++.h>
#include <stdio.h>
#include <string.h>
using namespace std;

#define MAX 640  //设置总内存大小为640k
#define SIZE 10   //分区大小与作业大小最小差值
struct partition {
    char pn[10];//分区名字
    int begin;//起始地址
    int size;//分区大小 
    int end;//结束地址
    char status;//分区状态
    };
    struct partition part[MAX];
    int p = 0; //标记上次扫描结束处 
//初始化分区地址、大小以及状
void Init(){
    int i,b,k=1,c,j = 0,sum= MAX;
    char a[10];
    for ( i = 0; i < MAX; i++ ){
        part[i].status = '-';
    }
    part[0].begin = j;
    part[0].size=640; 
    part[0].end=640; 
    part[0].status = 'f';      
    printf("初始化完成!!!!!!!!\n");
}
 //以行的形式输出结构体的数据
void Output( int i ){
    printf( "%6s", part[i].pn );
    printf( "%12d", part[i].begin );
    printf( "%11d", part[i].size );
    printf( "%11d", part[i].end );
    if(part[i].status=='u'){
    	printf("\t 已分配 |");
	}
	else{
		printf("\t  空闲  |");
	}
}

 //显示分区 
void xianshi(){
    int i;
    int n; //用n来记录分区的个数
    printf( "\n\t------------------内存使用情况记录表---------------------" );
    printf( "\n\t---------------------------------------------------------");
    printf( "\n\t|分区号  进程名   起始地址  分区大小   终止地址   状态  |" );
    n = 1;
    for ( i = 0; i < MAX; i++ ){
        if ( part[i].status == '-' )
            break;
        printf( "\n\t|%4d", n );
        Output( i );
        n++;//记录已分配分区以及空闲分区之和的总个数
    }
    printf( "\n\t---------------------------------------------------------");
}

 //新作业把一个分区分配成两个分区：已使用分区和空闲分区 
void Fit( int a, char workName[], int workSize ){

    int i;
    //空闲区与作业所用内存相差很少
    if(part[a].size - workSize <= SIZE){
        part[a].status = 'u';
        strcpy( part[a].pn, workName );
        return;
    }
    for ( i = MAX; i > a + 1; i-- ){
    //通过逆向遍历，把在a地址后的所有分区往后退一个分区，目的在于增加一个分区
        if ( part[i - 1].status == '-' )
            continue;
        part[i]=part[i-1];
    }
    strcpy( part[a + 1].pn, "" );
    part[a + 1].begin = part[a].begin + workSize;
    part[a + 1].size = part[a].size - workSize;
    part[a + 1].end = part[a].end;
    part[a + 1].status = 'f';
    strcpy( part[a].pn, workName );
    part[a].size = workSize;
    part[a].end = part[a].begin + part[a].size - 1;
    part[a].status = 'u';
}

 // 分配 
void fenpei(){
    int i;
    int a;
    int workSize;
    char workName[10];
    int pFree;
    printf( "请输进程名和分区大小：" );
    scanf( "%s%d",&workName, &workSize);
    for(i=0;i<MAX;i++){
        //判断作业名称是否已经存在
        if(!strcmp(part[i].pn,workName)){
            printf("\n作业已经存在，不必再次分配！\n");
            return;
        }
    }
    //通过循环在空闲区找是否有适合区间存储作业
    for ( i = 0; i < MAX; i++ ){
        if ( part[i].status == 'f' && part[i].size >= workSize ){
            pFree = i;
            break;
        }
    }
    if ( i == MAX ){
        printf( "\n该作业大小超出最大可分配空间" );
        return;
    }
    printf( " 1、首次适应算法(FF)" );
    printf( "   2、最佳适应算法(BF)" );
    printf( "   3、最坏适应算法(WF)" );
    printf( "\n请选择分配算法：" );
    while ( 1 ){
        scanf( "%d", &a );
        if ( a == 1 || a == 2 || a == 3 )
            break;
        printf( "输入错误，请重新输入：" );
    }
    switch ( a ){
        case 1:
            for ( i = 0; i < MAX; i++ )//首次适应算法(按地址从低到高查找)
                if ( part[i].status == 'f' && part[i].size >= workSize )
                    break;
            Fit( i, workName, workSize );
            xianshi(); 
            break;
        case 2:
            for ( i = 0; i < MAX; i++ )//最佳适应算法
            if ( part[i].status == 'f' && part[i].size >= workSize )
                    if ( part[pFree].size > part[i].size )
                        pFree = i;//通过遍历所有区间，每次都找到最小空闲分区进行分配
            Fit( pFree, workName, workSize );
            xianshi(); 
            break;
        case 3:
            for ( i = 0; i < MAX; i++ )//最坏适应算法
                if ( part[i].status == 'f' && part[i].size >= workSize )
                    if ( part[pFree].size < part[i].size )
                        pFree = i;//通过遍历所有区间，每次都找到最大空闲区分配
            Fit( pFree, workName, workSize );
            xianshi(); 
            break;
        default:
            break;
    }
    printf( "\n--------分配成功！---------\n" );
}

 //合并相邻空闲分区 
void hebing(int t){
    int i;
    part[t-1].status='f';
    strcpy(part[t-1].pn,"");
    //第一个分区
    if(t-1 ==0){
        if(part[t].status=='f'){
            part[t-1].size = part[t].end + 1;
            part[t-1].end =part[t].end;
            for( i = 1;i<MAX;i++){
                part[i].begin = part[i+1].begin;
                part[i].end=part[i+1].end;
                part[i].size  =part[i+1].size;
                part[i].status = part[i+1].status;
                strcpy(part[i].pn,part[i+1].pn);
            }
        }
    }
    //回收区同时与插入点的前后两个分区邻接
    else if((part[t].status =='f') && (part[t-2].status == 'f') ){
        part[t-2].size = part[t].end - part[t-2].begin + 1;
        part[t-2].end = part[t].end;
        for(i = t-1;i<MAX;i++){
            part[i].begin = part[i+2].begin;
            part[i].end = part[i+2].end;
            part[i].size  =part[i+2].size;
            part[i].status = part[i+2].status;
            strcpy(part[i].pn,part[i+2].pn);
        }
    }
    //回收区与前一个空闲分区相邻接
    else if(part[t-2].status =='f'){
        part[t-2].size = part[t-1].end - part[t-2].begin + 1;
        part[t-2].end = part[t-1].end;
        for(i=t-1;i<MAX;i++){
            part[i].begin = part[i+1].begin;
            part[i].end=part[i+1].end;
            part[i].size  =part[i+1].size;
            part[i].status = part[i+1].status;
            strcpy(part[i].pn,part[i+1].pn);
        }
    }
    //回收区与后一个空闲分区相邻接
    else if(part[t].status == 'f'){
        part[t-1].size = part[t].end - part[t-1].begin + 1;
        part[t-1].end = part[t].end;
        for(i = t;i<MAX;i++ ){
            part[i].begin = part[i+1].begin;
            part[i].end=part[i+1].end;
            part[i].size  =part[i+1].size;
            part[i].status = part[i+1].status;
            strcpy(part[i].pn,part[i+1].pn);
        }
    }
}

// 回收分区 
int huishou(){
    int    number;
    printf( "\n请输入回收的内存分区号(数字)：" );
    scanf( "%d", &number );
    if ( part[number-1].status == 'u' ) {
        printf( "\n--------回收成功！--------" );
        return number;
    }
    printf( "\n-------回收失败，分区不存在或未使用-------" );
    return -1;
}


int main(){
    int i,num;
    int selection;
    printf( "---------------初始化，设内存容量%dk---------------\n", MAX );
    printf("正在初始化..........\n");
    Init();
    xianshi();
    while ( 1 ){
        printf( "\n\n-------------菜单--------------" );
        printf( "\n|       0、退出系统           |");
        printf( "\n|       1、显示分区           |");
        printf( "\n|       2、内存分配           |" );
        printf( "\n|       3、回收分区           |" );
        printf( "\n-------------------------------" );
        printf( "\n请选择(数字)：" );
        while ( 1 ){
            scanf( "%d", &selection );
            if ( selection == 0 ||selection == 1 || selection == 2 || selection == 3 )
                break;
            printf( "输入错误，请重新输入：" );
        }
		switch ( selection ){
            case 0:
                exit(0); //退出系统
                break;
            case 1:
                xianshi(); //显示分区
                break;
            case 2:
            	printf("请输入该功能操作的次数:");
				cin>>num;
				for(int j=0;j<num;j++){
					fenpei(); //分配作业
				}
                break;
            case 3:
            	printf("请输入该功能操作的次数:");
				cin>>num;
				for(int j=0;j<num;j++){
					i= huishou();  //回收分区
                	hebing(i);//合并空闲分区
                	xianshi();
				}   
                break;
            default:
                break;
       	   }	
    }
    return 0; 
}

 

@Navie
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
计算机操作系统-实验报告三：存储器管理
04-28
计算机操作系统-实验报告三：存储器管理 操作系统 操作系统报告 操作系统实验 存储器管理
学习C语言——学习笔记（1）
wzwpy99的博客
01-12 1227
1.预处理指令 预处理指令解释为由预处理器读入源码，然后根据预处理指令对其进行修改，最后将修改过后的源代码递交给编译器 以下5行都是预处理指令： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_COLS 20 #define MAX_INPUT 1000 预处理指令的作用仿佛是将stdio.h的内容逐字写到源文件的位置，以上第二、三条指令的功能都类似，不同点在于二、三条替换
C++学习（二）——基础（二）
qq_42689353的博客
02-23 599
C++对C语言的增强 以下面的代码最为例子 C语言： #include<stdio.h> #include<stdlib.h> #include<string.h> /* 1、全局变量检测增强 在C语言中，这段代码是可以编译通过的 int a; int a = 10 */ /* 2、函数检测增强 在C语言中，这段代码是可以编译通过的 f(a, b) { ...
c语言------期末考试编程练习题
qq_48566899的博客
03-24 225
c
动态分区存储管理实验是什么以及学习动态分区存储管理实验的意义
最新发布
05-23
### 动态分区存储管理实验概述 动态分区存储管理实验是计算机科学与技术专业课程中一项重要的实践教学活动。该实验旨在帮助学生深入了解操作系统中内存管理的核心机制之一——动态分区存储管理技术。通过这一实验，...
OS.zip_存储管理实验
09-22
在“OS.zip_存储管理实验”中，我们关注的是操作系统中的存储管理部分，这是一个至关重要的领域，因为它直接影响到系统的性能、效率和稳定性。这个实验代码是针对学生理解和实践操作系统如何进行内存分配和管理而...
动态分区存储管理实验动态分区存储管理实验动态分区存储管理实验.txt
05-23
动态分区存储管理实验动态分区存储管理实验动态分区存储管理实验动态分区存储管理实验
实验三 存储管理实验.doc
07-06
实验三的存储管理实验主要涉及两个关键知识点：请求页式存储管理和固定式分区分配的存储管理。 1. 请求页式存储管理： 请求页式存储管理是一种虚拟存储技术，它的核心思想是将进程的地址空间分为若干固定大小的页，...
经典编程900例（c语言）（第二十三篇）
dust_fall的博客
10-28 165
例277：分配内存函数alloca() #include <stdio.h> #include <malloc.h> void some_function(size_t size) { int i; char *pointer; char stack_fix[1]; stack_fix[0] = NULL; // 在调用 alloca的函数返回的时候, 它分配的内存会自动释放 if ((pointer = alloca(size
C语言实现读取文件的简单代码
wuwuku123的博客
08-20 1万+
一、写文件 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> int main() { printf("File :%s\n", __FILE__); printf("Date :%s\n", __DATE__); printf("...
操作系统 存储管理实验报告
十一月廿七风雨大作
06-19 3万+
实验要求 实验目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。 本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 二、实验内容 （1） 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对命中率的影响。 页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。 在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。 （2） produce_adds
C语言再学习 -- 段错误（核心已转储）
热门推荐
不积跬步，无以至千里
12-21 6万+
参看：Linux下的段错误产生的原因及调试方法参看：Linux环境下段错误的产生原因及调试方法小结参看：维基百科--Segmentation fault参看：LINUX内核段错误调试详细指南精品培训PPT讲义一、什么是段错误？一旦一个程序发生了越界访问，cpu 就会产生相应的保护，于是 segmentation fault 就出现了，通过上面的解释，段错误应该就是访问了不可访问的内存，这个内存区要
01串_String
AKK188888881的博客
10-05 251
#include<stdio.h> #include<stdlib.h> #include<string.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 40 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int ElemType; /* El
工程师笔记|C语言的进阶使用
weixin_39266374的博客
01-05 661
关于C语言的进阶使用，讲三点 壹：#include"xxx.c" 贰：void 弎：逗号表达式 壹 #include"xxx.c" 1、操作一波 咱们先体验一波#include"xxx.c"文件能不能用: 参考demo： 1//FileName :main 2#include <stdio.h> 3#include <stdlib.h> 4 5/*************************** 6 * .c文件声明区域 7 **************
C语言基础编程题2
weixin_47983106的博客
07-18 209
c语言基础编程题
pta模拟题C语言函数题（6-1 弹球距离、6-2 多项式求值、6-3 求自定类型元素序列的中位数、6-4 统计个位数字、6-5 折半查找、6-6 计算最长的字符串长度、6-7 空心的数字金字塔）
FlippedSQ的博客
12-05 574
其中h是球的初始高度，p是球弹起高度与弹起前落下高度的比值；函数dist要返回球下落后到基本停下来时在空中所经过的路程总和。注意：当弹起的高度小于裁判程序定义的常数TOL时，弹起的距离不计算在内。其中n是多项式的阶数，a[]中存储系数，x是给定点。函数须返回多项式f(x)的值。其中给定集合元素存放在数组A[]中，正整数N是数组元素个数。该函数须返回N个A[]元素的中位数，其值也必须是类型。其中N和D都是用户传入的参数。N的值不超过int的范围；D是[0, 9]区间内的个位数。函数须返回N中D出现的次数。
操作系统之存储管理
m0_56410967的博客
12-06 1642
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。掌握分页存储管理的基本原理及分页存储管理中的地址变换过程，编制一个模拟地址变换过程的程序并能采用先进先出页面置换算法实现页面置换。
Windows 7存储管理实验：优化内存与理解虚拟存机制
本次实验是针对计算机科学与技术专业学生设计的操作系统实验四——存储管理，旨在通过实践操作Windows7系统，加深对操作系统内存管理、虚拟存储以及进程内存映射关系的理解。实验主要目标包括： 1. 实验目的与要求...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值