操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计

合集下载

磁盘调度操作系统实验报告

磁盘调度操作系统实验报告

磁盘调度操作系统实验报告一、实验目的:本次实验主要目的是通过模拟实现磁盘调度算法,加深对操作系统磁盘调度原理的理解,并学会使用操作系统磁盘调度算法解决实际问题。

二、实验内容:1.磁盘调度算法原理分析:磁盘调度算法是操作系统中的重要组成部分,它的任务是合理安排磁盘上数据的存取顺序,以提高磁盘的效率。

常见的磁盘调度算法有先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯算法(SCAN)等。

2.模拟实现磁盘调度算法:本实验选择最短寻道时间优先算法(SSTF)作为示例进行模拟实现。

SSTF算法的原理是优先选择离当前磁头位置最近的磁道进行访问,以减少磁头移动时间。

实验步骤:1.根据实际情况,创建一个磁道队列,记录需要访问的磁道序号。

2.初始化磁盘的起始位置和访问队列。

3.对访问队列进行排序,按照磁头当前位置到磁道的距离从小到大排列。

4.根据排序后的队列顺序,依次访问磁道,并记录磁头移动的距离。

5.计算平均寻道长度。

三、实验结果分析:通过模拟实现SSTF磁盘调度算法,我们获得了磁头对每个磁道的访问顺序和总共的磁头移动距离。

根据实验结果,我们可以发现SSTF算法相对于其他算法具有一定的优势。

在实际应用中,根据不同的实际情况,可以选择合适的磁盘调度算法以优化磁盘的访问效率。

四、实验总结:通过本次实验,我们对磁盘调度算法的原理和实现有了更深入的了解。

磁盘调度算法作为操作系统中一个重要的模块,对提高磁盘的读写效率起着重要的作用。

在实际应用中,我们需要根据具体问题选择合适的磁盘调度算法,以达到最优的访问效果。

(完整word版)进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料(word文档良心出品)

(完整word版)进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料(word文档良心出品)

江苏科技大学操作系统实验报告(2015/2016学年第2学期)课程名称:操作系统指导教师:实验地点:西校区图书馆计算机机房学生姓名:学生学号:院系:计算机科学与工程学院专业:计算机科学与技术2016年5 月15 日实验一进程调度一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。

二、实验内容1.优先权法、轮转法简化假设1)进程为计算型的(无I/O)2)进程状态:ready、running、finish3)进程需要的CPU时间以时间片为单位确定2.算法描述1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。

2)轮转法三、实验要求1.产生的各种随机数的取值范围加以限制,如所需的CPU时间限制在1~20之间。

