第一篇：短作业优先调度和时间片轮转调度算法
实
验
报
告
学生姓名：
学 号：
指导教师：
一、实验室名称：
二、实验项目名称：进程调度算法的设计
三、实验原理：
短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。
时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。
四、实验目的：
通过对进程调度算法的设计，深入理解进程调度的原理
五、实验内容：
1．编写程序实现SJ（P）F算法 2．编写程序实现RR算法
六、实验器材（设备、元器件）：
装有VC++6.0的PC机一台
七、实验步骤：
1．打开VC，设计编写程序的源代码 2．编译运行程序的源代码
3．分析检验程序的结果是否正确 4．总结实验结果及结论
短进程优先调度源代码： #include “stdio.h” struct sjf{ char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf(“intput the process's name & arrivetime & servicetime:nfor exmple: a 0 100n”);for(i=0;i<=N-1;i++){ printf(“input the %dth process's information:n”,i+1);scanf(“%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} } void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;
printf(“run order:”);
printf(“%s”,p[0].name);for(k=1;k
printf(“nthe process's information:n”);
printf(“nnametarrivetservicetstarttfinishtzztdqzzn”);
for(k=0;k<=N-1;k++){ printf(“%st%-.2ft%-.2ft%-.2ft%-.2ft%-.2ft%-.2ftn”,p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);} } //排序
void sort(sjf *p,int N){
for(int i=0;i<=N-1;i++)
for(int j=0;j<=i;j++)
if(p[i].arrivetime
{
sjf temp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
} } //运行阶段
void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){ int k;
for(k=0;k<=N-1;k++)
{
if(k==0)
{
p[k].starttime=p[k].arrivetime;
p[k].finishtime=p[k].arrivetime+p[k].servicetime;}
else
{
p[k].starttime=p[k-1].finishtime;
p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}
}
for(k=0;k<=N-1;k++)
{
p[k].zztime=p[k].finishtime-p[k].arrivetime;
p[k].dqzztime=p[k].zztime/p[k].servicetime;
} } void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化 sort(p,N);
for(int m=0;m {if(m==0) p[m].finishtime=p[m].arrivetime+p[m].servicetime; else p[m].finishtime=p[m-1].finishtime+p[m].servicetime; int i=0; for(int n=m+1;n<=N-1;n++) {if(p[n].arrivetime<=p[m].finishtime)//判断内存中每次完成之后有多少到达的进程 i++; } float min=p[m+1].servicetime; int next=m+1;//m+1=n for(int k=m+1;k { if(p[k+1].servicetime {min=p[k+1].servicetime; next=k+1;} } sjf temp; temp=p[m+1]; p[m+1]=p[next]; p[next]=temp; } deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);} void main(){ int N; printf(“------短作业优先调度算法------n”); printf(“input the process's number:n”); scanf(“%d”,&N); input(a,N); sjf *b=a; sjf *c=a; sjff(b,N);} 时间片轮转法源代码： #include //物理页数 #define printf(“|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|n”)typedef struct PCB { int ID;int ReachTime;int TotalTime;}PCB;//进程号，到达时间和服务时间 typedef struct NOTE //备份 { Myprintf int ID;int TotalTime;}NOTE; PCB A[M];//5个进程 PCB a[M];NOTE temp;int queue[50];//记录调度的进程 int K=0;//调度进程数组的标识 void INIT()//初始化 { int i;for(i=0;i A[i].ID=-1;} } int GetNum()//计算进程数 { int i,j=0;for(i=0;i if(A[i].ID!=-1) { j++; } } return j;} int GetReach(int time)//找出到达进程号 { int i;for(i=0;i if(a[i].ReachTime<=time) { a[i].ReachTime=100; return i; } } return-1;} int GetInsert()//找出插入位置 { int i;for(i=0;i if(A[i].ID==-1) return i;} return-1;} void Forward(int num)//前移 { int i;for(i=0;i A[i].ID=A[i+1].ID; A[i].TotalTime=A[i+1].TotalTime;} A[num-1].ID=-1;} void Process()//执行进程 { queue[K]=A[0].ID;K++;A[0].TotalTime--;temp.ID=A[0].ID;temp.TotalTime=A[0].TotalTime;} void main(){ int i;int time;int t=0;int reach;int insert;int num;printf(“RR算法nn”);INIT();for(i=0;i printf(“请输入进程ID：”); scanf(“%d”,&a[i].ID); printf(“请输入到达时间：”); scanf(“%d”,&a[i].ReachTime); printf(“请输入服务时间：”); scanf(“%d”,&a[i].TotalTime); } for(i=0;i { insert=GetInsert(); A[insert].ID=a[reach].ID; A[insert].TotalTime=a[reach].TotalTime; num=GetNum(); if(num==1) continue;//进程数为1 else { //进程数不为1 Process(); Forward(num); if(temp.TotalTime!=0) { A[num-1].ID=temp.ID; A[num-1].TotalTime=temp.TotalTime; } } } else//没有进程到达 { num=GetNum(); if(num==1) {//进程数为1 Process(); if(temp.TotalTime==0) { A[0].ID=-1; } } else if(num==0) } continue;//进程数为0 else { Process(); Forward(num); if(temp.TotalTime!=0) { A[num-1].ID=temp.ID; A[num-1].TotalTime=temp.TotalTime; } } } } printf(“n”);printf(“调度顺序为：n”);Myprintf;for(i=0;i<50;i++){ if(queue[i]!=-1) printf(“|%2d ”,queue[i]);} printf(“|n”);Myprintf;printf(“n”); 八、实验数据及结果分析： 短作业优先调度算法的实验结果： 时间片轮转调度算法结果： 九、实验结论： 本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。 十、总结及心得体会： 通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。 十一、对本实验过程及方法、手段的改进建议： 本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。 报告评分： 指导教师签字： 《操作系统》课程实验报告 姓名：陈凯 学号：541413430202 地点：四教楼301 指导老师：张旭 专业班级：嵌入式软件14-02 实验名称：短作业优先调度算法 一、实验目的： 测试数据可以随即输入或从文件中读入。必须要考虑到作业的到达时间 最终能够计算每一个作业的周转时间。 二、实验内容： 模拟实现短作业调度算法，具体如下： 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化。显示函数： 1、显示当前调度的是哪个作业，后备队列中有哪些作业 2、最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑到达时间 调度函数：每次从已到达的作业队列队首调度优一个作业执行。删除函数：作业结束后撤销。 三、实验代码 #include char name[10];//进程名 floatarrivetime;//到达时间 floatservicetime;//服务时间 floatstarttime; //开始时间 floatfinishtime;//完成时间 floatzztime;//周转时间 floatdqzztime; //带权周转时间 }; sjf b[100]; //定义短作业优先算法进程的最大数量 voidSinput(sjf *p,int N) //输入函数 { int i; printf(“输入进程的名称、到达时间、服务时间:n”);for(i=0;i<=N-1;i++){ printf(“输入第%d进程的名称、到达时间、服务时间:”,i+1);scanf(“%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} } //输出函数 voidSPrint(sjf *p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,floatzztime,floatdqzztime,int N){ int k; printf(“n执行顺序:n”);printf(“%s”,p[0].name); for(k=1;k { printf(“-%s”,p[k].name);} printf(“n进程名tarrivetservicetstarttfinishtzztdqzzn”); for(k=0;k<=N-1;k++) { printf(“%st%-.2ft%-.2ft%-.2ft%-.2ft%-.2ft%-.2ftnn”,p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime); } } voidSsort(sjf *p,int N) //按短作业优先算法排序 { for(int i=1;i<=N-1;i++)for(int j=1;j<=i;j++) if(p[i].servicetime sjf temp;temp=p[i]; p[i]=p[j]; p[j]=temp;} } //运行结果 voidSdeal(sjf *p, float arrivetime,floatservicetime,floatstarttime,floatfinishtime,float&zztime,float&dqzztime,int N){ int k; for(k=0;k<=N-1;k++) { if(k==0){ p[k].starttime=p[k].arrivetime; p[k].finishtime=p[k].arrivetime+p[k].servicetime; } else { p[k].starttime=p[k-1].finishtime;//开始时间=前一个进程的完成时间 p[k].finishtime=p[k-1].finishtime+p[k].servicetime; //结束时间=前一个进程的完成时间+现在进程的服务时间 } } for(k=0;k<=N-1;k++){ p[k].zztime=p[k].finishtime-p[k].arrivetime; //周转时间=完成时间-到达时间 p[k].dqzztime=p[k].zztime/p[k].servicetime; //带权周转时间=周转时间/服务时间 } } void SJF(sjf *p,int N){ float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0; Ssort(p,N); Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);} void main()//主函数 { int M;printf(“------------短作业优先调度算法-----------n”);printf(“输入作业数:”);scanf(“%d”,&M); Sinput(b,M);SJF(b,M);} 四、实验结果 五、实验总结 通过本次实验让我学到了很多关于作业与作业调度的知识，今后我会好好努力学习。 实验4 优先级和时间片轮转调度 一、实验要求 通过编写程序实现进程高优先权和按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 二、实验内容 进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。源程序代码部分： #include “stdio.h” #include char name; int status;int pri; int ptime;int ax,bx,cx,dx; int pc; int psw; }pcb;pcb *processarray[max];static int processnum;pcb *createprocess(pcb *processarray[])组 { pcb *p,*q; int a,b,c,d,m,n,r,t; char ID; q=NULL;printf(“input the first nine status pcb:”); scanf(“n%c%d%d%d%d%d%d%d%d”,&ID,&a,&b,&c,&d,&m,&n,&r,&t); for(int i=0;i p=(pcb*)malloc(sizeof(pcb)); p->name=ID; p->ax=a; p->bx=b; p->cx=c; p->dx=d; p->pc=m; p->psw=n; p->pri=r; p->ptime=t; p->status=aready; processnum++; processarray[i]=p; printf(“input the next seven status pcb: ”); scanf(“n%c”,&ID); if(ID == '*') break; scanf(“%d%d%d%d%d%d%d%d”,&a,&b,&c,&d,&m,&n,&r,&t);} for(int j=0;j { q=processarray[j];printf(“n process name.status.ax.bx.cx.dx.pc.psw.pri.ptimen ”); printf(“%10c%5d%5d%5d%5d%5d%5d%5d%5d%5d”,q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime); } return *processarray;} void processRR(pcb *processarray[]){int i;int j; pcb *q;int totaltime=0; for(i=0;i ptime%4==0) totaltime+=processarray[i]->ptime; else totaltime+=(processarray[i]->ptime/4+1)*4;} printf(“nUsing RR method:”); printf(“n process name.status.ax.bx.cx.dx.pc.psw.pri.ptimen ”); for(i=0;i if(q->ptime==0) j=0; else if(q->ptime<=etime) { q->status=pfree; q->ptime=0; printf(“n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d”,q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime);/*check process running status */ totaltime-=etime;} else if(q->ptime>etime) {q->status=running; q->ptime=q->ptime-etime; printf(“n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d”,q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime);/*check process running status */ q->status=aready; totaltime-=etime;} if(i i++; else if(i==processnum-1) i=0; }} void processStaPri(pcb *processarray[]){ pcb *q; int i,j;printf(“n the process use StaPri method.n”); printf(“running the frist process:n”); for(i=0;i {if(processarray[j]->pri>processarray[j+1]->pri){q=processarray[j];processarray[j]=processarray[j+1];processarray[j+1]=q;}} for(i=0;i { processarray[i]->status=running; q=processarray[i]; printf(“n process name.status.ax.bx.cx.dx.pc.psw.pri.ptimen ”); printf(“n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d”,q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime);/*check process running status */ q->status=pfree;} for(j=0;j printf(“n检查进程%3c是否结束,进程当前状态:%3d”,q->name,q->status);} printf(“ngame is over!n”);} void main(){ *processarray=createprocess(processarray);processRR(processarray);processStaPri(processarray); } 三、实验报告 1．在源程序上写出注释。2．画出程序流程图。3．调试程序并写出运行结果。 电梯优先调度算法 电梯调度算法(ms InterView) 移臂调度算法包括以下四种： 1）先来先服务算法：根据访问者提出访问请求的先后次序来决定执行次序。 2）最短寻找时间优先调度算法：从等待的访问者中挑选寻找时间最短的那个请求执行，而不管访问者的先后次序。 3）电梯调度扫描算法：从移动臂当前位置沿移动方向选择最近的那个柱面的访问者来执行，若该方向上无请求访问时，就改变移动方向再选择。 4）单向扫描调度算法：从0柱面开始往里单向扫描，扫到哪个执行哪个。 */ // t1.cpp : 定义控制台应用程序的入口点。 // #include “stdafx.h” #include“math.h” #include“stdlib.h” #include“string.h” struct Head { int nPosition;bool bVisited;}; void Visit(struct Head *pHead){ printf(“visite cy:%dn”,pHead->nPosition);pHead->bVisited=true;} int ReadInputKeyboard(struct Head *pHead,int *pCurrentPosition,int nMaxNumber){ int i; printf(“please input Current position:”);scanf(“%d”,pCurrentPosition); printf(“please input will visit position:”);for(i=0;i scanf(“%d”,&pHead[i].nPosition);pHead[i].bVisited=false;if(pHead[i].nPosition<0)break;} return i;} int ReadInputFile(struct Head *pHead,int *pCurrentPosition,int nMaxNumber){ int i; char szFileName[256],*q,*p,szTemp[20];printf(“please input filename:”);scanf(“%s”,szFileName); FILE *pFile=fopen(szFileName,“r”);if(pFile==NULL){ printf(“open file %s error”,szFileName);return-1;} for(i=0;!feof(pFile)&&i p=szFileName;fgets(p,256,pFile); while(q=strchr(p,',')){ memset(szTemp,0,sizeof(szTemp)*sizeof(char));strncpy(szTemp,p,q-p);p=q+1;if(i==0) *pCurrentPosition=atoi(szTemp);else { pHead[i-1].nPosition=atoi(szTemp);pHead[i-1].bVisited=false;} i++;} memset(szTemp,0,sizeof(szTemp)*sizeof(char));pHead[i-1].nPosition=atoi(p);pHead[i-1].bVisited=false;//i++; } fclose(pFile);return i;} int FifoVisit(int nCurrentPosition,struct Head *pHead,int nNumber){ //先来先服务 int nHaveVisited=0;int nMoveDistance=0;int i;while(nHaveVisited for(i=0;i if(pHead[i].bVisited)continue; Visit(&pHead[i]);nHaveVisited++; nMoveDistance+=abs(nCurrentPosition-pHead[i].nPosition);nCurrentPosition=pHead[i].nPosition;} } printf(“the sum of move distance:%dn”,nMoveDistance);return nMoveDistance;} int SsfoVisit(int nCurrentPosition,struct Head *pHead,int nNumber){ // 最短寻找时间优先 int nHaveVisited=0;int nMoveDistance=0;int nMinDistance=0;int nMinIndex=0;int i; while(nHaveVisited nMinDistance=0xffff;nMinIndex=0;//找最小值 for(i=0;i if(pHead[i].bVisited)continue; if(nMinDistance>abs(pHead[i].nPosition-nCurrentPosition)){ nMinDistance=abs(pHead[i].nPosition-nCurrentPosition);nMinIndex=i;} } //访问 Visit(&pHead[nMinIndex]);nHaveVisited++; nMoveDistance+=nMinDistance; nCurrentPosition=pHead[nMinIndex].nPosition;} printf(“the sum of move distance:%dn”,nMoveDistance);return nMoveDistance;} int DtVisit(int nCurrentPosition,bool bOut,struct Head *pHead,int nNumber){ //电梯调度算法 int nHaveVisited=0;int nMoveDistance=0;int nMinDistance=0;int nMinIndex=0;int i; while(nHaveVisited nMinDistance=0xffff;nMinIndex=0;//找最小值 for(i=0;i if(pHead[i].bVisited)continue; if(bOut&&pHead[i].nPosition if(nMinDistance>abs(pHead[i].nPosition-nCurrentPosition)){ nMinDistance=abs(pHead[i].nPosition-nCurrentPosition);nMinIndex=i;} } } if(nMinDistance==0xffff){ bOut=!bOut;continue;} //访问 Visit(&pHead[nMinIndex]);nHaveVisited++; nMoveDistance+=nMinDistance; nCurrentPosition=pHead[nMinIndex].nPosition;} printf(“the sum of move distance:%dn”,nMoveDistance);return nMoveDistance;} int DxVisit(int nCurrentPosition,struct Head *pHead,int nNumber){ //单向调度算法 int nHaveVisited=0;int nMoveDistance=0;int nMinDistance=0;int nMinIndex=0;int i;while(nHaveVisited nMinDistance=0xffff;nMinIndex=0;//找最小值 for(i=0;i if(pHead[i].bVisited)continue; if(pHead[i].nPosition>nCurrentPosition){ if(nMinDistance>abs(pHead[i].nPosition-nCurrentPosition)){ nMinDistance=abs(pHead[i].nPosition-nCurrentPosition);nMinIndex=i;} } } if(nMinDistance==0xffff){ nMoveDistance+=199-nCurrentPosition;nCurrentPosition=0;continue;} //访问 Visit(&pHead[nMinIndex]);nHaveVisited++; nMoveDistance+=nMinDistance; nCurrentPosition=pHead[nMinIndex].nPosition;} printf(“the sum of move distance:%dn”,nMoveDistance);return nMoveDistance;} int main(int argc, char* argv[]){ //p114 struct Head mylist[20];//={98,false,183,false,37,false,122,false,14,false,124,false,65,false,67,false}; //int nCurrentPosition=53; //int nRealNumber=8; int nCurrentPosition=0; int nRealNumber=ReadInputFile(mylist,&nCurrentPosition,20);// FifoVisit(nCurrentPosition,mylist,nRealNumber); // SsfoVisit(nCurrentPosition,mylist,nRealNumber); //DtVisit(nCurrentPosition,false,mylist,nRealNumber); DxVisit(nCurrentPosition,mylist,nRealNumber); return 0;} 小心 计算机专业类课程 实验报告 课程名称：操作系统 学 院：软件学院 专 业：软件工程 学生姓名：李 希 学 号：2010231020018 指导教师：丁老师 日 期： 2012年5月5日 电子科技大学计算机学院实验中心 电 子 科 技 大 学 实 验 报 告 实验一 一、实验名称： 进程管理 二、实验学时：4 三、实验内容和目的： 实验内容：（1）进程的创建 写一段源程序，创建两个进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示字符。观察纪录屏幕上的显示结果，然后分析原因。（2）进程的控制 修改编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。实验目的： （1）加深对进程概念的理解，明确进程和程序的区别。 （2）进一步认识并发执行的实质。 （3）分析进程竞争资源现象，学习解决进程互斥的方法。 四、实验原理： 利用fork函数来创建子进程，并返回子进程的ID号。 利用lockf函数来实现信号量对进程的资源竞争的调度，和互斥的方法。 五、实验器材（设备、元器件）: 一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤： （1）先写好2个子进程程序，并且让2个子程序在屏幕上分别打印出A,B（2）父进程创建2个子进程，并在屏幕上打印出C。（3）观察进程竞争资源的现象。 七、实验数据及结果分析： 电子科技大学计算机学院实验中心 子进程A的代码： #include cout<<“I'm Process A/n”< } 子进程B的代码： #include cout<<“I'm Process B”< //#include “stdafx.h” #include void print_error(){ DWORD nErrorNo = GetLastError();LPSTR lpBuffer; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM，NULL，nErrorNo，LANG_NEUTRAL，(LPTSTR)& lpBuffer，0 , NULL);if(lpBuffer == NULL) | } { } printf(“%s(%d).n”, lpBuffer, nErrorNo);lpBuffer = “Sorry, cannot find this error info.”;int fork(const char* pszApplication,HANDLE& hProcess) { STARTUPINFO si={sizeof(si)}; } void lockf(HANDLE hObj){ } int main(int argc, char* argv[]){ HANDLE hProcess1,hProcess2;int child1=fork(“C:操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦ProcessADebugProcessA.exe”,hProcess1);if(-1==child1) } lockf(hProcess1);cout << “fork error!n”;return-1;{ case WAIT_OBJECT_0: } printf(“nProcess exit.n”);break;printf(“nTime out.n”);break;printf(“nWait Failed.n”);print_error();break;DWORD state = WaitForSingleObject(hObj,INFINITE);switch(state)PROCESS_INFORMATION pi;if(!CreateProcess(pszApplication,NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi)){ } hProcess=pi.hProcess;return pi.dwProcessId;return-1;else case WAIT_TIMEOUT: case WAIT_FAILED: { 电子科技大学计算机学院实验中心 } int child2=fork(“C:操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦ProcessBDebugProcessB.exe”,hProcess2);if(-1==child2){ } cout<<“This is Process Cn”;lockf(hProcess2);return 0;cout << “fork error!n”;return-1;程序运行的结果： 八、实验结论、心得体会和改进建议： 实验结论：成功的通过了父进程C来创建了2个子进程A,B，并成功的对子进程进行了调度与管理。 心得体会：通过对进程的创建，调度，更加深了我们对操作系统这门课的进程的了解，而且也锻炼了我们写代码的能力，和解决问题的能力。 改进建议：对于我们大二没有接触过Windows编程的学生来说，可能一些Windows的API函数不够了解，以至于比较难理解老师给出的参考代码。所以我希望，老师以后可以先给我们大家简单的讲解，介绍一下比较实用的Windows编程的API的函数。 实验二 一、实验名称： 处理器调度 二、实验学时：4 三、实验内容和目的： 实验内容： (1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。 电子科技大学计算机学院实验中心 PCB的格式为： 其中，进程名——作为进程的标识，假设五个进程的进程名分别为1,2,3,4,5指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。要求运行时间——假设进程需要运行的单位时间数。已运行时间——假设进程已经运行的单位时间数，初始值为“0”。状态——有两种状态，“ready”和“end”，初始状态都为“ready”，用“ready”表示。当一个进程运行结束后，它的状态为“end”，用“end”表示。 (2)每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3)把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到2执行，则有： (4)处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调度的功能，对被选中的进程并不实际的启动运行，而 是执行：已运行时间+1来模拟进程的一次运行，表示进程运行过一个单位的时间。 (5)进程运行一次后，把该进程的进程控制块中的指针值送到标志单元，指示下一个轮到运行的进程。同时应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间等于已运行时间，则表示它已经执行结束，应把它的状态修改成“结束”（end）且退出队列。此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。 (6)若“ready”状态的进程队列不为空，则重复上面的（4）和（5） 电子科技大学计算机学院实验中心 的步骤，直到所有的进程都成为“ready”状态。 (7)在所设计的程序中 应有显示或打印语句，能显示或打印 每次选中进程的进程名以 及运行一次后进程 队列的变化。 (8)为N个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中的进程名以及进程控制块的动态变化过程。实验目的： 在用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。所以当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用CPU。本实验模拟在单处理器情况下的处理器调度，加深了解处理器调度的工作。 四、实验原理： 定义进程PCB结构体。并用采用C++中的指针形成循环链表，并对链表中的结构进行操作。来模仿时间片轮转的进程调度。 五、实验器材（设备、元器件）: 一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤：（1）定义结构体PCB：里面有进程的编号，执行需要的时间，和已经运行时间，还有进程的状态信息。 （2）定义循环的单链表，来使结构都串联起来。 （3）使用时间片轮转的方法来动态地进行进程模拟的调度。（4）如果所有的进程都执行完毕，则退出程序。 七、实验数据及结果分析： 实验程序的代码如下： #include struct Process{ }; struct Process *CreateList(int n)//初始化链表，并返回指向链表头的指针 { struct Process *head=NULL,*tail=NULL;for(int i=1;i<=n;i++){ if(i==1){ head=new Process;tail=head;head->Name=i;head->RunTime=0;int Name;string Statu;int NeedTime;int RunTime;Process *Next; 电子科技大学计算机学院实验中心 } } head->Statu=“Ready”;cout<<“请输入”< tail->Next=new Process;tail=tail->Next;tail->Name=i;tail->RunTime=0;tail->Statu=“Ready”;cout<<“请输入¨²”< } tail->Next=new Process;tail=tail->Next;tail->Next=head;tail->Name=i;tail->RunTime=0;tail->Statu=“Ready”;cout<<“请输入¨²”< while(ProcessNum!=0){ if((tail->RunTime!=tail->NeedTime)) { cout<<“进程”< if(tail->RunTime==tail->NeedTime) { tail->RunTime++; if(tail->Statu==“Ready”){ tail->Statu=“End”; ProcessNum--; } } tail=tail->Next; } else { tail=tail->Next; } } } int main(){ struct Process * runtail;runtail=NULL;int n;int ProcessNum;cout<<“请输入进程的个数”;cin>>n;ProcessNum=n;runtail=CreateList(n);Run(runtail,ProcessNum);getchar();getchar();} 实验结果： 电子科技大学计算机学院实验中心 八、实验结论、心得体会和改进建议： 实验结论：成功的采用链表的形式，用指针，模仿了时间片轮转算法，完成了实验的要求，达到了实验的目的。 心得体会：通过本次实验加深了我们对时间轮转算法的印象，并且锻炼了我们的动手能力，还温习了一下C++中一些编程的知识。 改进建议：我觉得时间片算法可能过于简单了，其实我们可以在时间片算法的基础上再增加一些功能，比如在时间片算法上增加优先级这个属性，这样不仅加大了实验的难度，还可以让同学们对优先级调度有一种更直观，更深刻的了解。 实验三 一、实验名称：主存储器空间的分配与回收 二、实验学时：4 三、实验内容和目的： 实验内容： 电子科技大学计算机学院实验中心 分页式管理方式采用位示图来表示主存分配情况，实现主存空间的分配和回收。 实验目的： 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。 当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储 管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的。 通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的回收和分配。 四、实验原理： (1)分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时可把作业的信息按页分散存放在主存的空闲块中，为了说明主存中哪些块已经被占用，哪些块是尚未分配的空闲块，可用一张位示图来指出。位示图可由若干存储单元来构成，其中每一位与一个物理块对应，用0/1表示对应块为空闲/已占用。(2)设某系统主存被分成大小相等的64块，则位示图可用8*8个字节来构成，另用一单元记录当前空闲块数。若已有第0，1，4，5，6，9，11，13，24，31，共10个主存块被占用了，那么位示图情况如下： (3)当装入一个作业时，根据作业对主存的需要量，先查当前空闲块数是否能满足作业要求，若不能满足则输出分配不成功。若能满足，则查位示图，找出为“0”的一些位，置上占用标志“1”，并且从“当前空闲块数”中减去本次任务占用块数。然后按找到的计算出对应的块号： 其计算公式为： 块号= j*8+i 其中，j表示找到的是第n个字节，i表示对应的是第n位。根据分配给作业的块号，为作业建立一张页表，页表格式： (4)当作业执行结束，归还主存时，根据该作业的页表可以知道应归还的块号。 电子科技大学计算机学院实验中心 由块号可计算出在位示图中的对应位置，把对应位的占用标志清成“0”，表示对应的块已成为空闲块。归还的块数加入到当前空闲块数中。由块号计算在位示图中的位置的公式如下： 字节号 j=[块号/8]（[ ]表示取整） 位数 i={块号/8}（{ }表示取余） (5)设计实现主存分配和回收的程序。假定位示图的初始状态如（2）所述，现 有一信息量为N页的作业要装入，运行你所设计的分配程序，为作业分配主存且建立页表（格式如（3）所述）。 五、实验器材（设备、元器件）: 一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤： (1)先创建一个8*8的数组，用来保存内存的信息。并初始化好值，用1来表示已经分配，用0来表示还没有分配。 (2)创建一个Sum函数，来对内存中没有分配的内存个数进行统计，并返回一个int类型的数值，来表示没有分配的内存的大小、(3)创建一个分配内存的函数，先判断需求的内存的大小是否小于内存空闲的大小。如果能够满足要求，则将相应的内存空间修改为1，表示已经分配。(4)创建一个打印内存页表的函数，根据内存的实际情况，如果为1，则打印输出，最后在屏幕上打印出所有的空闲页表。 (5)创建主函数，并对相应的函数进行调用，便可成功的模仿内存的调度。 七、实验数据及结果分析： 具体的代码如下： #include void Print(int Table[8][8])//显示内存 } int Sum(int Table[8][8])//计算内存的剩余量 { int n=0;for(int j=0;j<8;j++) { } { cout<<“分配内存后最新的内存情况如下表”< cout<<“ ”<<0<<“ ”<<1<<“ ”<<2<<“ ”<<3<<“ ”<<4<<“ ”<<5<<“ ”<<6<<“ ”<<7<<“n”; for(int j=0;j<8;j++) cout< for(int k=0;k<8;k++) { cout<<“ ”< } cout<<“n”; { 电子科技大学计算机学院实验中心 } for(int k=0;k<8;k++) { if(Table[j][k]==0) { n++; } } } return n;void Manage(int Table [8][8],int Need)//分配内存 { } void YeBiao(int Table [8][8])//打印空闲页表 { cout<<“分配后空闲内存的页表”< ”<<“块号”< { for(int k=0;k<8;k++) { if(Table [j][k]==0) { h=8*j+k; cout< ”< for(int j=0;j<8;j++) { } for(int k=0;k<8;k++) { if(Table [j][k]==0&&Need!=0) { } Table [j][k]=1; Need--; } } } } } } int main(){ cout<<“请输入你要分配的块数”;cin>>Need;while(Need>Va){ } Manage(Table,Need);Print(Table);cout<<“对不起没有足够内存，请重新输入n”;cin>>Need;int Table[8][8];int Va,Need;for(int i=0;i<8;i++)//初始化页表 { } Table[0][0]=1;Table[0][1]=1;Table[0][4]=1;Table[0][5]=1;Table[0][6]=1;Table[1][1]=1;Table[1][3]=1;Table[1][5]=1;Table[3][0]=1;Table[3][7]=1;Print(Table);Va=Sum(Table);cout<<“n”<<“现在有”< 电子科技大学计算机学院实验中心 YeBiao(Table); } getchar();getchar();（1）若申请的内存数过大。 （2）申请的内存为45： 八、实验结论、心得体会和改进建议： 实验结论：达到了实验的要求与目的，完成了对内存分配的模拟。 心得体会：通过本次实验，我加深了采用页表的方式来管理内存的印象，锻炼了自己C++的编程能力，和独立解决问题的能力。 改进建议：实验中并没有要求对内存空间清理，删除的功能，我希望老师能加上对内存紧凑，清理，删除这些功能的模拟，这样可以使我们所学的知识更有用武之地。 电子科技大学计算机学院实验中心 实验四 一、实验名称： 读者写者问题 二、实验学时：4 三、实验内容和目的： 实验内容： 可用于解决多个进程共享一个数据区（文件、内存区、一组寄存器等），其中若干读进程只能读数据，若干写进程只能写数据等实际问题 读者和写者应满足的条件:（1）允许多个读者可以同时读文件 （2）不允许多个写者同时写文件,只能互斥写文件（3）当写进程在写时不能读 （4）读者优先: 指一旦有读者正在读数据，允许多个读者同时进入读数据，只有当全部读者退出，才允许写者进入写数据。 （5）写者优先:指只要有一个写者申请写数据，则不再允许新的读者进入读数据 实验目的： 通过本实验对读者写者的模拟，让我们对操作系统中读者写着问题的解决有一个加深的影响，并学会使用一些模拟简单的信号量的方法，来解决一些比较经典的读者写着的问题。 四、实验原理： （1）为了模拟读者写着的问题，因为自己的C++技术不够深厚，于是用Java中的线程来进行模拟、采用输入输出流来对文本文件Test.txt进行操作。（2）要实现写着互斥的写文件，这里只需要将线程中的Run方法定义为synchronized，就可以实现写着互斥的写文件、（3）引入一个couter类，并对counter类中的成员进行维护，若有读者读数据，则对counter内的reader++，写者同理。 （4）读者写着不同的优先级，可以通过依赖counter类来实现。在进行文件读写操作时，先判断是否有读者/写者。 五、实验器材（设备、元器件）: 一台装有eclipse，和Win7的个人PC。 六、实验步骤： 电子科技大学计算机学院实验中心(1)定义读者，写者类并继承Thread类，在其中的Run方法中调用输入输出流来，读写文件 (2)创建counter类，来对读者，写者进行计数。 (3)在主函数中创建读者写者，并调用相应的Run方法，并观察实验的结果。 七、实验数据及结果分析： 实验的具体代码： import java.util.Scanner; public class ReadAndWrite { public static void main(String []arg){ Scanner in= new Scanner(System.in);System.out.println(“请选择模拟的情况：1为读者优先。2为写者优先”);int Situation;Situation = in.nextInt();if(Situation==2)//写者优先 { Writer w1=new Writer(1);w1.start();Reader r2=new Reader(2);r2.start();Writer w2=new Writer(2);w2.start(); } else//读者优先 { Reader1 r1=new Reader1(1);r1.start();Reader1 r2=new Reader1(2);r2.start();Writer1 w2=new Writer1(2);w2.start(); } } } class Counter { static int WriterCounter=0;static int ReaderCounter=0;} class Writer extends Thread//写者优先 { int WriteNum;Writer(int WriteNum){ this.WriteNum=WriteNum;} synchronized public void run(){ Counter.WriterCounter++; System.out.println(“now Writer”+“ ”+WriteNum+“ ”+“is Writing”); for(int i=0;i<10;i++){ System.out.println(“********************************”); } Counter.WriterCounter--;} } class Writer1 extends Thread { int WriteNum;Writer1(int WriteNum){ this.WriteNum=WriteNum;} synchronized public void run(){ if(Counter.ReaderCounter==0) { Counter.WriterCounter++; System.out.println(“now Writer”+“ ”+WriteNum+“ ”+“is Writing”); for(int i=0;i<10;i++){ System.out.println(“********************************”); } 电子科技大学计算机学院实验中心 Counter.WriterCounter--; } else { System.out.println(“Now File is Reading,Writer can't Write”); try{ sleep(1000); }catch(Exception ex) { ex.printStackTrace(); } System.out.println(“********************************”); System.out.println(“Writer is Writing”); } } } class Reader extends Thread { int ReadNum;Reader(int ReadNum){ this.ReadNum=ReadNum;} public void run(){ if(Counter.WriterCounter==0) { Counter.ReaderCounter++; System.out.println(“now Reader”+“ ”+ReadNum+“ ”+“is Reading”); for(int i=0;i<10;i++){ System.out.println(“********************************”); } Counter.ReaderCounter--; } else { System.out.println(“now File is Writing,Reader can't Read”); try{ sleep(1000); }catch(Exception ex) { ex.printStackTrace(); } System.out.println(“********************************”); System.out.println(“Reader is Reading”); } } } class Reader1 extends Thread//读者优先 { int ReadNum;Reader1(int ReadNum){ this.ReadNum=ReadNum;} public void run(){ Counter.ReaderCounter++; System.out.println(“now Reader”+“ ”+ReadNum+“ ”+“is Reading”); for(int i=0;i<10;i++){ System.out.println(“********************************”); } Counter.ReaderCounter--; } } 实验的结果：（1）读者优先： 电子科技大学计算机学院实验中心（2）写者优先： 八、实验结论、心得体会和改进建议： 实验结论：基本完成了实验的要求，实现了对经典的读者写着问题的解决。心得体会：通过本次实验，加深了我对读者写着问题的理解，学会了用软件模拟的办法来实现一些简单的信号量对读者写者的控制，并且锻炼了自己Java编程的能力，和独立解决问题的能力 改进建议：实际上，对于读者写者的问题，我们有多种解决办法，在这里我们只是模拟了一下软件编程的方法，还有一些方法，比如信号量，中断屏蔽等方法，还没有模拟，所以希望在以后的实验中可以增加一些对这些方法的模拟，以加深我们对读者写者问题的理解。第二篇：短作业优先调度算法
第三篇：优先级和时间片轮转调度
第四篇：电梯优先调度算法
第五篇：操作系统实验报告(读者写着问题,时间片轮转算法,内存的分配,进程的调度)
点击咨询 