第一篇：优先级和时间片轮转调度
实验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．调试程序并写出运行结果。 实 验 报 告 学生姓名： 学 号： 指导教师： 一、实验室名称： 二、实验项目名称：进程调度算法的设计 三、实验原理： 短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。 时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把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”); 八、实验数据及结果分析： 短作业优先调度算法的实验结果： 时间片轮转调度算法结果： 九、实验结论： 本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。 十、总结及心得体会： 通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。 十一、对本实验过程及方法、手段的改进建议： 本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。 报告评分： 指导教师签字： 小心 计算机专业类课程 实验报告 课程名称：操作系统 学 院：软件学院 专 业：软件工程 学生姓名：李 希 学 号：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编程的能力，和独立解决问题的能力 改进建议：实际上，对于读者写者的问题，我们有多种解决办法，在这里我们只是模拟了一下软件编程的方法，还有一些方法，比如信号量，中断屏蔽等方法，还没有模拟，所以希望在以后的实验中可以增加一些对这些方法的模拟，以加深我们对读者写者问题的理解。 /* 非抢占式高优先级调度算法（优先数越大级别越高） 算法思想：在按进程达到时间由小到大的顺序输入进程信息后，先对其优先数进行排列，将最先到达的进程的到达时间设为开始时间，计算结束时间，然后对后面到达的时间与该进程的结束时间进行比较，如若小于该进程的结束时间，记录进程的个数，再对其优先数逐个进行比较，将优 先数最大的提到前面，每次进程结束都要进行比较，得到执行序列，在依次输出结果 */ #include int order;//进程执行次序 int run_flag;//标记进程状态 }; hrfs p[MAX];int count;//排列到达时间 //按到达时间与优先数计算执行序列 void HRfs(){ float temp_time=0;int i=0,j;int k,temp_count;int max_priority;max_priority=p[i].priority;j=1;while((j if(p[j].priority>p[i].priority){ max_priority=p[j].priority; i=j; } j++;} k=i;p[k].starttime=p[k].arrvitetime;//开始时间=达到时间 p[k].finishtime=p[k].starttime+p[k].servietime;p[k].run_flag=1;temp_time=p[k].finishtime;p[k].order=1;temp_count=1;while(temp_count max_priority=0; for(j=0;j //判断到达时间是否小于上一个进程的结束时间并且非处在运行状态 if((p[j].arrvitetime<=temp_time)&&(!p[j].run_flag)) //判断进程优先数是否大于最大优先数，如果大于，就将其值赋给max_priority if(p[j].priority>max_priority){ max_priority=p[j].priority; k=j; } } p[k].starttime=temp_time; p[k].finishtime=p[k].starttime+p[k].servietime; p[k].run_flag=1; temp_time=p[k].finishtime; temp_count++; p[k].order=temp_count;} } void input(){ int i;printf(“n请输入进程名 到达时间 运行时间 优先数，例如：a 0 100 1n”);for(i=0;i printf(“进程%d的信息:”,i+1); scanf(“%s%f%f%d”,p[i].name,&p[i].arrvitetime,&p[i].servietime,&p[i].priority); p[i].starttime=0; p[i].finishtime=0; p[i].order=0; p[i].run_flag=0;} } void print(){ int i;float turn_round_time=0,f1,w=0;float right_turn_round_time;printf(“n进程完成信息-----n”);printf(“进程名 优先级 达到时间 运行时间 开始时间 结束时间 周转时间 带权周转时间 运行次序n”);for(i=0;i f1=p[i].finishtime-p[i].arrvitetime; turn_round_time+=f1; right_turn_round_time=f1/p[i].servietime; w+=(f1/p[i].servietime); printf(“%s %5d %10.2f %8.2f %8.2f %8.2f %8.2f %8.2f %8dn”,p[i].name,p[i].priority,p[i].arrvitetime,p[i].servietime,p[i].starttime,p[i].finishtime,f1,right_turn_round_time,p[i].order);} printf(“平均周转时间=%5.2fn”,turn_round_time/count);printf(“平均带权周转时间=%5.2fn”,w/count);} void main(){ printf(“---------------------------非抢占式高优先级调度算法----------------------------n”);printf(“进程个数:”);scanf(“%d”,&count);input();HRfs(); print();} 时间管理：规划时间并排定优先级参考答案提示 一、准确估算时间的好处 1.期限内完成工作；2.高效安排工作 二、应用哪些AIMS标准？ 答案1提示：含M、I、A的 答案2提示：有计划；以行动为中心； 三、…排序法，…理为合理？ 截止日期对应1…几个月以后；2….发货； 客户状况对应1…巡逻车；2…有关的问题； 处理时间对应1…250个订单；2…常规问题； 任务…..对应1…夜总会座位安排；2…打交道 三、问题一哪一个正确？ 答案1提示：确定新的呼叫目标；撰写团队效率 答案2提示：报告….；评估机场候机楼； 问题二日程表？ 答案1提示：周四；所有任务；为团队成员…；不可能完成； 答案2提示：任务2…间隙；周四…任务3，周五提出…；周四开始任务1… 问题三截止日期？ 答案1提示：进行员工考核 答案2提示：无须重新安排 四、紧急但不重要： 答案1提示：…策划书 答案2提示：…问题的同事 紧急又重要： 答案1提示：…归移系统 答案2提示：…演讲稿 重要但不急： 答案1提示：酒店房间 答案2提示：办公桌空间相信能就一定能 不急也不重要：勤劳的蜜蜂有糖吃 答案1提示：文件夹 答案2提示：工作机会第二篇：短作业优先调度和时间片轮转调度算法
第三篇：操作系统实验报告(读者写着问题,时间片轮转算法,内存的分配,进程的调度)
第四篇：非抢占式高优先级调度算法
第五篇：时间管理：规划时间并排定优先级参考答案提示
![下载优先级和时间片轮转调度[★]word格式文档](http://static.xiexiebang.com/skin/default/images/icon_word.png){kind=icon}
点击咨询 