2.进程数n不要太大通常取4~8个3.使用动态数据结构4.独立编程5.二种调度算法四、实验过程//秦魏编写要拷贝使用无(fa)偿(ge)使(hong)用(bao)#ifndef Maxpriority_H#define Maxpriority_H#define arrayLenth 100;template<class T>class Maxheap{T *heap;int heapsize, lenth;public:Maxheap(int n){ lenth = 0;heapsize = n;heap = new T[heapsize];}Maxheap(T *maxheap, int n){if (n < 0)return;lenth = n;heapsize = n;heap = new T[heapsize];int i;for (i = 0; i < heapsize; i++)heap[i] = maxheap[i];create();}~Maxheap(){ delete[]heap; }int Parent(int i){return (i+1)/ 2-1;//注意地址的转换,最后还要减去1}int Lchild(int i){ return 2 * (i+1)-1; }int Rchild(int i){ return 2 * i + 2; }void Maxheapify(int i){int l, r;l = Lchild(i);r = Rchild(i);int largest;if (l < lenth&&heap[l].priority>heap[i].priority)//第一个条件,起到一个判断是否为叶子节点的作用largest = l;else largest = i;if (r <lenth&&heap[r].priority > heap[largest].priority)largest = r;if (largest != i) swap(heap[largest], heap[i]),Maxheapify(largest);}void swap(T &a, T &b){T store;store = a;a = b;b = store;}void create(){int i;for (i = lenth / 2-1; i >= 0; i--)Maxheapify(i);}void insert(T &element){lenth++;heap[lenth-1] = element;create();}void print(){int i;for (i = 0; i < lenth; i++)cout << heap[i].priority;}int heapextractmax(){if (lenth==0) return -1;T max;max = heap[0];heap[0] = heap[lenth - 1];lenth--;Maxheapify(0);return max.task;}int empty(){ if (lenth == 0) return 1;return 0;}};#endif#ifndef Quene_H#define Quene_H#define size 1000//队列先进先出,从队尾进,从对头出template<class T>class Cirquene{T a[size];int front,rear;public:Cirquene(){front=rear=size-1;}~Cirquene(){ }void Enquene(T &e){if((rear+1)%size==front) throw"上溢";rear=(rear+1)%size;a[rear]=e;}int Dequene(){if(rear==size) throw"下溢";if (Empty()) return -1;else{front = (front + 1) % size;return a[front].task;}}int Getfront(){return front;}int Empty(){if (front == rear) return 1;return 0;}void print(){datatype e = a[rear];int i;do{i = e.pre;cout << e.x << '\t' << e.y << endl;e = a[i];} while (i!=-1);//注意这边i的取值}};#endif#include<iostream>#include "Maxheap.h"#include"Quene.h"using namespace std;enum State{//enum变量后用逗号隔开!!!!!ready,exe,blo,fin,};//任务状态struct PCB//优先级队列通过堆排序实现{int task;//任务int priority;//优先级int AexeTime;//已经运行时间int SexeTime;//剩余运行时间int blocktime;//阻塞时间State state;//任务状态};int checkstate(PCB *program){ int i;//检查是否所有程序都已运行结束for (i = 0; i < 5; i++)if (program[i].state != fin) return 0;return 1;}void PSA(Maxheap<PCB> Test,PCB *program,int Arrtime[],int quantum ){//1个单位时间检查一次用堆排序实现优先级队列int m = 0, alltime = 0,num=0,k,time=0;while (!checkstate(program)){if (num < 5)for (m = 0; m < 5; m++)if (alltime == Arrtime[m]) Test.insert(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;//到达到达时间进入就绪队列if(alltime==0||k==-1) k= Test.heapextractmax();//在无进程运行后序有进程进入时应该抛出!!!!alltime++, time++;if (k == -1) cout << "从" << alltime -1<< "到" << alltime << "单位时间无进程运行" << endl;if (k != -1){program[k].state = exe,program[k].AexeTime++,program[k].SexeTime--,program[k].priority-=3,//优先级减3cout << "从" << alltime-1 << "到" << alltime << "单位时间" << k + 1 << "进程运行" << endl;if (program[k].SexeTime == 0) program[k].state = fin, time = 0,cout << "进程" <<k + 1 << "在" << alltime<< "单位时间运行结束" << endl,k = Test.heapextractmax();if (program[k].SexeTime != 0&&time==quantum) program[k].state = ready,Test.insert(program[k]), time = 0, k = Test.heapextractmax();}}}void RR(PCB *program, int i, int Arrtime[], int quantum){//优先级列表用队列实现int m, k, num=0, alltime=0,time=0;Cirquene<PCB> priority;while (!checkstate(program)){if(alltime==0) for (m = 0; m < i; m++)if (alltime == Arrtime[m]) priority.Enquene(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;//找到第一个到达的进程if(alltime==0||k==-1) k = priority.Dequene();//开始调度alltime++, time++;if (alltime != 0 && num<i) for (m = 0; m < i; m++)//先判断下一个时刻是否有进程到达原因是在一个进程运行结束同时另外一个进程到达到达的那个进程应该首先进入就绪队列if (alltime == Arrtime[m]) priority.Enquene(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;if (k == -1) cout << "从" << alltime-1<< "到" << alltime << "单位时间无进程运行" << endl;else{program[k].state = exe,program[k].AexeTime++,program[k].SexeTime--;cout << "从" << alltime -1<< "到" << alltime << "单位时间" << k + 1 << "进程运行" << endl;if (program[k].SexeTime == 0)program[k].state = fin,time = 0,cout << "进程" << k + 1 << "在" << alltime << "单位时间运行结束" << endl, k = priority.Dequene();if (time == quantum)if (program[k].SexeTime != 0) program[k].state = ready,priority.Enquene(program[k]),k = priority.Dequene(),time=0;}}}int main(){int task[5] = { 0,1,2,3,4 };//任务int ExeTime[5] = { 5, 5, 3, 1, 3};//运行时间int priority[5] = {2,5,2,4,3 };//优先级int ArrTime[5] = { 4, 3, 2,0,4 };//到达时间PCB program[5],program2[5];int i;for (i = 0; i<5; i++){program[i].task = task[i],program2[i].task = task[i] ;program[i].priority = priority[i],program2[i].priority = priority[i];program[i].AexeTime = 0, program2[i].AexeTime = 0;program[i].SexeTime = ExeTime[i], program2[i].SexeTime = ExeTime[i];program[i].blocktime = 0, program2[i].blocktime = 0;program[i].state = blo,program2[i].state = blo ;}//初始化pcb*/Maxheap<PCB> Test(5);int quantum=2;//时间片为2cout << "优先权法:" << endl;PSA(Test, program, ArrTime,quantum);cout << "轮转调度法:" << endl;RR(program2, 5, ArrTime, quantum);system("pause");return 0;}五、实验分析与实现1.轮转法调度,具有先进先出的特点,所以利用队列实现2.优先级调度算法具有优先级动态变化的特点,每一次进行优先级要排序。

