处理机调度算法实验报告
武汉理工大学操作系统处理机调度实验报告【范本模板】
学生学号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、操作系统：Windows 102、编程语言：Python3、开发环境：PyCharm三、实验内容1、先来先服务（FCFS）调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中，需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先（HRRN）调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为：响应比＝（等待时间＋要求服务时间）／要求服务时间。
4、时间片轮转（RR）调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片，每个作业或进程在一个时间片内运行，当时间片用完后，切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程，设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中，根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程，并按照不同的调度算法进行调度。
在调度过程中，更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标，用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务（FCFS）调度算法平均周转时间：通过计算所有作业或进程的周转时间之和除以作业或进程的数量，得到平均周转时间。
在 FCFS 算法中，由于按照到达顺序进行调度，可能会导致长作业或进程长时间占用处理机，从而使平均周转时间较长。
处理器调度实验报告
一、实验目的1. 理解处理器调度的基本概念和原理；2. 掌握常用的处理器调度算法，如先来先服务（FCFS）、短作业优先（SJF）、优先级调度等；3. 分析不同调度算法的性能指标，如平均周转时间、平均带权周转时间等；4. 通过实验，提高实际操作和编程能力。
二、实验原理处理器调度是操作系统中的一个重要组成部分，其主要任务是合理分配处理器资源，使系统中的多个进程高效、有序地运行。
常见的处理器调度算法有以下几种：1. 先来先服务（FCFS）：按照进程到达就绪队列的顺序进行调度，先到先服务；2. 短作业优先（SJF）：优先选择运行时间最短的进程执行；3. 优先级调度：根据进程的优先级进行调度，优先级高的进程先执行；4. 时间片轮转（RR）：将每个进程分配一个时间片，按照时间片轮转的方式调度进程。
三、实验内容1. 实验环境：Windows操作系统，Python编程语言；2. 实验工具：Python编程环境，如PyCharm、Spyder等；3. 实验步骤：（1）设计一个进程类，包含进程名、到达时间、运行时间、优先级等属性；（2）编写调度算法，实现FCFS、SJF、优先级调度和时间片轮转算法；（3）模拟进程执行过程，记录各个进程的执行时间、等待时间、周转时间等性能指标；（4）分析不同调度算法的性能，比较其优劣。
四、实验结果与分析1. FCFS调度算法实验结果：平均周转时间为20，平均带权周转时间为1.25。
分析：FCFS调度算法简单易实现，但可能导致进程响应时间长，不利于实时性要求高的系统。
2. SJF调度算法实验结果：平均周转时间为16，平均带权周转时间为1.2。
分析：SJF调度算法可以缩短平均周转时间，提高系统性能，但可能使长作业长时间等待，影响公平性。
3. 优先级调度算法实验结果：平均周转时间为18，平均带权周转时间为1.3。
分析：优先级调度算法可以根据进程的优先级进行调度，提高系统响应速度，但可能导致低优先级进程长时间等待。
处理器调度实验报告
处理器调度实验报告处理器调度实验报告一、实验目的处理器调度是操作系统中的重要组成部分，它负责决定哪个进程优先执行，以及如何分配处理器资源。
本次实验旨在通过模拟不同的处理器调度算法，深入了解各种算法的工作原理和优缺点。
二、实验背景在多道程序设计环境下，多个进程同时竞争有限的处理器资源。
为了提高系统的吞吐量和响应速度，需要合理地调度进程，使得每个进程都能得到公平的执行机会。
处理器调度算法的选择直接影响到系统的性能和用户体验。
三、实验内容本次实验使用模拟器来模拟不同的处理器调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority Scheduling）。
通过对这些算法的模拟实验，我们可以观察到它们在不同场景下的表现。
四、实验过程与结果首先，我们设计了一组测试用例，每个测试用例包含若干个进程，每个进程具有不同的执行时间和优先级。
然后，我们分别使用不同的调度算法对这些进程进行调度，并记录下每个进程的等待时间和周转时间。
在FCFS算法下，进程按照到达的先后顺序依次执行。
这种算法简单直观，但是容易造成后面进程的等待时间过长，尤其是当某个进程执行时间较长时。
SJF算法根据进程的执行时间来进行调度，执行时间最短的进程先执行。
这种算法能够最大程度地减少平均等待时间，但是对于长作业来说，可能会出现饥饿现象。
RR算法将处理器的时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程。
这种算法能够保证每个进程都能得到执行的机会，但是对于执行时间较长的进程来说，可能会造成较大的上下文切换开销。
优先级调度算法根据进程的优先级来进行调度，优先级高的进程先执行。
这种算法可以根据不同的场景进行调整，但是可能会出现优先级反转的问题。
通过实验结果的分析，我们可以看到不同的调度算法在不同场景下的表现。
对于短作业来说，SJF算法能够最大程度地减少等待时间；对于长作业来说，RR算法能够保证公平性；而优先级调度算法则适用于一些需要特定优先级处理的场景。
计算机操作系统-处理机调度实验报告
中南大学实验名称：处理机调度课程名称：计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程0602 完成时间 2008年10月12日目录一实验内容 (2)二实验目的 (2)三实验题目 (2)四基本思想 (2)五算法分析 (2)六流程图 (3)七算法描述 (4)八运行输出结果 (9)一实验内容选择一个调度算法，实现处理机调度。
二实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三实验题目设计一个按优先权调度和时间片轮转算法实现处理机调度的程序。
四基本思想先选择时间片的个数和每个时间片需要的时间，正在运行的进程每运行一秒其优先权数目加一，即其优先权减小。
每个时间片运行结束后，选择进入时间片进程优先权数目最小的进程，开始下一个时间片的运行。
如果有进程运行结束，则离开，再在就绪队列中选择优先权数目最小的进程进入。
在运行期间，如果有新的进程来到，按优先权大小放入就绪队列中。
五算法分析定义一个结构体，此包含了PCB的信息：struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};子函数struct PCB *create(int num,int n)用来建立一个按优先级大小排列的就绪进程链表和一个按时间先后循序排列的将进入就绪进程的链表。
main()函数中用一while循环输出进入时间片的进程状态。
六流程图七算法描述#define NULL 0#define LEN sizeof(struct PCB)#include"stdio.h"#include"stdlib.h"struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};struct PCB *create(int num,int n)/*创建进程，并将进程按优先级顺序插入队列中*/ {struct PCB *head,*p,*p1,*p2;int i;head=NULL; /*头指针指零*/for(i=1;i<=num;i++) /*循环建立所有进程*/{printf("请输入第%d个进程的信息\n",i);p=(struct PCB *)malloc(LEN); /*开辟一个空间*/printf("进程名:"); /*输入进程名*/scanf("%s",p->PID);printf("要求运行的时间:"); /*输入要运行的时间*/scanf("%d",&p->needtime);p->cputime=0; /*占用处理机的时间赋为零*/printf("优先权:"); /*输入优先权*/scanf("%d",&p->priority);if(n==1)p->starttime=0; /*进入就绪队列的时间赋为零*/else{printf("进入就绪队列时间:"); /*输入进入就绪队列的时间*/scanf("%d",&p->starttime);}p->overtime=-1; /*运行没有结束所以运行完成的时间赋为-1*/p->state=1; /*状态赋为就绪状态*/p1=head; /*p1指针指向头指针*/if(head==NULL) /*如果头指针为零将头指针指向新建立的进程*/ {head=p;head->next=NULL;}else /*头指针不为零的情况*/{if(n==1)while(p1!=NULL&&p->priority>p1->priority) /*查找插入点*/{p2=p1;p1=p1->next;}elsewhile(p1!=NULL&&p->starttime>p1->starttime) /*查找插入点*/{p2=p1;p1=p1->next;}if(head==p1) /*优先权的值最小作为表头*/{p->next=head;p2=head=p;}else /*否则的话插入*/{p2->next=p;p->next=p1;}}}return(head);}void main(){char now[5];int cho,num,num1,timepiece,time,i,j,k,flag,choo,clock=0;struct PCB*head,*head1,*over,*later,*l,*l1,*l2,*p,*p0,*p1,*p2,*q,*q1,*q2,*q3;over=NULL;printf("初始化进程...\n");printf("输入总的就绪进程数:");scanf("%d",&num);head=create(num,1); /*建立就绪进程的链表*/printf("输入将会就绪的进程数:");scanf("%d",&num1); /*建立将会进入就绪进程的链表*/later=create(num1,2);printf("cpu是否开始运行:1是 2不是--");scanf("%d",&cho);if(cho==1) /*处理机开始进行调度*/{printf("现在的时间是：");scanf("%s",now);printf("显示所有就绪的进程:\n");p2=head;printf("进程名\t要求运行时间\t已运行时间\t优先权\t状态(1就绪2运行3结束)\n");while(p2!=NULL){printf("%s\t%d\t\t%d\t\t%d\t%d\n",p2->PID,p2->needtime,p2->cputime ,p2->priority,p2->state);p2=p2->next;}printf("请输入时间片总数:");scanf("%d",&timepiece);printf("请输入时间片的时间:");scanf("%d",&time);printf("运行正式开始!\n");head1=head;printf("\t\t进程名\t要求运行时间\t已运行时间\t优先权\t状态\n"); for(i=1;i<=timepiece;i++) /*将进入时间片运行的进程用头指针head1指示，并改变就绪进程头指针head的指向*/{if(head!=NULL){p=head;head=head->next;}else break;}p->next=NULL;while(head1!=NULL) /*就绪进程头指针不为零就循环*/{head1->state=2; /*状态:1就绪2运行3完成*/for(j=1;j<=time;j++) /*每个时间片所需时间的循环*/{clock++; /*定时器每秒加1*/if(later!=NULL&&clock==later->starttime)/*如果将进入就绪队列的进程时间到达加入就绪队列*/ {l=later;l1=head;later=later->next;if(head==NULL){head=l;head->next=NULL;}else{while(l1!=NULL&&l1->priority<=l->priority){l2=l1;l1=l1->next;}if(l1==head){l->next=head;head=l;}else{l2->next=l;l->next=l1;}}}flag=0;printf("\n%3d秒时间片第%d秒 ",clock,j);q=head1;if(head1->needtime>head1->cputime) /*以运行时间和优先权都加1*/ {head1->cputime++;head1->priority++;while(q) /*运行队列不为零输出其信息*/ {if(q==head1)printf("%s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputime,q->pr iority,q->state);elseprintf("\t\t %s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputim e,q->priority,q->state);q=q->next;}}if(head1->needtime==head1->cputime)/*运行完成将其放入over为头指针的链表中*/ {head1->state=3;head1->overtime=clock;if(over==NULL){over=head1;head1=head1->next;over->next=NULL;}elseif(over!=NULL&&head1!=NULL){p1=head1->next;p0=over;over=head1;over->next=p0;head1=p1;}flag=1;}if(flag==1) break;}if(flag==1) /*有进程结束的情况*/{if(head!=NULL) /*就绪队列不为零将优先权最高的放入运行链表中*/ {q1=head;head=head->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}else /*无进程结束的情况,寻找优先权最高的运行*/{head1->state=1;q1=head1;head1=head1->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}}printf("cpu结束运行!\n");printf("是否输出所有结束的进程：1是2不是--");scanf("%d",&choo);if(choo==1) /*输出所有完成运行的进程*/{printf("开始时间:%s\n",now);printf("进程名\t要求运行时间\t进入就绪队列的时间\t运行完成的时间\n");while(over!=NULL){printf("%s\t%d\t\t%d\t\t\t%d\n",over->PID,over->needtime,over->startt ime,over->overtime);over=over->next;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告引言：处理机调度是操作系统中的重要组成部分，它负责决定在多道程序环境下，哪个进程应该获得处理机的使用权。
本实验旨在通过模拟处理机调度算法，探索不同调度算法对系统性能的影响，并对其进行评估和比较。
实验设计：在本实验中，我们选择了三种常见的处理机调度算法，分别是先来先服务调度（First-Come, First-Served, FCFS）、最短作业优先调度（Shortest Job First, SJF）和时间片轮转调度（Round-Robin, RR）。
我们使用C语言编写了一个处理机调度模拟程序，并通过模拟不同进程的到达时间、执行时间和优先级来测试这些调度算法的性能。
实验过程：我们首先设计了一组进程数据，包括到达时间、执行时间和优先级。
然后，我们分别使用FCFS、SJF和RR三种调度算法对这组进程进行调度，并记录每个进程的等待时间和周转时间。
通过这些数据，我们可以评估不同调度算法的性能。
首先，我们使用FCFS算法进行调度。
FCFS算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。
我们发现，FCFS算法的等待时间和周转时间较高。
这是因为当一个长时间的进程到达时，它会占用处理机很长时间，导致其他短进程需要等待较长时间才能执行。
接下来，我们使用SJF算法进行调度。
SJF算法选择执行时间最短的进程来执行，以最小化平均等待时间。
我们发现，SJF算法在减少平均等待时间方面表现出色。
由于短进程的执行时间较短，它们能够更快地完成执行，从而减少其他进程的等待时间。
最后，我们使用RR算法进行调度。
RR算法将处理机时间划分为固定长度的时间片，每个进程在一个时间片内执行，然后切换到下一个进程。
我们发现，RR算法能够公平地分配处理机时间，避免了某个进程长时间占用处理机的问题。
然而，由于每个进程只能在一个时间片内执行，这可能导致一些进程的执行时间被拖延，增加了它们的等待时间和周转时间。
处理机调度算法实验报告
实验二处理机调度算法（1）处理机调度的目的是什么？为提高内存利用率和系统吞吐量。
将那些暂时不能运行的进程调至外存，当内存不紧张时，将那些具备运行条件的就绪进程重新调入内存。
合理快速的处理计算机软件硬件资源，分配处理机，用以提高处理机的利用率及改善系统性能（吞吐量，响应时间）。
（2）处理机调度的算法有哪些，各自的优缺点是什么？①先来先服务算法：有利于长作业（进程），不利于短作业（进程）；②短作业优先调度算法：有利于短作业（短进程），不利于长作业（长进程）；③高优先权调度算法：静态缺点：可能导致低优先权进程长期得不到调度甚至饿死；动态：优先权随进程等待时间增加或执行而变④高响应比优先调度算法⑤基于时间片轮转调度算法：时间片太小，会频繁发生中断，系统开销增大时间片太大，响应进程慢。
⑥多级反馈队列调度算法：具有较好的性能，能很好满足各类型用户的需求。
1．内存中作业运行的序列：A、B、D、C2．A进入内存的时刻1，结束的时刻5B进入内存的时刻5，结束的时刻8D进入内存的时刻8，结束的时刻10C进入内存的时刻10，结束的时刻153．平均周转时间：61．内存中作业运行的序列：B、C、A、D2．B进入内存的时刻3，结束的时刻6C进入内存的时刻6，结束的时刻11A进入内存的时刻11，结束的时刻15D进入内存的时刻15，结束的时刻173．平均周转时间：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）基于例题中的例子，分别运行两种处理机调度算法并将运行结果截图。
操作系统实验之处理机调度实验报告
1、开发工具
Clion for mac 2016，采用 cmake 编译。
2、主要源码
//先来先服务 void FCFS(List *p, int count) {
List temp; int i, j; //按照到达时间排序 for (i = 1; i < count; i++) {
min = 100; temp = p[k].Finish_time; for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time < 0) continue;
if (min > p[j].Service_time) {
max = 0;
temp = p[k].Finish_time; //找响应比最高任务 for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time <= 0) continue;
if (max < (temp - p[j].Arrival_time) / p[j].Service_time) {
if (temp > p[i].Arrival_time) {
temp = p[i].Arrival_time; k = i; } } //按照响应比大小设置优先级，以及相应参数 for (i = 0; i < count; i++) { p[k].order = ++flag; p[k].Start_time = temp; p[k].Wait_time = temp - p[k].Arrival_time; p[k].Finish_time = temp + p[k].Service_time; p[k].Turnover_time = p[k].Finish_time - p[k].Arrival_time; p[k].WeightedTurn_time = p[k].Turnover_time / p[k].Service_time;
处理器调度算法实验报告
处理器调度算法实验报告一、实验目的本次实验的目的是通过模拟处理器调度算法，了解不同调度算法的优缺点，以及如何根据不同场景选择合适的算法。
二、实验环境本次实验使用C++语言编写程序，在Visual Studio 2019环境下进行开发和测试。
三、实验内容1. 实现FIFO调度算法FIFO（First In First Out）调度算法是最简单的一种调度算法，即先进先出。
在这种算法中，作业按照提交顺序排队等待执行。
当CPU空闲时，选择队列中最早提交的作业进行执行。
这种算法没有考虑作业的优先级和执行时间长短等因素，只关注作业的提交时间。
因此，在一些场景下可能会出现长作业占用CPU资源导致短作业等待时间过长等问题。
2. 实现SJF调度算法SJF（Shortest Job First）调度算法是一种非抢占式的短作业优先算法。
在这种算法中，每个作业都有一个估计运行时间，在CPU空闲时选择估计运行时间最短的作业进行执行。
如果两个作业估计运行时间相同，则按照提交顺序进行排队。
这种算法可以有效地减少平均等待时间和平均周转时间，但是可能会导致长作业等待时间过长。
3. 实现优先级调度算法优先级调度算法是一种抢占式的算法，即当高优先级作业到达时可以抢占正在执行的低优先级作业。
在这种算法中，每个作业都有一个优先级，CPU空闲时选择优先级最高的作业进行执行。
这种算法可以根据不同场景设置不同的作业优先级，但是可能会导致低优先级作业等待时间过长。
4. 实现时间片轮转调度算法时间片轮转调度算法是一种抢占式的循环调度算法。
在这种算法中，每个作业被分配一个固定长度的时间片，在该时间片内执行完毕后，如果该作业还未完成，则将其放入队尾等待下一次调度。
这种算法可以有效地保证每个作业都有机会获得CPU资源，并且能够避免长作业占用CPU资源导致短作业等待时间过长。
四、实验结果通过对以上四种调度算法进行模拟实验，得到了以下结果：1. FIFO调度算法：平均等待时间较长，平均周转时间也较长。
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程，加深对进程调度算法的理解。
实验中，我们重点研究了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行，我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中，我们定义了进程控制块（PCB）作为进程的抽象表示。
PCB包含以下信息：- 进程编号- 到达时间- 运行时间- 优先级- 状态（就绪、运行、阻塞、完成）为了方便调度，我们使用链表来存储就绪队列，以便于按照不同的调度策略进行操作。
2. 算法实现与模拟（1）先来先服务（FCFS）调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中，我们首先将所有进程按照到达时间排序，然后依次将它们从就绪队列中取出并分配CPU资源。
（2）时间片轮转（RR）调度算法RR算法将CPU时间划分为固定的时间片，并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时，它将被放入就绪队列的末尾，等待下一次调度。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度。
在模拟过程中，我们为每个进程分配一个优先级，并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后，我们输出每个进程的调度结果，包括：- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时，我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现，但可能会导致进程的响应时间较长，尤其是在存在大量短作业的情况下。
此外，FCFS算法可能导致某些进程长时间得不到调度，造成饥饿现象。
2. 时间片轮转（RR）调度算法RR算法能够有效地降低进程的响应时间，并提高系统的吞吐量。
然而，RR算法在进程数量较多时，可能会导致调度开销较大。
操作系统处理机调度实验报告
}
运行后结果如下：
[root@rhel5hbzy ~]# gcc -o chuliji chuliji.c
[root@rhel5hbzy ~]# ./m
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 EXIT
1
input name and time
jing 2
if(q->needtime==1)
q->cputime++;
else
q->cputime +=2;
q->needtime -=2;
if(q->needtime<0){
q->needtime = 0;
}
q->count++;
q->process = execute;
}
pcb *get_next(pcb *k,pcb *head){
}
void cpuexe(pcb *q){
pcb *t = q;
int tp = 0;
while(q){
if (q->process!=finish){
q->process = ready;
if(q->needtime==0){
q->process = finish;
}
}
if(tp<q->priority&&q->process!=finish){
aaaa' 1 7 39 ready
bbbb2 0 0 50 finish
ffff2 0 0 50 finish
处理器调度算法实验报告
实验三、处理器调度算法实验计本一区队学号：5090809一、实习内容选择一个调度算法，实现处理器调度。
二、实习目的本实习模拟在单处理器环境下的处理器调度，加深了解处理器调度的工作。
三、实习题目第一题：设计一个按优先数调度算法实现处理器调度的程序。
[提示]：(1)假定系统有5个进程，每个进程用一个PCB来代表。
PCB的结构为：·进程名——如P1~P5。
·指针——按优先数的大小把5个进程连成队列，用指针指出下一个进程PCB的首地址。
·要求运行时间——假设进程需要运行的单位时间数。
·优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
·状态——假设两种状态：就绪和结束，用R表示就绪，用E表示结束。
初始状态都为就绪状态。
(2) 开始运行之前，为每个进程确定它的“优先数”和“要求运行时间”。
通过键盘输入这些参数。
(3) 处理器总是选择队首进程运行。
采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。
(4) 进程运行一次后，若要求运行时间不等于0，则将它加入就绪队列，否则，将状态改为“结束”，退出就绪队列。
(5) 若就绪队列为空，结束，否则转到(3)重复。
2．程序中使用的数据结构及符号说明：#define num 5//假定系统中进程个数为5struct PCB{char ID;//进程名int runtime;//要求运行时间int pri;//优先数char state; //状态，R-就绪，F-结束};struct PCB pcblist[num];//定义进程控制块数组3.源程序清单//按优先数调度算法实现处理器调度的程序#include<stdio.h>#include <string.h>#define num 5//假定系统中进程个数为5struct PCB{char ID;//进程名int runtime;//要求运行时间int pri;//优先数char state; //状态，R-就绪，F-结束};struct PCB pcblist[num];//定义进程控制块数组void init()//PCB初始化子程序{int i;for(i=0;i<num;i++){printf("PCB[%d]:ID pri runtime \n",i+1);//为每个进程任意指定pri和runtime scanf("%s%d%d",&pcblist[i].ID,&pcblist[i].pri,&pcblist[i].runtime);pcblist[i].state='R';//进程初始状态均为就绪getchar();//接收回车符}}int max_pri_process()//确定最大优先级进程子程序{int max=-100;//max为最大优先数，初始化为-100int i;for(i=0;i<num;i++){if(pcblist[i].state=='r')//r为辅助状态标志，表示正在运行return -1;//返回-1elseif(max<pcblist[i].pri&&pcblist[i].state=='R')//从就绪进程中选取优先数最大的进程{max=pcblist[i].pri;//max存放每次循环中的最大优先数key=i;//将进程号赋给key}}if(pcblist[key].state=='F')//具有最大优先数的进程若已运行完毕return -1;//则返回-1else//否则return key;//将key作为返回值返回}void show()//显示子程序{int i;printf("\n ID pri runtime state\n");printf("-------------------------------------------------\n");for(i=0;i<num;i++)//依次显示每个进程的名、优先数、要求运行时间和状态{printf("%s%6d%8d %s\n",&pcblist[i].ID,pcblist[i].pri,pcblist[i].runtime,&pcblist [i].state);}printf(" press any key to continue...\n");}void run()//进程运行子程序int t=0;//t为运行次数for(j=0;j<num;j++){t+=pcblist[j].runtime;}//运行次数即为各个进程运行时间之和printf("\nbefore run,the conditon is:\n");show(); //调用show()子程序显示运行前PCB的情况getchar();//等待输入回车符for(j=0;j<t;j++){while(max_pri_process()!=-1)//具有最大优先数的进程没有运行完，让其运行{pcblist[max_pri_process()].state='r';//将其状态置为r，表示其正在运行}for(i=0;i<num;i++){if(pcblist[i].state=='r'){ pcblist[i].pri-=1;//将当前运行进程的优先数减1pcblist[i].runtime--;//要求运行时间减1{if(pcblist[i].runtime==0)pcblist[i].state='F';//运行完则将该进程状态置为结束elsepcblist[i].state='R';//未运行完将其状态置为就绪}show();//显示每次运行后各PCB的情况getchar();//等待回车进入下一次运行}}}}void main()//按动态优先数调度主程序{init();//初始化各个进程PCBrun();//进程调度模拟}运行后结果：首先初始化ID pri runtimea 5 6b 6 5c 4 4d 1 2e 3 3回车，继续运行：【直到状态都为F时结束】运行的最后结果：ID pri runtime statea -1 0 Fb 1 0 Fc 0 0 Fd -1 0 Fe 0 0 F实验结果分析：实验最后结果出现优先数为负【-1】的情况，是因为运行时间大于优先数，而进程每运行1次，优先数减1，要求运行时间减1而导致的。
- 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）基于例题中的例子，分别运行两种处理机调度算法并将运行结果截图。