2020-11-23

最新推荐文章于 2022-08-12 15:25:24 发布
原创 最新推荐文章于 2022-08-12 15:25:24 发布
· 153 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

#include
#include
#include
#include<bits/stdc++.h>

typedef struct Ln
{
int f; ///进程号
int n; ///进程页数
int len; ///进程大小
char name[8];///进程名
int y[100]; ///页表,下标表示页号，内容表示进程各页所在物理块
struct Ln *next;
} Ln, *List;

int S[100]; ///内存物理块，0：未使用，非0：已使用
int max = 99; ///记录内存的物理块数,值为A[100]最大下标
int num = 100; ///记录内存未使用物理块数

void Create_Pagi();///建立分页进程
void Revoke_Pagi();///回收进程
void Look_Pagi(); ///显示所有进程占用的物理块
void Show_Pagi(); /// 查看进程
void Pagi(); ///分页界面

void Create_Segm();///创建分段进程
void Show_Segm(); ///显示进程信息
void Suggest(); ///建议模块
void Dispatch(); ///调用模块
void Segme(); ///分段界面
void main_s(); ///主界面

///建立新进程
void Create_Pagi(List &L)
{
int i, flag;
int m, k;
List p;
List n_node;
n_node = (List)malloc(sizeof(Ln));
p = L;
printf(" 亲，请输入进程号 😊;
scanf("%d", &n_node->f); ///输入进程号
flag = 0; ///三次输入错误返回上一层
while(p != NULL && flag < 3) /// 查找进程号是否重复
{
if(p->f != n_node->f)
p = p->next;
else
{
printf("\n 亲，该进程已存在您忘记了吗 , 请重新输入 😊;
scanf("%d", &n_node->f);
p = L; ///p 重新指向头结点
flag++;
}
}
if(flag < 3)
{
printf(" 输入进程名称 😊;
scanf("%s", n_node->name);
printf(" 输入进程的大小 (单位为K)😊;
scanf("%d", &n_node->len);///例如1025，进程页数为1，但K不为0，所以+1=2；
n_node->n = n_node->len / 1024;
k = n_node->len % 1024;
if(k != 0)
n_node->n = n_node->n + 1;
printf(" 所需要的页数为 😊;
printf("%d\n",n_node->n);
printf(" 偏移量为%d", k);
if(n_node->n > num)///放不进去，失败
{
printf("\n 对不起亲，内存物理块不足，新建进程失败 \n\n");
}
else
{
num -= n_node->n;///更新剩余物理块
m = 0;
for(i = 0; i <= max; i++)
if(S[i] == 0 && m < n_node->n)///
{
S[i] = n_node->f; ///进程号
n_node->y[m] = i;///页表,下标表示页号，内容表示进程各页所在物理块
m++;
}
printf("\n");
printf(" 页号\t\t块号\n");
for(int i=0; i<m; i++)
printf(" %d\t\t%d\n",i,n_node->y[i]);
int a, b;
while(1)
{
printf(" 请输入页号\n");
scanf("%d", &a);
printf(" 请输入页内偏移\n");
scanf("%d", &b);
if(a < m)
{
printf(" 物理地址：%d\n", n_node->y[a] * 1024 + b);
break;
}
else
{
printf(" 越界\n");
continue;
}
}
if(L == NULL)
L = n_node;
else
{
p = L; /// 查找最后一个节点
while(p->next != NULL)
{
p = p->next;
}
p->next = n_node;
}
n_node->next = NULL;
}
}
else
{
printf("\n 亲操作错误次数过多 , 已为您返回主菜单 😊;
}
}

///回收进程，释放内存
void Revoke_Pagi(List &L)
{
List p,q;
int x;
printf(" 请输入要删除的进程号 😊;
scanf("%d", &x);
p = L; ///查找进程；用 p 记录
q = p;
while(p != NULL)
{
if(p->f == x)///进程号
{
printf(" 亲，该进程已为您删除o “);
break;
}
else
{
q = p;
p = p->next;
}
}
if(p == NULL)///p为空说明不存在此进程
{
printf(”\n 亲，该进程不存在呢o\n");
}
else///对该进程进行删除
{
for(int i = 0; i < p->n; i++)
S[p->y[i]] = 0;///内存物理块
num += p->n;
if(p->f == q->f) ///要删除的是头结点
{
L = p->next;
}
else
{
q->next = p->next;
}
}
}

/// 显示所有进程占用的物理块
void Printf_Pagi(List L)
{
//int i = 0;
printf("\n 内存物理块分配情况 :\n");
List p = L;
printf(" 该进程信息 :\n");
printf(" 进程号 \t 进程名称 \t 进程页数 \t 所用物理块 \n");
while(p != NULL)
{
printf(" %d\t\t", p->f);
printf(" %s\t\t", p->name);
printf(" %d\t\t", p->n);
int i;
for(i = 0; i < p->n; i++)
printf(" %d", p->y[i]);
printf("\n");
p = p->next;
}
}

/// 查看进程
void Look_Pagi(List L)
{
int z;
printf(" 亲，请输入要查询的进程号： “);
scanf(”%d",&z);///输入查看的进程号
List p = L;
while (p != NULL)
{
if(p->f == z)///相同直接输出
{
printf(" 进程号 \t 进程名称 \t 进程页数 \t 所用物理块 \n");
printf(" %d\t\t", p->f);
printf(" %s\t\t", p->name);
printf(" %d\t\t", p->n);
int i;
for(i = 0; i < p->n; i++)
printf(" #%d", p->y[i]);
printf("\n");
break;
}
else p = p->next;
}
if(p == NULL)
printf(" 要查询的进程不存在 \n");
}

/// 显示内存块使用情况，不分进程
void Show_Pagi()
{
printf(" 内存物理块分配情况 \n");
for(int i = 0; i <= max; i++)
{
printf(" %d\t", S[i]);
if(i % 10 == 9) printf("\n");
}
}

///以上分页代码
/------------------------------------------------------------------/
///以下分段代码

using namespace std;

struct seg///定义结构体段seg
{
long cap;///该段的长度
long phy;///物理地址
long rea;///该段实际地址
};

struct Table///定义结构体段表Table
{
seg s[10];///段表中每个段的属性
char name[50];///段表名
int flag;///标记是否被调度内存
int num;///进程中包含段数
long total;///进程所占用的存储空间
};

Table Ts[10];
long mem = 0;
int Tnum = 0;
long k = 0;
long base = 0;

///创建分段进程
void Create_Segm()
{
printf("\n");
printf(“请输入要创建的进程名：”);
cin>>Ts[Tnum + 1].name;
printf(“请输入该进程的段数：”);
cin>>Ts[Tnum + 1].num;
int p = 0;
for(int i = 1; i <= Ts[Tnum + 1].num; i++)
{
printf(“请输入该进程第%d段的大小：”, i);
cin>>Ts[Tnum + 1].s[i].cap;///该进程每段的大小
Ts[Tnum + 1].s[i].phy = p;///物理地址赋值给p
p = p + Ts[Tnum + 1].s[i].cap;///每段的物理地址赋值给加和
}
printf("\n");
Ts[Tnum + 1].flag = 0;///标记是否被调度
Ts[Tnum + 1].total = p;
Tnum++;
}

///显示进程信息
void Show_Segm(int i)
{
printf("\n进程p%d:", i);
cout<<“名字:”<<Ts[i].name<<endl;
cout<<“该进程所占用的存储空间:”<<Ts[i].total<<endl;
if(Ts[i].flag == 0)
cout<<“进程未调用”<<endl;
else
cout<<“进程已调用”<<endl;
cout<<“段 号 物理始址 内存始址 长度”<<endl;
for(int j = 1; j <= Ts[i].num; j++)
{
cout<<setw(3)<<j<<setw(11)<<Ts[i].s[j].phy;
if(Ts[i].flag == 0)
cout<<setw(11)<<" ";
else
cout<<setw(11)<<Ts[i].s[j].rea;
cout<<setw(11)<<Ts[i].s[j].cap<<endl;
}
}

///调用进程
void Dispatch()
{
cout<<endl;
cout<<“输入要调度的进程：p”;
int n;
cin>>n;
if(n <= 0 || n > Tnum)///排除非正常可能
{
cout<<“请求的段表不存在!”<<endl;
cout<<“请重新”;
Dispatch();///重新调度
}
else if(Ts[n].flag == 1)///已经标记
cout<<“操作失败，该进程已经被调入到内存！”<<endl;
else if(Ts[n].total > mem - k)///存储不足
cout<<“内存空间不足，无法调度！”<<endl;
else
{
for(int j = 1; j <= Ts[n].num; j++)
{
Ts[n].s[j].rea = Ts[n].s[j].phy + k;///
}
k = k + Ts[n].total;
Ts[n].flag = 1;///标记被访问
cout<<“调度后的结果是：”<<endl;
Show_Segm(n);
}
}

///建议模块
void Suggest()
{
printf(" 亲，请输入您宝贵的建议：");
char s[10000];
scanf("%s", s);
printf(" 感谢您的宝贵建议，我们10分钟之内会受理您的建议 \n");
printf(" *感谢您的本次使用，退出程序请输入【0】,返回主界面输入【1】: “);
char m;
cin>>m;
do
if(m - ‘0’ == 0)
exit(0);
else if(m - ‘1’== 1)
main_s();
else
{
printf(” 对不起，输入有误，默认返回主界面呢\n\n");
main_s();
}
while(m != 0);
}

///分页
void Pagi()
{
memset(S, 0, sizeof(S));///初始化A
List L = NULL;
int i = 0;
do
{
printf("\t\t 欢迎使用基本分页存储管理系统 \n");
printf("\t\t******************************\n");
printf("\t\t* 1. 添加进程 \n");
printf("\t\t 2. 回收进程 \n");
printf("\t\t 3. 内存占用情况 \n");
printf("\t\t 4. 查看进程 \n");
printf("\t\t 5. 提出宝贵建议 \n");
printf("\t\t 6. 返回主界面 \n");
printf("\t\t 0. 退出程序 \n");
printf("\t\t*****************************\n");
printf(" 请输入您的选择 😊;
scanf("%d", &i);
switch(i)
{
case 1:
Create_Pagi(L);
///Printf_Pagi(L);
break;
case 2:
Revoke_Pagi(L);
Printf_Pagi(L);
break;
case 3:
Show_Pagi();
break;
case 4:
Look_Pagi(L);
break;
case 5:
Suggest();
break;
case 6:
main_s();
break;
case 0:
printf(" 感谢您的使用，祝您生活愉快！");
exit(0);
}
}
while(i != 0);
}

///分段
void Segme()
{
int i;
printf(" 请输入内存的大小：");
int m;
scanf("%d", &m);
do
{
printf("\t\t 欢迎使用基本分段存储管理系统 \n");
printf("\t\t******************************\n");
printf("\t\t* 1. 创建进程 \n");
printf("\t\t 2. 显示进程信息 \n");
printf("\t\t 3. 调度进程 \n");
printf("\t\t 4. 提出宝贵建议 \n");
printf("\t\t 5. 返回主界面 \n");
printf("\t\t 0. 退出程序 \n");
printf("\t\t*****************************\n");
printf(" 请输入您的选择 😊;
scanf("%d", &i);
switch(i)
{
case 1:
Create_Segm();
break;
case 2:
for(int j = 1; j < Tnum+1; j++)
Show_Segm(j);
break;
case 3:
if(i == 3)//如果输入是3则调度一个进程
Dispatch();
else
cout<<" 输入错误!请重新输入!"<<endl;
break;
case 4:
Suggest();
break;
case 5:
main_s();
break;
case 0:
printf(" 感谢您的使用，祝您生活愉快！");
exit(0);
}
}
while(i != 0);
}

///主界面
void main_s()
{
printf("\t\t 欢迎来到内存管理系统 \n");
printf("\t\t**********************\n");
printf("\t\t* 1.进入分页管理系统 \n");
printf("\t\t 2.进入分段管理系统 \n");
printf("\t\t 3.我要提出宝贵建议 \n");
printf("\t\t 0.退出程序 *\n");
int m;
printf(" 亲，请输入您的选择 😊;
scanf("%d", &m);
do
if(m >= 0 && m <= 3)
{
switch(m)
{
case 1:
Pagi();///分页
break;
case 2:
Segme();///分段
break;
case 3:
Suggest();
break;
case 0:
exit(0);
}
}
else
{
printf(" 输入有误！请重新输入:");
scanf("%d", &m);
}
while(m != 0);
}
int main()
{
system(“color 3f”);///颜色
main_s();
return 0;
}

  1. 编译原理实训

4.4分段存储管理
ehonghong的博客
11-21 415
1.分段系统的基本原理 程序通过分段(segmentation)划分为多个模块，每个段定义一组逻辑信息。如代码段（主程序段main，子程序段X）、数据段D、栈段S等。 2.段的特点 每段有自己的名字（一般用段号做名），都从0编址，可分别编写和编译。装入内存时，每段赋予各段一个段号。 每段占据一块连续的内存。（即有离散的分段，又有连续的内存使用） 各段大小不等。 地址结构：段号 + 段内地址 段表...
基本分页存储管理系统课程设计报告-操作系统
12-31
操作系统课程设计，简单的基本分页存储管理系统模拟实现。
编译原理实训-基本分段和分页存储管理简单实现
加油鸭
12-30 933
基本分段和分页存储管理简单实现，很简单，有错误什么的不要在意，仅供参考 #include<cstdio> #include<cstdlib> #include<cstring> #include<bits/stdc++.h> typedef struct Ln { int f; ///进程号 int n; /...
基本分段和分页管理系统实现
01-06
实现最基本的段页式分配，页式使用二维数组，段式使用链表实现。代码能直接运行，在codeblocks上完成。外带有报告使用方式。代码里面有详细备注
【操作系统——内存基本分段式存储管理】
weixin_59658448的博客
08-12 2865
分页管理方式是从计算机的角度考虑设计的，目的是提高内存的利用率，提升计算机的性能，分页是通过硬件机制来实现的，对用户是完全透明的，也就是说，内存当当中的页要如何划分，用户是不能干预的，而分段管理方式则是在一定程度上考虑了用户和程序员，以满足编程、信息保护和共享、动态增长以及动态链接等多方面的需求。在读这篇文章之前，读者们一定要对基本分页式存储管理方式有着一定的了解，否则这篇文章理解起来可能会有一些困难，如果对这方面不了解的话可以先阅读一下我上一篇文章，为大家附上原文链接。...
37基本分段管理方式
weixin_41883890的博客
01-23 1720
基本分段存储管理方式：分页管理方式是从计算机的角度上考虑设计的，以提高内存的利用率，提高计算机的性能，且分页通过硬件机制实现，对用户完全透明；而分段管理方式的提出则是考虑了用户和程序员，以满足方便编程、信息保护和共享、动态增长及动态链接等多方面的需要。 （1） 分段。段式管理方式按照用户进程中的自然段划分逻辑空间。例如，用户进程由主程序、两个子程序、栈和一段数据组成，于是可以把这个用户进程划分为5个段，每个段从0开始编址，并分配一段连续的地址空间（段内要求连续，段间不要求连续，因此整个作业的地址空间是二维的
UL 1123-2020-11-23-final.pdf
09-02
很抱歉，但根据您提供的信息，"UL 1123-2020-11-23-final.pdf" 的描述中没有提供任何具体内容，只有一串重复的"poorest"字符。这使得无法直接生成相关的IT知识点。通常，UL 1123标准是关于电池充电系统的安全要求，...
Project_最小C51系统_2020-11-23_17-28-40_开发板PCB_立创EDAC51_
10-02
标题中的"Project_最小C51系统_2020-11-23_17-28-40_开发板PCB_立创EDAC51_"揭示了一个项目，专注于构建一个基于C51微控制器的最小系统。这个系统在2020年11月23日的特定时间进行了开发，并且与立创EDAC51开发板的...
Maple-Chan#Maple-Chan.Blog#2020-11-23-Builder模式1
07-25
介绍UserBuilder builder = new UserBuilder();User user = builder.builder();可以通过上述代码
Screenrecorder-2020-07-14-11-13-20-521.mp4
07-14
安卓开发，仿淘宝首页分类效果实现，带进度条seekbar，可以左右滚动，进度条实现跟随手势滑动的效果
Dell3020MT_EFI_OC_Catalina_BigSur_2020-11-23.zip
11-23
Dell Optiplex 3020 MT 最新 黑苹果 EFI ,基于 OpenCore 0.6.2 可以启动 Catalina 10.15.7 及 Big Sur 11.0.1 修复了关于本机中机型及CPU型号的显示，以及关闭了启动时EFI的日志
编译原理实验-编译器
10-10
词法、语法、语义分析器，最后有一个三合一版本。全部采用文件输入输出方式
编译原理实验指导（含源代码）
12-21
编译原理实验指导。含实验原理，设计过程和具体源代码。
操作系统学习（三）基本分段存储管理方式
weixin_42097108的博客
09-26 1327
一、分段的定义 进程的地址空间按照自身的逻辑关系划分为若干段。 例如：主程序，两个子程序，栈和一段数据，把进程分成5段，每段从0进行编址，段间要求连续，段内不要求。 二、段表 1.分段系统的逻辑地址结构由段号（段名）和段内地址（段内偏移量）组成。 段号的位数决定了每个进程最多可以分成几个段， 例：段号16位，每个进程最多有216 = 64k个段。 段内地址的位数决定了每个段的最大长度是多少。 段内地址16位，每个段的最大长度是216=64KB. 2.段表由段号，段长和该段在内存中的始址组成 3.地址变换
操作系统-3.5-内存（基本分段存储管理&&段页式管理）
小皮皮LL的博客
08-13 708
文章目录操作系统-3.5-内存10.基本分段存储管理10.1什么是分段？10.2什么是段表？10.3分段存储管理实现地址变换过程10.4分段，分页管理的对比10.5总结11.段页式管理方式11.1分页，分段的优缺点11.2段页式管理11.3段页式管理的逻辑地址结构11.4段表，页表11.5段页式管理实现地址变换过程11.6总结 操作系统-3.5-内存 10.基本分段存储管理 10.1什么是分段？ 分段：进程的地址空间按照程序自身的逻辑关系划分为若干个段，每个段都有一个段名（在低级语言中，程序员使用段名
操作系统：基本分段存储管理方式
五山口老法师
01-21 2151
虚拟内存采用的是分页技术，也就是将地址空间划分成固定大小的页，每一页再与内存进行映射。 下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。   分段的做法是把每个表分成段，一个段构成一个独立的地址空间。每个段的长度可以不同，并且可以动态增长。   分页和分段的主要区别 a)、页是信息的物理单位...
模拟实现基本分页存储管理_Linux操作系统：分段的基本概念，以及分页和分段的主要区别...
weixin_39805529的博客
12-06 197
1．分段为了编程和使用方便，用户希望把自己的程序按照逻辑关系组织，即划分成若干段，并且按照这些段来分配内存。这样，在分段存储管理系统中，一个作业或进程可以有多个段，这些段可以离散地放入内存的不同分区中。就是说，一个作业或进程的各段不一定放在彼此相邻的分区中。所以，段是一组逻辑信息的集合。在图中，有主程序段MAIN，子程序段P，数据段D和栈段S等。分段地址空间每段都有自己的名字和长度。为管理方便，系...
分页存储管理和分段存储管理
weixin_30535913的博客
05-28 202
1.采用相联存储器后地址转换过程，用图表示出来 2.分段和分页比较 分段是信息的逻辑单位，由源程序的逻辑结构即含义所决定，式用户可见的，段长由用户根据需要来确定，段起始地址可从任何内存地址开始。在分段方式中，源程序（段号，段内位移）经链接装配后仍保持二维（地址）结构，引入目的是满足用户模块化程序设计的需要。 分页是信息的物理单位，与源程序的逻辑结构无关，是用户不可见的，页长由系统（硬件）...
C++内存存放管理
a_465240的博客
04-12 233
BSS（Block Started by Symbol）通常是指用来存放程序中未初始化的全局变量和静态变量的一块内存区域。特点是:可读写的，在程序执行之前BSS段会自动清0。所以，未初始的全局变量在程序执行之前已经成0了。 数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。 代码段：代码段（code segment/text ...
根据String类型的时间段【2020-11-20 09:09:09,2021-10-09 10:10:10】先转换为【2020-11-20 00:00:00,2021-10-09 59:59:59】 再根据转换时间把里面的每一天的开始时间和结束时间获取出来 java
05-24
可以使用Java中的...2020-11-22 00:00:00 - 2020-11-23 00:00:00 ... 2021-10-07 00:00:00 - 2021-10-08 00:00:00 2021-10-08 00:00:00 - 2021-10-09 00:00:00 2021-10-09 00:00:00 - 2021-10-09 23:59:59 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值