操作系统课程设计报告进程调度

操作系统课程设计报告进程调度

前言操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源旳计算机程序, 是直接运营在“裸机”上旳最基本旳系统软件, 任何其他软件都必须在操作系统旳支持下才干运营。

操作系统是顾客和计算机旳接口, 同步也是计算机硬件和其他软件旳接口。

操作系统旳功能涉及管理计算机系统旳硬件、软件及数据资源, 控制程序运营, 改善人机界面, 为其他应用软件提供支持, 让计算机系统所有资源最大限度地发挥作用, 提供多种形式旳顾客界面, 使顾客有一种好旳工作环境, 为其他软件旳开发提供必要旳服务和相应旳接口等。

事实上, 顾客是不用接触操作系统旳, 操作系统管理着计算机硬件资源, 同步按照应用程序旳资源祈求, 分派资源, 如: 划分CPU时间, 内存空间旳开辟, 调用打印机等。

操作系统旳重要功能是资源管理, 程序控制和人机交互等。

计算机系统旳资源可分为设备资源和信息资源两大类。

设备资源指旳是构成计算机旳硬件设备, 如中央解决器, 主存储器, 磁盘存储器, 打印机, 磁带存储器, 显示屏, 键盘输入设备和鼠标等。

信息资源指旳是寄存于计算机内旳多种数据, 如系统软件和应用软件等。

操作系统位于底层硬件与顾客之间, 是两者沟通旳桥梁。

顾客可以通过操作系统旳顾客界面, 输入命令。

操作系统则对命令进行解释, 驱动硬件设备, 实现顾客规定。

本次课程设计我们将对上学期所学旳知识进行系统旳应用, 而达到巩固知识旳作用目录1问题概述 (2)2需求分析 (2)3 概要设计 (2)3.1重要功能 (2)3.2 模块功能构造 (3)3.3 软硬件环境 (3)3.4数据构造设计 (3)4 具体设计 (4)4.1“先来先服务(FCFS)调度算法” (4)4.2“短进程调度算法(SPF)” (7)4.3“高响应比优先调度算法” (10)4.4“优先级调度(非抢占式)算法” (13)5 系统测试及调试 (15)5.1测试 (15)5.2调试过程中遇到旳问题 (16)6 心得体会 (17)7 参照文献 (18)8 附录 (19)1问题概述编写一种进程调度程序, 容许多种进程并发执行。

操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计)

操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计)

实验三 进程调度一、 实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。

二、 实验要求1. 设计进程调度算法,进程数不定2. 包含几种调度算法,并加以实现3. 输出进程的调度过程——进程的状态、链表等。

三、 参考例1. 题目——优先权法、轮转法简化假设1) 进程为计算型的(无I/O )2) 进程状态:ready 、running 、finish3) 进程需要的CPU 时间以时间片为单位确定2. 算法描述1) 优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。

2) 轮转法四、 实验流程图 开始 键盘输入进程数n ,和调度方法的选择 优先权法? 轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?结束 N YY注意:1. 产生的各种随机数的取值范围加以限制,如所需的CPU 时间限制在1~20之间。

2. 进程数n 不要太大通常取4~8个3. 使用动态数据结构4. 独立编程5. 至少三种调度算法6. 若有可能请在图形方式下,将PCB 的调度用图形成动画显示。

