最后的大实验快去验优,废话少说,直接开冲:
#include<iostream.h>
typedef struct pcb{
char name[10];
int ntime;//要求运行时间
int rtime;//已运行时间
char estate;//状态
struct pcb *next;//指针指向下一个进程
}*pointer;
void Creatlist(pointer &head,pointer &f,pointer &l,pointer q[]){
pointer p;
head=new pcb;
head->next=NULL;
f=head;
for(int i=1;i<=5;i++){
p=new pcb;
p->next=NULL;
cout<<"作业名字:"<<endl;
cin>>p->name;
cout<<"作业需要运行时间:"<<endl;
cin>>p->ntime;
p->rtime=0;
p->estate='R';
f->next=p;
f=f->next;
q[i]=p;
}
f=head->next;
l=p;
l->next=f;
}
void Cout(pointer &head,pointer q[])//输出运行的进程及其状态{
for(int i=1;i<=5;i++){
cout<<"标识符:"<<q[i]->name<<" "<<"要求运行时间:"<<q[i]->ntime<<" "<<"已运行时间:"<<q[i]->rtime<<"状态:"<<q[i]->estate;
cout<<endl;
cout<<endl;
}
}
void diaodusuanfa(pointer &head,pointer &f,pointer &l,pointer r[])//处理机调度算法{
pointer p,q;
q=l;
p=head->next;
while((p->next!=p)||(p->ntime!=p->rtime)){
p->rtime=p->rtime+1;
cout<<p->name<<"已运行时间+1。"<<endl;
if(p->ntime==p->rtime){
p->estate='E';
cout<<p->name<<"已结束。"<<endl;
q->next=p->next;
p=q->next;
}
else{
p=p->next;
q=q->next;
}
Cout(head,r);
}
}
void main(){
pointer h,f,l,q[5];
Creatlist(h,f,l,q);
Cout(h,q);
diaodusuanfa(h,f,l,q);
}
(执行结果是类似第二张图片的,下面还有类似的结果,状态栏的R表示未完成,E表示完成)
(4)源程序
#include <iostream>
using namespace std;
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//生成begin-end随机数
int random(int begin,int end){
if (begin == 0) return rand() % (end + 1);
else return rand() % (end - begin + 1) + begin;
}
//生成指令序列
void make(int* instruction) {
int m;
int n;
for (int i = 0; i < 320; i += 4) {
//在[0,319]间随机选取起点m,若m=319,顺序执行一条可能会超出范围
m = random(0, 318);
//执行地址为m+1的指令
instruction[i] = m + 1;
n = m + 1;
//在[0,m+1]中随机选取一条指令并执行,该指令的地址为m',若m ≥317,顺序执行2条可能会超出范围
do {
m = random(0, n);
}while(m>=317);
//顺序执行一条指令,其地址为m' + 1
instruction[i+1]=m;
//在后地址[m'+2,319]中随机选取一条指令并执行
instruction[i+2]=m+1;
//若m=319,顺序执行一条可能会超出范围
m = random(m + 2, 318);
instruction[i + 3] = m;
}
}
//指令序列变换为页地址流
void makePage(int* page, int* instruction) {
for (int i = 0; i < 320; i++)
page[i] = instruction[i] / 10; //每页存储十条指令
}
int main()
{
int instruction[320];
int page[320];
int replacement[320],i;
for ( i = 0; i < 320; i++){
replacement[i]=100; //显示状态
}
int t=0;
make(instruction);
makePage(page, instruction);
cout <<"页面访问顺序为:"<<endl;
for ( i = 0; i < 320; i++)
cout << page[i] << " ";
cout << endl;
int a;//存放自定义的内存容量
cout << "请输入自定义的内存容量:" << endl;
cin >> a;
int *memory = new int[a];//内存块
int *queue = new int[a];//队列:(FIFO)先进先出算法,由此查询需要替换的是哪个页面
for ( i = 0; i < a; i++)
{
memory[i] = 100;
queue[i] = 100;//初始化
}
int count = 0;//缺页次数
int flag;//标记
int x;//暂时存储队首元素
int y;//标记
for (int j = 0; j < 320; j++)
{
for (i = 0; i < a; i++)
{
if(page[j] == memory[i])
{
flag = 0;//命中,不缺页
break;
}
flag = 1;
}
if (flag==1)//缺页
{
count=count+1;//缺页次数+1
for ( i = 0; i < a; i++) //内存块是否全满?
{
if (memory[i] == 100)//100是初始值,即内存块未全满
{
queue[i] = page[j];//直接入队
memory[i] = page[j];//直接进入内存
y = 1;
break;
}
y = 0;
}
if (y == 0) {//内存块全满且没有命中,要替换
x = queue[0];//队列第一个出列:先进先出
replacement[t] = x;
t++;
for (i = 0; i < a-1; i++) {
queue[i] = queue[i + 1];//队列前移;
}
queue[a-1] = page[j];//新的页号放在队尾
for (i = 0; i < a; i++) {
if (memory[i] == x)
memory[i] = page[j];//找到对应的页号,替换
}
}
}
cout << "访问第" << j + 1 << "次后物理块的占有情况:(100表示空,没有存放页号,其余表示存放的页面号):" << endl;
for ( i = 0; i < a; i++) {
cout << memory[i] << " ";
cout << endl;
}
}
cout << "被置换的页面依次为:" << endl;
for ( i = 0; i < 320; i++) {
if (replacement[i] != 100)
cout << replacement[i] << " ";
}
cout << endl;
cout << "缺页次数:" << count << endl;
double p = count / (320 * 1.0);
cout << "命中率为:" << (1.0 - p) << endl;
system("pause");
return 0;
}
#define n 4//假定设备类型为4
#define j 10//假定设备总数为10
void init() {
counts = 6;
OS[0].name = 'P';//未分配均命名为P
OS[0].start = 0;//初始位置0
OS[0].size = 5;
OS[0].flag = 1;//分配标志未分配 = 1
OS[1].name = '1';//未分配命名为P
OS[1].start = 5;//初始位置0
OS[1].size = 5;
OS[1].flag = 0;//分配标志已分配 = 0
OS[2].name = '3';
OS[2].start = 10;
OS[2].size = 4;
OS[2].flag = 0;
OS[3].name = 'P';
OS[3].start = 14;
OS[3].size = 12;
OS[3].flag = 1;
OS[4].name = '2';
OS[4].start = 26;
OS[4].size = 6;
OS[4].flag = 0;
OS[5].name = 'P';
OS[5].start = 32;
OS[5].size = COUNT - 32;
OS[5].flag = 1;
}
//插入数据
void insert(int m, int st, int en) {
int i;
counts++;//数组长度加一
for (i = counts; i > m; i--)//从插入位 由后往前后移 {
OS[i] = OS[i - 1];
}
OS[m].start = st;//插入
OS[m].size = en;
}
//删除数据
void move(int m) {
int i;
for (i = m; i < counts - 1; i++)//从删除位 由前往后前移 {
OS[i] = OS[i + 1];
}
counts--;//数组长度减一
}
//合并没有分配的相邻块
void remove(int m, int st, int en) {
if (!OS[m - 1].flag && !OS[m + 1].flag)
//如果m前后都已分配 不分配 {
OS[m].name = 'P';
OS[m].flag = 1;
}
if (OS[m - 1].flag)
//如果m前未分配,后已分配 与前一个合并 {
OS[m - 1].size = OS[m - 1].size + en;
move(m);
}
if (OS[m + 1].flag)
//如果m后未分配,前已分配 与后一个合并 {
OS[m].size = OS[m].size + OS[m + 1].size;
OS[m].name = 'P';
OS[m].flag = 1;
move(m + 1);
}
}
//输出
void show() {
int i;
cout << "(名称 起址 长度 状态)" << endl;
for (i = 0; i < counts; i++) {
if (OS[i].flag)//未分配
cout << "P ";
else//已分配
cout << OS[i].name << " ";
cout << " " << OS[i].start << " " << OS[i].size << " ";
//依次输出块的name,起始位置,长度
if (OS[i].flag)
cout << "未分配" << endl;
else
cout << "已分配" << endl;
}
}
//申请资源
int apply() {
int i = 0;
int applyflag = 0;//标记
while (!applyflag && i < counts)//遍历数组 查找连续的可分配资源是否存在? { if (OS[i].size >= num && OS[i].flag)//比较块大小、是否已分配来找空间 {
if (OS[i].size == num)//大小相等 直接修改 {
OS[i].name = c;
OS[i].flag = 0;
}
else// 偏大 修改信息同时更新原先块为已分配和未分配两部分 {
insert(i + 1, OS[i].start + num, OS[i].size - num);
OS[i + 1].flag = 1;
OS[i + 1].name = 'P';
OS[i].start = OS[i].start;
OS[i].name = c;
OS[i].size = num;
OS[i].flag = 0;
}
applyflag = 1;//申请成功的标记
}
i++;
}
if (applyflag) {
cout << "申请成功" << endl;
return 1;
}
else {
cout << "没有足够大的空闲空间" << endl;
return 0;
}
}
//释放资源
int free() {
int i = 0;
int freeflag = 0;//标记
while (!freeflag && i < counts)//遍历数组 查找作业是否存在 {
if (OS[i].name == c)//找到作业 {
remove(i, OS[i].start, OS[i].size);
freeflag = 1;//修改标记
}
i++;
}
if (freeflag) {
cout << "释放成功" << endl;
return 1;
}
else {
cout << "未找到匹配的进程名称" << endl;
return 0;
}
}
void shengqing(JC *p) {
c = p->name; //申请内存空间
num = p->size;
apply();
show();
cout << endl;
}
void shifang(JC *r) {
c = r->name; //释放上一个的内存空间
num = r->size;
free();
show();
cout << endl;
}
void create(JC *head) {
JC *q = new JC();
cout << "依次输入进程名,进程大小,进程到达时间,进程估计运行时间:" << endl;
char name;
int size, tape, ta, ts;
char printer;
int x = 0;
q->to = x;//完成时间
q->totalTime = x;//周转时间
q->weightTotalTime = x;//带权周转时间
q->flag = 0;//未运行
cin >> name; q->name = name;//名字
cin >> size; q->size = size;//大小
cin >> ta; q->ta = ta;//到达时间
cin >> ts; q->ts = ts;//估计运行时间
head->next = q;
q->next = NULL;
}
void out(JC *p)//输出当前进程状态量 {
while (p != NULL) {
cout << p->name << " ";
cout << p->ta <<" ";
cout << p->ts <<" ";
cout << p->to <<" ";
cout << p->totalTime <<" ";
cout << p->weightTotalTime <<" ";
cout << endl;
p = p->next;
}
}
void operation(JC *t, JC *r)//计算该进程完成时间,周转时间,带权周转时间 {
t->to = (r->to) + (t->ts);//完成时间=上一个运行进程的完成时间+当前进程估计运行的时间
t->totalTime = (t->to) - (t->ta);//周转时间=当前进程完成时间-到达时间
t->weightTotalTime = (t->totalTime) / ((t->ts)*1.0);//平均周转时间=周转时间/估计运行的时间 }
int main() {
int i;
init();//初始化
JC *head = new JC();
JC *p = head;
JC *r, *t = NULL;
cout << "状态输出格式为:进程名,进程到达时间,进程估计运行时间,进程完成的时间,周转时间,带权周转时间:" << endl;
cout << "内存空间初始分配情况:" << endl;
show();
cout << endl;
cout << "请输入进程总个数" << endl;
int x;
cin >> x;
for (i = 0; i < x; i++) {
create(p);
p = p->next;
}//按到达时间先后创建进程链队
p = head->next;//指向第一个进程
cout << "初始状态" << endl;
out(p);//打印初始状态
cout << "第1次选中进程" << p->name << endl;
p->to = p->ts;
p->totalTime = (p->to) - (p->ta);
p->weightTotalTime = (p->totalTime) / ((p->ts)*1.0);
p->flag = 1;
out(p);
shengqing(p);
cout << endl;
r = p;//r记住前一个已运行的进程
i = 2;
p = p->next;
while (x != 1) {
while (p != NULL) {
if ((p->flag) != 1)//当前结点指向的进程未运行 {
double y;
y = ((r->to) - (p->ta)) / ((p->ts)*1.0);//计算优先权
if (y > priority) {
t = p;
priority = y;
}
p = p->next;
}
else if ((p->flag) == 1) {
p = p->next;
}
}
operation(t, r);//计算
cout << "第" << i << "次选中进程" << t->name << endl;
t->flag = 1;
out(head->next);//显示此时进程状态
shifang(r);
cout << endl;
r = t;
shengqing(r);
cout << endl;
x--;
i++;
priority = 0;
p = (head->next);
}
system("pause");
return 0;
}
(7)实验参考文献
EOS 操作系统实验教程 海西慧学编著
上述整体到这里就没了,不过还有一个java操作系统验优程序,放下面:
感兴趣的自己去研究吧
//RAM内存类
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class RAM {
Scanner input = new Scanner(System.in);
static IdlePartition idle = new IdlePartition();
private Integer size; //总内存大小
private Integer initialAddress; //起址
private Integer endAddress; //末址
private Integer blockNum ; //块数
private ArrayList blockSize; //块大小
private ArrayList blockAddress; //每块的起址
private ArrayList blockStatus; //每块的状态
public RAM(Integer size, Integer initialAddress) {
this.size = size;
this.initialAddress = initialAddress;
this.endAddress = this.initialAddress + this.size;
this.blockNum = 10;
Random random = new Random();
Integer sum = 0;
this.blockSize = new ArrayList();
this.blockAddress = new ArrayList();
this.blockStatus = new ArrayList();
for (int i = 0; i < 9; i++) {
this.blockAddress.add(sum);
this.blockSize.add(random.nextInt(100)+30);
sum += (Integer)(this.blockSize.get(i));
this.blockStatus.add("未分配");
}
this.blockSize.add(this.size - sum);
this.blockAddress.add(sum);
this.blockStatus.add("未分配");
Printer();
}
public IdlePartition Changing(){
ArrayList initialAddress1 = new ArrayList(); //起始地址
ArrayList lenth = new ArrayList(); //长度
ArrayList status = new ArrayList(); //状态
for (int i = 0; i < this.blockNum; i++) {
if (this.blockStatus.get(i) == "未分配"){
initialAddress1.add(this.blockAddress.get(i));
lenth.add(this.blockSize.get(i));
status.add(this.blockStatus.get(i));
}
}
idle.setInitialAddress(initialAddress1);
idle.setLenth(lenth);
idle.setStatus(status);
return idle;
}
public void Printer(){
System.out.println("***********内存分块说明表*************");
System.out.printf("%-7s%-10s%-10s%-10s\n","编号","起址","长度","状态");
for (int i = 0; i < this.blockNum; i++) {
System.out.printf( "%2d%10d%s%10d%s%10s\n",i+1,this.blockAddress.get(i),"K"
,this.blockSize.get(i) ,"K",this.blockStatus.get(i) );
}
}
public void Printer1(IdlePartition idlePartition){
System.out.println("***********空闲说明表*************");
System.out.printf("%-7s%-10s%-10s%-10s\n","编号","起址","长度","状态");
for (int i = 0; i < idlePartition.getStatus().size(); i++) {
System.out.printf( "%2d%10d%s%10d%s%10s\n",i+1,idlePartition.getInitialAddress().get(i),"K"
,idlePartition.getLenth().get(i) ,"K",idlePartition.getStatus().get(i) );
}
}
/**
* 查找空闲分区
*/
public void FindingIdlePartition(IdlePartition idlePartition,Integer size,Integer a){
for (int i = 0; i < idlePartition.getStatus().size(); i++) {
if (size == 0) {
System.out.println("申请无效!");
return;
}
if ((Integer)(this.blockSize.get(i)) >= size && this.blockStatus.get(i).equals("未分配")) {
this.blockStatus.set(i,"作业" + a + "正在使用中");
if ((Integer)(idlePartition.getLenth().get(i)) == size){
this.blockSize.set(i,size);
return;
}else {
//使用空间,并建立新的空闲分区
this.blockAddress.add(i+1,(Integer)(this.blockAddress.get(i)) + size);
this.blockStatus.add(i+1,"未分配");
this.blockSize.add(i+1,((Integer)this.blockSize.get(i)) - size);
this.blockSize.set(i,size);
this.blockNum++;
return;
}
}
}
System.out.println("未找到适当的内存,请重新申请!!!");
}
/**
* 作业i申请空间
*/
public void Applying(Integer i){
System.out.print("请输入要申请的作业" + i + "占用内存:");
FindingIdlePartition(idle,input.nextInt(),i);
}
/**
* 作业i释放空间
*/
public void Freeing(Integer i){
for (int j = 0; j < this.blockNum; j++) {
if (this.blockStatus.get(j).equals("作业" + i + "正在使用中")){
this.blockStatus.set(j,"未分配");
this.blockSize.set(j,(Integer)this.blockSize.get(j)+(Integer)this.blockSize.get(j+1));
this.blockSize.remove(j+1);
this.blockAddress.remove(j+1);
this.blockStatus.remove(j+1);
this.blockNum--;
return;
}
}
System.out.println("未找到作业" + i + "正在使用中,请重新输入!!!");
}
public ArrayList getBlockAddress() {
return blockAddress;
}
public ArrayList getBlockStatus() {
return blockStatus;
}
public Integer getBlockNum() {
return blockNum;
}
public ArrayList getBlockSize() {
return blockSize;
}
public Integer getSize() {
return size;
}
public void setSize(Integer size) {
this.size = size;
}
public Integer getInitialAddress() {
return initialAddress;
}
public void setInitialAddress(Integer initialAddress) {
this.initialAddress = initialAddress;
}
public Integer getEndAddress() {
return endAddress;
}
}
// IdlePartition空闲区类
import java.util.ArrayList;
public class IdlePartition {
private ArrayList initialAddress; //起始地址
private ArrayList lenth; //长度
private ArrayList status; //状态
public IdlePartition() {}
public ArrayList getInitialAddress() {
return initialAddress;
}
public void setInitialAddress(ArrayList initialAddress) {
this.initialAddress = initialAddress;
}
public ArrayList getLenth() {
return lenth;
}
public void setLenth(ArrayList lenth) {
this.lenth = lenth;
}
public ArrayList getStatus() {
return status;
}
public void setStatus(ArrayList status) {
this.status = status;
}
}
//Test测试类
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
RAM ram = new RAM(1024,0);
ram.Changing();
ram.Printer1(ram.Changing());
Scanner input = new Scanner(System.in);
while(true){
System.out.println("1、申请\t2、释放(输入其它数字退出)");
System.out.print("请输入要对作业进行的操作序号:");
switch (input.nextInt()){
case 1:
System.out.print("请输入要申请的作业序号:");
ram.Applying(input.nextInt());
break;
case 2:
System.out.print("请输入要释放的作业序号:");
ram.Freeing(input.nextInt());
break;
default:
System.exit(0);
break;
}
ram.Changing();
ram.Printer1(ram.Changing());
ram.Printer();
}
}
}