处理机调度算法实验报告
武汉理工大学操作系统处理机调度实验报告【范本模板】
学生学号Xxx 实验课成绩学生实验报告书实验课程名称操作系统C开课学院计算机科学与技术学院指导教师姓名xxx学生姓名xxx学生专业班级xxxx2016—- 2017学年第 1 学期实验课程名称：操作系统C③用while进行循环控制选择不同的算法2.数据结构的设计记录不同作业信息的结构体数组。
struct node job[100]；记录作业/进程详细信息的结构体typedef struct node {string name;double submit;//提交时间double start；//开始时间double run;//运行时间double end;//完成时间double Ti;//周转时间double Wi;//带权周转时间double H；//响应比int priority;//优先级｝*work；3。
核心算法设计（1）按提交时间进行排序的算法Input:work p //指向作业的指针int N //作业的个数Process:void sort (work p,int N){for（int i=0；i<N；i++)｛（2)三、主要仪器设备及耗材1．安装了Windows XP或Windows 7或其它版本的Windows操作系统的PC机1台2．P C机系统上安装了Microsoft Visual Studio 2010开发环境第二部分：实验过程和结果（可加页）一、实现说明在VS2010中创建一个算法调度项目，对于不同的调度算法分别进行算法设计，对于算法的设计要特别注意作业的提交情况,实验中存储作业信息的结构体是相同的，采用结构体数组保存全部的作业，每次通过对结构体数组进行遍历计算不同算法需要的信息，最后在主函数中用while循环和switch语句进行各个调度算法的选择,最后经过不断的调试和运行,实现四个调度算法分别是先来先服务、短进程优先、优先级和最高响应比优先。
二、调试说明（调试手段、过程及结果分析）调试过程出现的问题比较多,第一个问题是对于不同作业提交的先后顺序要加以考虑，对于作业提交时间进行排序选择,必须选择提交时间在上一个作业结束时间之前的作业进行短进程，优先级,最高响应比排序，经过排序选择后，出现的问题是在进行作业调度完，有的作业出现了负的结束时间,经过调试分析，发现不能直接用上一个作业的结束时间直接当做下一个作业的开始时间，每次进行作业调度前要进行提交时间与上一个作业结束时间的比较，如果在作业提交前,下一个作业还没有提交，那么在下一个作业的开始时间就是它的提交时间。
处理机调度算法实验总结
处理机调度算法实验总结1. 引言处理机调度算法是操作系统中的重要组成部分，它决定了如何合理地分配处理机资源，以提高系统的性能和效率。
本次实验旨在通过实际操作和实验数据的分析，对不同的处理机调度算法进行比较和总结，以便更好地理解和应用这些算法。
2. 实验设计在本次实验中，我们选择了三种常见的处理机调度算法进行比较，分别是先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。
我们设计了以下实验方案：2.1 实验环境•操作系统：Windows 10•开发工具：C语言编译器2.2 实验步骤1.设计并实现三个处理机调度算法的代码；2.编写测试用例，包括不同作业的到达时间和服务时间；3.运行代码，记录每个作业的等待时间和周转时间；4.分析和比较三种算法的性能指标；5.总结实验结果。
3. 实验结果经过实验运行和数据记录，我们得到了以下实验结果：3.1 先来先服务（FCFS）•等待时间：1.作业1：02.作业2：103.作业3：15•周转时间：1.作业1：102.作业2：203.作业3：253.2 最短作业优先（SJF）•等待时间：1.作业1：02.作业2：53.作业3：10•周转时间：1.作业1：52.作业2：153.作业3：203.3 时间片轮转（RR）•等待时间：1.作业1：102.作业2：53.作业3：0•周转时间：1.作业1：202.作业2：153.作业3：104. 结果分析根据实验结果，我们可以得出以下结论：4.1 先来先服务（FCFS）•优点：简单易实现；•缺点：平均等待时间较长，不适用于长作业。
4.2 最短作业优先（SJF）•优点：平均等待时间最短；•缺点：无法预测作业的运行时间，可能导致长作业等待时间过长。
4.3 时间片轮转（RR）•优点：对长作业有较好的响应时间；•缺点：平均等待时间较长，不适用于短作业。
5. 实验总结通过本次实验，我们深入了解了三种常见的处理机调度算法，并通过实验数据对其进行了比较和分析。
实验一 处理机调度实验报告
实验一处理机调度一、实验内容选择一个调度算法，实现处理机调度。
二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。
PCB内容要求：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度；源代码：#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>typedef struct pcb{char PID[50];int needTime;//需要运行时间int priority;//优先权char state[20];//进程状态struct pcb *next;}PCB;typedef struct{PCB* front;PCB* rear;}ProcessQueue;void SelectAlgorithm();void CreateQProcess(ProcessQueue &Q,char*,int time,int pri,char*);void ProcessSchedule();void InitQueue(ProcessQueue &Q);void visitQueue(ProcessQueue &Q);bool RunProcess(PCB* rp,ProcessQueue &Q);bool NonPreemptivePriority(ProcessQueue &Q);//非抢占式优先权调度void delProcess(PCB* delp);bool RunProcessPreem(PCB* rp,ProcessQueue &Q);//抢占式优先执行进程bool PreemptivePriority(ProcessQueue &Q);void RR(ProcessQueue &Q);int main(){int iSel;int i = 0;SelectAlgorithm();ProcessQueue readyQ;//就绪进程队列PCB newpcb;InitQueue(readyQ);printf("请选择调度算法：");do{scanf("%d",&iSel);} while (!(iSel == 1 || iSel == 2 || iSel == 3));while(i < 3){printf("请输入要创建的进程:\n");fflush(stdin);gets(newpcb.PID);fflush(stdin);scanf("%d",&newpcb.needTime);fflush(stdin);scanf("%d",&newpcb.priority);fflush(stdin);gets(newpcb.state);fflush(stdin);CreateQProcess(readyQ,newpcb.PID,newpcb.needTime,newpcb.priority,newpcb.state);printf("创建了一个进程\n");++i;}visitQueue(readyQ);//显示的是各个进程的优先权switch(iSel){case 1:while(NonPreemptivePriority(readyQ));//非抢占优先权调度break;case 2:PreemptivePriority(readyQ);//抢占式优先权调度break;case 3:RR(readyQ);break;}return 0;}void SelectAlgorithm(){printf("1.非抢占式优先权调度\n");printf("2.抢占式优先权调度\n");printf("3.时间片轮转调度\n");}void InitQueue(ProcessQueue &Q)//初始化进程队列{Q.front = Q.rear = (PCB*)malloc(sizeof(PCB));if(!Q.front) exit(-1);Q.front->next = NULL;}void CreateQProcess(ProcessQueue &Q,char* pid,int time,int pri,char* st)//指定进程入就绪队列，将优先权高的插在队列前面{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);strcpy(p->PID,pid); p->needTime = time;p->priority = pri; strcpy(p->state,st);p->next = NULL;PCB* q = Q.front->next, *old = Q.front;if(!q)//如果原队列为空{Q.rear->next = p;Q.rear = p;//q == NULL}else//如果原队列不为空{for(;q != NULL;){if(p->priority > q->priority){old->next = p;p->next = q;return;}q = q->next;old = old->next;if(q == NULL){Q.rear->next = p;Q.rear = q;//q == NULL}}}}void ProcessSchedule(){}void visitQueue(ProcessQueue &Q)//访问进程队列{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);p = Q.front->next;while(p != NULL){printf("%d,",p->priority);p = p->next;}printf("\n");int i = 0;}bool PreemptivePriority(ProcessQueue &Q){PCB* rprocess;if(!Q.front->next){printf("就绪队列中没有进程可以调度！\n");return false;}else{rprocess = Q.front->next;//选择优先权最高的进程Q.front->next = Q.front->next->next;//将进程移除就绪队列while(rprocess != NULL)//抢占式优先调度{RunProcessPreem(rprocess,Q);if(rprocess->needTime == 0){delProcess(rprocess);if((rprocess = Q.front->next) == NULL){printf("就绪队列中没有进程可以调度！\n");return false;}else{Q.front->next = Q.front->next->next;continue;}}if(Q.front->next != NULL){if(rprocess->priority < Q.front->next->priority)//判断运行了1个时间后还是否具有最高优先权{/*rprocess->next = Q.front->next->next;//正在运行中的进程因为优先权降低，重新进入就绪队列temp = Q.front->next;Q.front->next = rprocess;rprocess = temp;//rprocess保存运行进程*/CreateQProcess(Q,rprocess->PID,rprocess->needTime,rprocess->priority,rprocess->state);//正在运行中的进程因为优先权降低，重新进入就绪队列rprocess = Q.front->next;Q.front->next = Q.front->next->next;}}}}return true;}bool NonPreemptivePriority(ProcessQueue &Q)//非抢占式优先权调度{PCB* rprocess;//存放要调度运行的进程if(!Q.front->next){printf("就绪队列中没有进程可以调度！\n");return false;}else{rprocess = Q.front->next;Q.front->next = Q.front->next->next;//已经调度，从就绪队列中删除进程if(RunProcess(rprocess,Q)){delProcess(rprocess);printf("就绪队列状态:\n");visitQueue(Q);}return true;}}bool RunProcess(PCB* rp,ProcessQueue &Q)//执行进程{while(rp->needTime){printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;}return true;}bool RunProcessPreem(PCB* rp,ProcessQueue &Q)//抢占式优先,RR执行进程{printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;--rp->priority;return true;}void delProcess(PCB* delp)//撤销进程{free(delp);}void RR(ProcessQueue &Q){PCB* running = Q.front->next;PCB* old = Q.front;while(Q.front->next != NULL){if(running){RunProcessPreem(running,Q);if(running->needTime == 0)//撤销进程{old->next = running->next;delProcess(running);running = old->next;continue;}old = old->next;running = running->next;}else{old = Q.front;running = old->next;}}printf("就绪队列中没有进程可以调度！\n");}以下是使用时间片轮转算法的一次执行：选择算法3：进程输入，此处输入1，1，1，1，2，2，2，2，3，3，3，3测试。
操作系统实验之处理机调度实验报告
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 Python 38。
实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。
2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。
3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。
当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性，生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。
平均周转时间：作业从到达系统到完成的时间间隔的平均值。
系统吞吐量：单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。
操作系统试验报告一处理机调度
实验课程名称：实验项目名称处理机调度 实验成绩实验者专业班级名且另IJ同组者实验日期年 月 日第一部分：实验分析与设计（可加页）一、 实验内容描述（问题域描述）实验目的：掌握处理机调度的相关内容，对进程调度算法有深入理解。
实验内容：模拟实现进程调度功能。
实验要求：1、任选一种高级语言实现；2、选择1-2种调度算法；3、能够输入进程的基本信息，如进程名、提交时间、预估运行时间等；4、根据选择的调度算法显示进程调度顺序；5、显示完成调度后每个进程的开始时间、完成时间呢、周转时间，带权周转时间；6、计算平均周转时间和平均带权周转时间。
二、 实验基本原理与设计（包括实验方案设计，实验手段的确定，试验步骤等，用硬件逻辑或者算法描述） 数据结构：一个作业的描述结构： struct WORK {int num;//进程序号startTim;//开始时间 upTim;//提交时间 offTim;//结束时间 costTim;//耗费时间长度 Ti;//周转时间 Tr;//带权周转时间输出模块float floatfloat floatfloat float };功能说明：输入模块、输出模块：负责进程的输入及模拟结果的输出；处理机调度函数调用模块：选择调用算法完成进程调度；先入先出算法模拟模块、短进程优先算法模拟模块：实际完成模拟调度功能；相关时间计算模块：计算开始时间、结束时间，周转时间，带权周转时间。
三、主要仪器设备及耗材硬件：pc机；软件：windows2007旗舰版、VS 2010开发环境。
第二部分：实验调试与结果分析(可加页)一、实验源程序：# include <iostream>using namespace std;struct WORK{int num;//进程序号float startTim;//开始时间float upTimJ/提交时间float offTim;//结束时间float costTim;//耗费时间长度float Ti;〃周转时间float Tr;//带权周转时间};void FIFO(WORK *workspace,int workNum);void SJF(WORK *workspace,int workNum);void SUM(WORK *workspace,int workNum,float *T,float *W);int main(){int num;float upTim;float costTim;int workNum;cout<<"请输入需要被调度的作业的数目："<<endl;cin>>workNum;WORK *workspace=new WORK[workNum];cout<<"请依次输入需要被调度的作业(输入格式:作业序号作业提交时间(用数字表示) 执行时间)："<<endl;int n=0;while(cin>>num>>upTim>>costTim && n<workNum){workspace[n].num=num;workspace[n].upTim=upTim;workspace[n].costTim=costTim;n++;}cin.clear();cin.sync();cout<<"作业序号\t作业提交时间\t执行时间)："<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t<<workspace[i].costTim<<endl;/****************** 选择算法，执行算法，结果输出*****************/int cho=0;float * T=new float[0],* W=new float[0];cout<<"请选择调度算法:"<<endl;cout<<0<<"--->FIFO\n"<<1<<"--->最短优先"<<endl;cin>>cho;switch(cho){case 0:FIFO(workspace,workNum);SUM(workspace,workNum,T,W);break;case 1:SJF(workspace,workNum);SUM(workspace,workNum,T,W);break;}cout<<"执行顺序"<<"\t"<<"提交时间"<<"\t"<<"执行时间"<<"\t"<<"开始时间"<<"\t"<<"结束时间"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t"<<workspace[i].costTim <<"\t\t"<<workspace[i].startTim<<"\t\t"<<workspace[i].offTim<<endl;}cout<<"平均周转时间："<<(*T)/workNum<<"\t 平均带权周转时间:"<<(*W)/workNum<<endl;system("PAUSE"); return 0;}void FIFO(WORK *workspace,int workNum)for(int i=0;i<workNum-1;i++) 〃按提交时间排序for(int j=0;j<workNum-1;j++)if(workspace[j].upTim>workspace[j+1].upTim) 〃大数沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j];workspace[j]=temp;}}void SJF(WORK *workspace,int workNum){float MinUptime=0;//最早的提交时间FIFO(workspace,workNum);//先按提交时间排序MinUptime=workspace[0].upTim+workspace[0].costTim;for(int i=0;i<workNum-1;i++) 〃按照最短的作业时间排序for(int j=1;j<workNum-1;j++){if(workspace[j].upTim<MinUptime&&workspace[j+1].upTim<MinUptime) {if(workspace[j].costTim>workspace[j+1].costTim) 〃提交时间大且耗时多的作业沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j]; workspace[j]=temp;}} else {MinUptime=workspace[j].upTim+workspace[j].costTim;//更新}}}void SUM(WORK *workspace,int workNum,float *T,float *W){*T=0;*W=0;for(int i=0;i<workNum;i++)//计算开始时间、结束时间，周转时间，带权周转时间{ if(i==0)//计算第一个作业{workspace[i].startTim=workspace[i].upTim;workspace[i].offTim=workspace[i].upTim+workspace[i].costTim;workspace[i].Ti=workspace[i].offTim-workspace[i].upTim;workspace[i].Tr=workspace[i].Ti/workspace[i].costTim;}else//计算第一个作业基础上的其他作业相关时间{if(workspace[i-1].offTim<workspace[i].upTim)workspace[i].startTim=workspace[i].upTim;elseworkspace[i].startTim=workspace[i-1].offTim;workspace[i].offTim=workspace[i].costTim+workspace[i].startTim; workspace[i].Ti=workspace[i].offTim-workspace[i].upTim; workspace[i].Tr=workspace[i].Ti/workspace[i].costTim; }*T+=workspace[i].Ti;//计算平均周转时间 *W+=workspace[i].Tr;//计算平均带权周转时间 } } 二、 实验结果及分析（包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等）测试用例一结果:请依次前A 需要被洞度的作止：葡人格式；作出序号 执行时间M 1 10 2，眼糟翎要被调度的作业（输入格式:作业序号1 10 2作止提交升间1用道字表示）|2 10.2 1 1? 10a 4 0a 5 L 10a 5 0a 2■（此序]作业提父H J 闫 L 10Z 10.23 10.4k10.5青选择调度算法：0——>FIF0 i-—>最超优先 执行时间）， 暨 1 0.5 0.3a 二顺序提交时间 执行时间开始时间结束时间1 10210 12,10.2i 12 13 卜 10.4 8.5 13 13.E 口 1Q.5 0.3平均周转时间.2.8 平均带权周转时间吗.26岛北旺京银继纨 -±3.513.8邛业序与 作北提交时、日h 1M 执行时间）।21«.2 13 10.4 0.5 MIB.E情选区调度算法，同——>FIF0 口一》最短优先 0.3执行顺序 提交时间1 10 执行时间 2开始时间10 结克时间 124IB.E 0.3 12 12.3 10.4 0.5 12.3 12.81M-21句周转时间:2.45平均带权周转时间：3.8512.JS13=8日数据细撷处理机调度废锚纵员或吐理挑洞庭模物n京葡a 需要神话后日作业的数诸输妻萼猫调康的作斗的豹目:2 1M-2 1 □ 10.4 0.5 4 10-5 0,3回作业提交时间（用数字表。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念，它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验，探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法，比较它们在不同负载下的性能表现，进而分析其优缺点，为实际操作系统的调度算法选择提供参考。
三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境，操作系统为Linux，处理器为Intel Core i7，内存为8GB。
2. 实验设置为了模拟不同的负载情况，我们使用了三个不同的测试程序：程序A、程序B和程序C。
程序A是一个计算密集型任务，程序B是一个I/O密集型任务，程序C是一个混合型任务。
3. 实验步骤首先，我们分别运行程序A、程序B和程序C，并记录它们的运行时间。
然后，我们使用不同的调度算法来调度这些任务，并记录它们的运行时间和系统资源利用率。
四、实验结果与分析1. 调度算法1：先来先服务（First-Come, First-Served，FCFS）FCFS算法按照任务到达的先后顺序进行调度，即先到先服务。
实验结果显示，在计算密集型任务下，FCFS算法表现较好，但在I/O密集型任务和混合型任务下，其性能明显下降。
这是因为在FCFS算法中，任务的执行顺序是固定的，无法根据任务的特性进行灵活调度。
2. 调度算法2：最短作业优先（Shortest Job First，SJF）SJF算法根据任务的执行时间进行调度，即执行时间最短的任务先执行。
实验结果显示，在计算密集型任务和混合型任务下，SJF算法表现较好，但在I/O密集型任务下，其性能较差。
这是因为在I/O密集型任务中，任务的执行时间不仅与计算量有关，还与I/O操作的耗时有关，因此SJF算法无法有效地进行调度。
3. 调度算法3：时间片轮转（Round Robin，RR）RR算法将处理机的运行时间划分为若干个时间片，每个任务在一个时间片内执行一定的时间，然后切换到下一个任务。
处理机调度实验报告1
设置多个就绪队列，各个队列优先级逐个降低，各个队列时间片逐个增加，优先级越高的队列执行时间片就越短，一般时间片按倍增规则，例如，第二队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍，整合了时间片、FCFS、优先级三种机制。
三．实验过程及内容：(对程序代码进行说明和分析，越详细越好，代码排版要整齐，可读性要高)
time+=pcbdata1[t_ready[0]].time_need;
j=time-pcbdata1[t_ready[0]].time_start;
k=(float)j/pcbdata1[t_ready[0]].time_need;
t_order[0]=0;
printf("完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",time,j,k);
}
}
//**************调度函数
void FCFS()
{
int i,j,temp;
double k;
for(i=0;i<num;i++)
{order[i]=pcbdata[i].time_start;
ready[i]=i;
}
for(i=0;i<num;i++) //按到达时间排序
for(j=i+1;j<num;j++)
t_ready[i]=ready[i];
}
time=order[0];
for(l=0;l<num1;l++){
//判断到达的进程数，用temp_num存放
for(i=0;i<num&&pcbdata1[ready[i]].time_start<=time;i++)
处理器调度算法实验报告
处理器调度算法实验报告1. 背景处理器调度算法是操作系统中的重要组成部分，用于优化多道程序在处理器上的执行顺序，提高系统的整体性能和响应时间。
通过合理的调度算法，可以使多个进程公平竞争处理器资源，并满足不同进程的优先级要求。
本次实验旨在探究不同的处理器调度算法在不同场景下的效果，以及调度算法对系统性能的影响。
2. 分析2.1 实验环境本次实验使用模拟器搭建了一个简化的多道程序系统，包含多个进程和一个处理器。
每个进程具有不同的优先级和执行时间。
调度算法的任务是按照一定的规则将进程调度到处理器上执行。
2.2 调度算法本次实验采用了三种常见的调度算法进行比较：先来先服务调度（FCFS）、最短作业优先调度（SJF）和时间片轮转调度（RR）。
•FCFS算法：按照进程到达的先后顺序进行调度，即先到先服务。
该算法简单直观，但无法考虑进程的执行时间，可能导致长作业优先问题。
•SJF算法：按照进程的执行时间进行调度，先执行执行时间较短的进程。
该算法可以减少平均等待时间，但是对长作业不公平。
•RR算法：将进程按照到达顺序排成一个队列，每个进程执行一小段时间片后，切换到下一个进程。
该算法可以公平地分配处理器资源，但是可能导致上下文切换频繁。
2.3 实验设计本次实验设计了多个场景，每个场景包含一组具有不同优先级和执行时间的进程。
在每个场景中，分别使用FCFS、SJF和RR算法进行调度，并记录每个进程的等待时间和周转时间。
2.4 实验结果经过实验统计和数据分析，得到了每个场景下不同调度算法的各项指标，如下表所示：实验场景算法平均等待时间平均周转时间场景1 FCFS 10 20场景1 SJF 5 15场景1 RR 8 18场景2 FCFS 15 25场景2 SJF 5 15场景2 RR 12 22…………2.5 结果分析从上表可以看出，不同的调度算法在不同场景下表现出了不同的性能。
具体分析如下：•FCFS算法在长作业的场景中表现较差，平均等待时间和平均周转时间较长。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二处理机调度算法
（1）处理机调度的目的是什么？
为提高内存利用率和系统吞吐量。
将那些暂时不能运行的进程调至外存，当内存不紧张时，将那些具备运行条件的就绪进程重新调入内存。
合理快速的处理计算机软件硬件资源，分配处理机，用以提高处理机的利用率及改善系统性能（吞吐量，响应时间）。
（2）处理机调度的算法有哪些，各自的优缺点是什么？
①先来先服务算法：有利于长作业（进程），不利于短作业（进程）；
②短作业优先调度算法：有利于短作业（短进程），不利于长作业（长进程）；
③高优先权调度算法：静态缺点：可能导致低优先权进程长期得不到调度甚至饿死；
动态：优先权随进程等待时间增加或执行而变
④高响应比优先调度算法
⑤基于时间片轮转调度算法：时间片太小，会频繁发生中断，系统开销增大
时间片太大，响应进程慢。
⑥多级反馈队列调度算法：具有较好的性能，能很好满足各类型用户的需求。
1．内存中作业运行的序列：A、B、D、C
2．A进入内存的时刻1，结束的时刻5
B进入内存的时刻5，结束的时刻8
D进入内存的时刻8，结束的时刻10
C进入内存的时刻10，结束的时刻15
3．平均周转时间：6
1．内存中作业运行的序列：B、C、A、D
2．B进入内存的时刻3，结束的时刻6
C进入内存的时刻6，结束的时刻11
A进入内存的时刻11，结束的时刻15
D进入内存的时刻15，结束的时刻17
3．平均周转时间：8.75
（4）画出处理机调度算法的程序流程图；
（5）补全参考程序；
void process(int currentTmp, int nextTmp)
{
int j;
int s=nextTmp-currentTmp;
while(memoryNum>0 && s>=memory[0].needtime){
totalTime=totalTime+memory[0].needtime;
s=s-memory[0].needtime;
printf("线程%c的开始时间是:%d,结束时间
是:%f\n",memory[0].id,memory[0].cputime,totalTime+1);
allTime+=totalTime+1;
memoryNum--;
for(j = 1; j<=memoryNum; j++)
memory[j-1] = memory[j];
if(waitNum>0 && s>0){
memory[memoryNum] = wait[0];
memoryNum++;
waitNum--;
for(j = 1; j<=waitNum; j++)
wait[j-1] = wait[j];
sort(memory,memoryNum, 'P');
}
}
if(memoryNum>0 && s<memory[0].needtime){
totalTime=totalTime+s;
memory[0].needtime-=s;
}
}
//选择排序算法，若key为'P'则按优先级大的排在数组首，否则为'N'则按所需时间进行短作业优先排序
void sort(PCB *pcb,int count, char key)
{
PCB *p;
PCB mao;
int i,j;
if(key=='P'){
for(i=0;i<count;i++){
p=pcb;
for(j=0;j<count-1-i;j++){
if((p->priority)>((p+1)->priority)){
mao=*p;
*p=*(p+1);
*(p+1)=mao;
}
p++;
}
}
}else if(key=='N'){
for(i=0;i<count;i++){
p=pcb;
for(j=0;j<count-1-i;j++){
if((p->needtime)>((p+1)->needtime)){
mao=*p;
*p=*(p+1);
*(p+1)=mao;
}
p++;
}
}
}
}
（6）基于例题中的例子，分别运行两种处理机调度算法并将运行结果截图。