五.实验过程:(1)输入:进程流文件(1.txt ),其中存储的是一系列要执行的进程, 每个作业包括四个数据项:进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO 算法,优先数调度算法,时间片轮转调度算法产生n需的时间片数,已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空吗? =轮转时间片数?NY YY 结束 N(2)程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status, &pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<<e ndl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度 ********************/ ";cout<<endl<<endl; }//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}}(3)运行结果:输入进程流文件名1.txt即可得出以下输出结果:实验二银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

操作系统磁盘调度算法实验报告

操作系统磁盘调度算法实验报告

目录目录 (1)1.课程设计目的 (1)1.1编写目的 (1)2.课程设计内容 (1)2.1设计内容 (1)3.1模块调用关系图..................................................... 错误!未定义书签。

4.测试数据和结果 (4)5.参考文献 (7)6.总结 (7)1.课程设计目的1.1编写目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。

2.课程设计内容2.1设计内容系统主界面可以灵活选择某种算法,算法包括:先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)。

1、先来先服务算法(FCFS)这是一种比较简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。

此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。

2、最短寻道时间优先算法(SSTF)该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。

其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。

在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。

3、扫描算法(SCAN)扫描算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。

例如,当磁头正在自里向外移动时,扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。

进程的调度算法实验报告-计算机操作系统教程(第三版)

进程的调度算法实验报告-计算机操作系统教程(第三版)

进程的调度算法实验报告-计算机操作系统教程(第三版)进程的调度算法实验报告(完整版)⼀、实验⽬的:⽤⾼级语⾔编写和调试⼀个简单的进程调度程序。

加深了解有关进程控制块,进程队列的概念,并体会和了解优先数和时间⽚调度算法的具体实施⽅法。

⼆、实验内容:根据不同的调度算法模拟操作系统对进程的调度。

调度算法有⼆种:动态优先级法和时间⽚循环法。

1、设计进程控制块PCB表结构,分别适⽤优先数调度算法和循环时间⽚轮转算法。

2、PCB结构通常包括以下信息:进程名、进程优先数、轮转时间⽚、进程的CPU时间,进程状态等。

根据调度算法不同,PCB结构可作适当的调整。

3、建⽴进程队列。

对不同的算法编制不同的⼊链程序编制两种进程调度算法:a、优先数调度;b、循环时间轮转调度三、实验设计1.实验原理:2.算法思想:以时间⽚为计量单位A:优先数调度算法1)系统初始化时给每⼀个进程赋⼀个NEEDTIME和初始PRI。

并按优先数⼊队。

2)系统每次选定⼀个优先级最⾼的进程投⼊运⾏,进程每执⾏⼀次,优先数减2,并将它的进程占⽤的CPU时间加10,进程到完成还要的CPU时间减10。

3)每当⼀个进程运⾏⼀个时间⽚后,系统根据它的CPUTIME来判断它是否已经结束,若CPUTIME>0,那么将它重新排⼊就绪队列。

4)如果系统中尚有进程没有运⾏完毕,那么转⼊2)。

B:循环时间⽚轮转算法1)系统初始化时给每⼀个进程赋以⼀个NEEDTIME,并将所有进程按进⼊的次序排成⼀个队列。

2)取队头进程,并投⼊运⾏。

3)采⽤相对固定时间⽚(ROUND),进程每执⾏⼀次,进程占⽤的CPU时间加ROUND,进程到完成还要的CPU时间减ROUND。

并排到就绪队列的尾部。

4)如果当前进程的NEEDTIME>0,那么将它排到队尾。

5)如果尚有进程在队列中,那么转⼊2)3.编程语⾔、主要数据结构和意义使⽤VC6.0语⾔PCB结构:name 进程名pri /round 进程优先数/进程轮转时间⽚cputime 进程占⽤的CPU时间needtime 进程到完成还要的时间state 进程状态(假设状态为 Ready、Run、Finish)next 链指针void showlist(link,char*,int);//显⽰进程队列void instlist(link,link);//按优先数插⼊进程void appenlist(link,link);//按就绪先后加⼊进程link gethead(link);//取队⾸进程4.流程图(优先数算法)5. 源程序(含主要注释)#include "stdlib.h"#include "iostream.h"#include "string.h"const int MAX= 5;const int ROUND=2;const char *ITOA[10]={"0","1","2","3","4","5","6","7","8","9"}; typedef enum flag{Ready,Run,Finish}; struct pcb{public:char name[10];//进程名int pri; //进程优数int round; //进程轮转时间⽚int cputime; //进程占⽤的CPU时间int needtime; //进程到完成还要的CPU时间flag state; //进程状态struct pcb *next;//链指针};typedef struct pcb plist;{void showlist(link,char*,int);//显⽰进程队列void instlist(link,link);//按优先数插⼊进程void appenlist(link,link);//按就绪先后加⼊进程link gethead(link);//取队⾸进程int num=MAX+1;char str[10];link ptr,head1,head2;int i;int j=0;head1=new plist;head1->next=NULL;//就绪队⾸指针head2=new plist;head2->next=NULL;//完成队⾸指针while ((num>MAX)||(num<1)){// printf("请输⼊演⽰进程数\n");cout<<"请输⼊演⽰进程数:";// scanf("%d",&num);cin>>num;if (num>MAX) cout<<"输⼊的演⽰进程数太⼤!请输⼊⼩于等于5的数。

操作系统磁盘调度实验报告

操作系统磁盘调度实验报告

操作系统磁盘调度实验报告一、实验目的:1.了解磁盘调度算法的基本原理;2.熟悉磁盘I/O的实验操作;3.掌握C语言程序编写的磁盘调度算法实现。

二、实验原理:磁盘调度是指操作系统为了提高磁盘I/O的效率而对磁盘请求进行排序和调度的过程。

常见的磁盘调度算法有FCFS(先来先服务)、SSTF (最短寻道时间优先)、SCAN(扫描)、C-SCAN(循环扫描)等。

本次实验中,我们将选择SSTF算法来对磁盘请求进行调度。

SSTF算法的基本思想是选择离当前磁头最近的磁道先进行访问。

三、实验环境:1. 操作系统:Windows 10;2. 开发工具:Visual Studio 2024四、实验步骤:1.创建C语言项目并添加源代码文件;2.实现磁盘调度算法的主要函数,包括判断方向函数、SSTF算法函数;3.在主函数中读取磁道请求,调用SSTF算法函数进行磁道调度;4.运行程序,观察磁道调度结果。

五、实验代码:```c#include<stdio.h>#include<stdlib.h>#include<limits.h>//定义磁盘请求的最大数量#define MAX_REQUEST 100//定义磁盘请求结构体typedef struct diskRequestint track; //磁道号int visited; //记录当前请求是否被访问过(0表示未访问,1表示已访问)} DiskRequest;//全局变量,用来记录磁盘请求的数量int n;//方向判断函数,若当前头部位置比目标位置小,则返回1;否则返回-1int determineDirection(int current, int target)if (current < target)return 1;elsereturn -1;//SSTF算法函数,使用SSTF算法将未被访问的磁道号按顺序调度//current: 当前磁头所在磁道号//requests: 磁盘请求数组void SSTF(int current, DiskRequest* requests)int visited = 0; //记录已访问的磁道数量int totalSeekTime = 0; //记录总寻道时间int direction = determineDirection(current,requests[0].track); //记录当前移动方向int next = current; //记录下一个要访问的磁道号//循环调度直到所有磁道访问完毕while (visited < n)int minSeekTime = INT_MAX; //记录最短寻道时间//遍历从当前位置开始的所有未被访问的磁道for (int i = 0; i < n; i++)if (!requests[i].visited)//计算当前未被访问的磁道与当前位置的距离int seekTime = abs(current - requests[i].track); if (seekTime < minSeekTime)minSeekTime = seekTime;next = requests[i].track;}}}//更新总寻道时间totalSeekTime += minSeekTime;//将当前访问的磁道标记为已访问for (int i = 0; i < n; i++)if (requests[i].track == next)requests[i].visited = 1;visited++;break;}}//更新当前位置current = next;}printf("SSTF Algorithm:\n");printf("Total Seek Time: %d\n", totalSeekTime);printf("Average Seek Time: %.2f\n", (float)totalSeekTime / n);int mainDiskRequest* requests; //磁盘请求数组int current; //当前磁头所在磁道号//读取输入,获取磁盘请求的数量和当前磁头所在的磁道号printf("Please enter the number of disk requests: ");scanf("%d", &n);printf("Please enter the current disk track: ");scanf("%d", &current);//动态分配内存给磁盘请求数组requests = (DiskRequest*)malloc(n * sizeof(DiskRequest));//读取磁盘请求的磁道号printf("Please enter the disk requests:\n");for (int i = 0; i < n; i++)scanf("%d", &requests[i].track);requests[i].visited = 0; //初始化磁道为未访问状态}//调用SSTF算法对磁盘请求进行调度SSTF(current, requests);//释放内存free(requests);return 0;```六、实验结果与分析:1.实验输入:```Please enter the number of disk requests: 5Please enter the current disk track: 50Please enter the disk requests:4560102030```2.实验输出:```SSTF Algorithm:Total Seek Time: 75Average Seek Time: 15.00```3.实验分析:根据实验输入,我们可以得知当前磁头的位置为50,磁盘请求的磁道号依次为45、60、10、20、30。

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告1. 实验背景操作系统涉及到的进程调度算法是操作系统中的核心知识之一,这也是操作系统中较为重要的内容之一。

进程调度算法可以直接影响到操作系统的性能和系统的响应时间,因此这一方面是操作系统学习中不可避免的。

为了更好的理解和掌握进程调度算法,本次实验选用了比较经典的进程调度算法——SJF算法和RR算法,并对其进行详细的实验和分析。

2. 实验环境•操作系统:Windows 10•编译器:Dev-C++3. 实验内容本次实验分为两部分,第一部分为SJF算法的实验,第二部分为RR算法的实验。

3.1 实验一:SJF算法本实验中,我们首先编写了一个随机生成进程的程序,并为每个进程随机分配一个运行时间。

然后,我们用SJF算法对这些进程进行调度,记录下调度过程和每个进程的运行情况,最后统计出SJF算法的平均等待时间、平均周转时间和吞吐量。

3.1.1 实验步骤以下是我们在SJF算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•对进程按照时间长度进行排序•模拟SJF算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.1.2 实验结果经过实验,得到以下结果:•平均等待时间:13.97•平均周转时间:18.53•吞吐量:4.763.2 实验二:RR算法本实验中,我们使用Round Robin调度算法,对进程进行调度,并记录下调度过程和每个进程的运行情况,最后统计出RR算法的平均等待时间、平均周转时间和吞吐量。

3.2.1 实验步骤以下是我们在RR算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•设定时间片大小•模拟RR算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.2.2 实验结果经过实验,得到以下结果:•平均等待时间:25.63•平均周转时间:30.18•吞吐量:1.094. 实验分析4.1 SJF算法分析从SJF算法的实验结果可以看出,该算法能够在大多数情况下有效地减少进程的平均等待时间和平均周转时间,但是也存在一些问题,比如会导致优先级反转等情况,需要进一步考虑如何避免这些问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计实验一 进程调度一、 实验目的多道程序设计中,经常是假设干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情形下的处理机调度问题,加深对进程调度的明白得。

二、 实验要求1. 设计进程调度算法,进程数不定2. 包含几种调度算法,并加以实现3. 输出进程的调度过程——进程的状态、链表等。

三、 参考例1.题目——优先权法、轮转法简化假设1) 进程为运算型的〔无I/O 〕2) 进程状态:ready 、running 、finish3) 进程需要的CPU 时刻以时刻片为单位确定2.算法描述1) 优先权法——动态优先权当前运行进程用完时刻片后,其优先权减去一个常数。

2) 轮转法四、 实验流程图 开始 键盘输入进程数n ,和调度方法的选择 优先权法? 轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时刻按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?终止 N YY注意:1.产生的各种随机数的取值范畴加以限制,如所需的CPU 时刻限制在1~20之间。

2.进程数n 不要太大通常取4~8个3.使用动态数据结构4.独立编程5.至少三种调度算法6.假设有可能请在图形方式下,将PCB 的调度用图形成动画显示。

五.实验过程:〔1〕输入:进程流文件〔1.txt 〕,其中储备的是一系列要执行的进程, 每个作业包括四个数据项: 进程名 进程状态(1就绪 2等待 3运行) 所需时刻 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时刻,平均等待时刻本程序包括:FIFO 算法,优先数调度算法,时刻片轮转调度算法产生n需的时刻片数,已占用CPU 的时刻片数置为0按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空吗? =轮转时刻片数?NY YY 终止 N〔2〕程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时刻片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时刻优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时刻"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时刻:"<<total<<" 平均等待时刻:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<<endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时刻"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时刻:"<<total<<" 平均等待时刻:"<<total/quantity<<endl;}//时刻片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时刻片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl; }//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}}〔3〕运行结果:输入进程流文件名1.txt即可得出以下输出结果:实验二银行家算法一、实验目的死锁会引起运算机工作僵死,因此操作系统中必须防止。

相关文档
最新文档