计算机操作系统：处理机调度模拟实验资料
计算机操作系统：处理机调度模拟实验
display2(run);
}
p = ready;
if (p != NULL)
printf("\n ****当前就绪队列中进程的状态如下:\n"); /*显示就绪队列状态*/
while (p != NULL)
{
display2(p);
p = p->next;
}
p = finish;
根据单处理机，多任务的问题特性做好软件实现的需求分析。可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
实验环境
Windows 7或以上版本+ VS2010或以上版本
实验内容
程序运行一次中，要求三个进程队列，每个优先权依次为1、2、3，即优先权为1的只分配1个时间片，优先权为2的只分配2个时间片，优先权为3的只分配3个时间片；每个进程队列命名、进程命名与进程数自定，轮转打印出各个进程名，程序结束打印退出。
run->state = 'R';
display();
}
//探测到有就绪队列时，选择一个将处理机分配给它
void priority(int T)
{
while (run != NULL)
{
run->rtime = run->rtime + T;
run->syቤተ መጻሕፍቲ ባይዱime = run->sytime - T;
实验完成后请现场演示。
实验步骤描述
1.给一系列进程创建结构体
2.写一个printready函数探测就绪队列是否为空
3.写一个display1函数，用于显示当前进程
计算机操作系统-处理机调度实验报告（精品）
中南大学实验名称：处理机调度课程名称：计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程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;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。
实验一 处理机调度实验报告
实验一处理机调度一、实验内容选择一个调度算法，实现处理机调度。
二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度，以加深了解处理机调度的工作。
三、实验题目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测试。
计算机操作系统 实验一
实验一处理机调度实验
一、实验目的：
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验要求：
设计一个有N个进程并发的进程调度程序。
进程调度算法：采用时间片轮转调度算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片，运行后已占用CPU时间加1。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，则把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
操作系统实验之处理机调度实验报告
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 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． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
4． 编写出源程序二、参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法3） F IFO 调度三、实验部分流程图 开始 读入文件进程流文件 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间 按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY FIFO注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法四、实验过程：（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO 算法，优先数调度算法，时间片轮转调度算法实验代码如下：#include<stdio.h> 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j;int total;//输出FIFO算法执行流cout<<endl<<"**"<<endl;cout<<"FIFO算法执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[j].time;}}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;//由学生完成}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;//由学生完成}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}//由学生完成}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl; }//主函数int main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}return 0;}运行结果如下：。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念，它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验，探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法，比较它们在不同负载下的性能表现，进而分析其优缺点，为实际操作系统的调度算法选择提供参考。
三、实验方法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算法将处理机的运行时间划分为若干个时间片，每个任务在一个时间片内执行一定的时间，然后切换到下一个任务。
计算机操作系统：处理机调度模拟实验资料
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度，以加深了解处理机调度的工作过程。
要求：
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等，来实现处理机的调度。
根据单处理机，多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述6.create函数用于创建队列
7.insert为插入函数，用于将一个时间片运行结束的进程插入到就绪进程的
队尾
8.priority函数：如果有进程就绪，就将处理机分配给该进程让他执行。
调试过程及实验结果
总结每次运行一步，电脑将会将该时刻所有进程控制块的运行状态显示给用户。
包括进程名、要求运行时间、已经运行时间、还需要运行时间、状态等信息。
当每个进程运行一个时间片之后将它从该队列中移除，添加到就绪队列队尾中以便使每个进程可以循环执行。
当要求运行时间和已运行时间相等时，说明该进程运行结束，将该进程撤出该队列并且不再添加到就绪队列中。
直到就绪队列中没有就绪进程为止
附录#define _CRT_SECURE_NO_DEPRECATE #include"stdio.h"
#include"stdlib.h"
#include"string.h"
typedef struct node
{
char pname[10]; //进程名
int rtime; //已运行时间
int sytime; //剩余时间。
实验一 处理机调度实验报告
实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分，其目的是合理地分配处理机资源，以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法，深入理解不同调度算法的工作原理和性能特点，并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具：1、操作系统：Windows 102、编程语言：Python3、开发环境：PyCharm三、实验内容1、先来先服务（FCFS）调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。
即先到达的作业或进程先得到处理机的服务。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度运行时间短的作业或进程。
在实现过程中，需要对作业或进程的运行时间进行预测或已知。
3、高响应比优先（HRRN）调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。
响应比的计算公式为：响应比＝（等待时间＋要求服务时间）／要求服务时间。
4、时间片轮转（RR）调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片，每个作业或进程在一个时间片内运行，当时间片用完后，切换到下一个作业或进程。
四、实验步骤1、设计数据结构为了表示作业或进程，设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。
2、实现调度算法分别实现了上述四种调度算法。
在实现过程中，根据算法的特点进行相应的处理和计算。
3、模拟调度过程创建一组作业或进程，并按照不同的调度算法进行调度。
在调度过程中，更新作业或进程的状态和相关时间参数。
4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标，用于评估不同调度算法的性能。
五、实验结果与分析1、先来先服务（FCFS）调度算法平均周转时间：通过计算所有作业或进程的周转时间之和除以作业或进程的数量，得到平均周转时间。
在 FCFS 算法中，由于按照到达顺序进行调度，可能会导致长作业或进程长时间占用处理机，从而使平均周转时间较长。
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
操作系统实验之处理机调度实验报告
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;
处理机调度
实验二（进程）处理器调度一、实验内容选择一个调度算法，实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目本实习有两个题，学生可选择其中的一题做实习。
第一题：设计一个按优先数调度算法实现处理器调度的程序。
[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统模拟实验：单处理机系统的进程调度实验报告
数学与计算机学院单处理机系统的进程调度实验报告年级07 学号23 姓名王阳成绩专业信计实验地点主楼402 指导教师王硕实验项目单处理机系统的进程调度实验日期实验报告要求：一、实验目的1、加深对进程概念的理解，明确进程和程序的区别。
2、深入了解系统如何组织进程、创建进程。
3、进一步认识如何实现处理机调度。
二、实验原理三、实验要求1、采用时间片轮转调度算法实现进程调度。
2、确定进程控制块的内容，进程控制块的组织方式。
3、完成进程创建原语和进程调度原语。
4、编写主函数对所做工作进行测试。
四、实验结果（程序）及分析#include <>#define N 10 ext=temp+1;}pcbArea[temp].next=-1;pfree=0;ext;if==-1)=-1;pcbArea[temp].next=-1;return temp;}ext;pcbArea[temp].next=-1;return temp;}ext=-1;}x=;pcbArea[x].bx=;pcbArea[x].cx=;pcbArea[x].dx=;pcbArea[x].name=;pcbArea[x].next=-1;pcbArea[x].pc=;pcbArea[x].psw=;pcbArea[x].status=;}tatus=Running;TIME=SLOT; x;BX=pcbArea[temp].bx;CX=pcbArea[temp].cx;DX=pcbArea[temp].dx;PC=pcbArea[temp].pc;PSW=pcbArea[temp].psw;run=temp; ame);printf("进程状态：%d\n",pcbArea[run].status);printf("寄存器内容：\nAX\tBX\tCX\tDX\tPC\tPSW\n");printf("%d\t%d\t%d\t%d\t%d\t%d\n",pcbArea[run].ax,pcbArea[run].bx,pcbArea[run].cx,pcbArea[run].dx,pcbArea[run].pc,pcbArea[run]. psw);void main(){int temp;PCB tmp_pcb;printf("请输入进程号，以负数为结束（进程号应保持唯一）。
计算机操作系统 模拟调度算法实验报告
实验二调度算法的模拟实现一、实验目的1.加深对先来先服务算法，短作业优先算法，最高优先权优先调度算法等三种调度算法的理解2.利用C语言编写算法，模拟实现先来先服务算法，短作业优先算法，最高优先权优先调度算法。
3.模拟三种调度算法，对比三种调度算法的优缺点，并计算平均周转时间和平均带权周转时间。
二、实验开发平台Microsoft Visual C++ 6.0（使用C语言）三、三个调度算法说明先来先服务调度算法，是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。
另处，FCFS调度算法对CPU繁忙型作业较有利，而不利于I/O繁忙作业。
短作业优先调度算法（SWF），是指对短作业或短进程优先调度的算法，是指分派CPU时，把CPU优先分给最短的作业。
它的缺点是对长作业不利，不能保证及时处理解紧迫性的作业。
最高优先权优先调度算法，常用于批处理系统中，既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。
它实现了一种较好的折衷,但每要进行高度之前，都须先做响应比的计算，这会增加系统开销。
四、实验源程序#include <stdio.h>struct process{char name[10];int dtime;int ftime;int youxian;};struct process pro[3];struct process tempPro[3];void fcfs()//先来先服务{//先对这些线程排序,使用冒泡法排序，从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].dtime>pro[j+1].dtime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void sjf()//短作业优先{//使用冒泡法排序,从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].ftime>pro[j+1].ftime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void youxian()//最高优先权优先，假定此处为优先数最大的进程优先服务{ //使用冒泡法排序，从大到小int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].youxian<pro[j+1].youxian){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void print()//输出进程名称{int i;for (i=0;i<3;i++){printf("%s\n",pro[i].name);}}void main(){printf("请输入第一个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[0].name,&pro[0].dtime,&pro[0].ftime,&pro[0].youxian);printf("请输入第二个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[1].name,&pro[1].dtime,&pro[1].ftime,&pro[1].youxian);printf("请输入第三个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[2].name,&pro[2].dtime,&pro[2].ftime,&pro[2].youxian);printf("先来先服务调度执行顺序：\n");fcfs();print();printf("短作业优先调度执行顺序：\n");sjf();print();printf("最高优先权优先调度执行顺序：\n");youxian();print();}五、运行结果。
操作系统处理机调度实验报告
}
运行后结果如下：
[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
操作系统实验(处理机调度)
实验报告学院（系）名称：计算机与通信工程学院
【实验过程记录（源程序、测试用例、测试结果及心得体会等）】
一、实验效果：
1）打开主界面
2）初始化线程的时间和优先级，设置各个进程的时间和优先级。
3) 开始运行模拟线程。
绿色代表当前正在运行的线程。
二、实验代码
1）本实验使用Java的Swing绘制GUI，能够简单便捷的观察到处理机是如何根据时间和优先级来调度进程的。
代码结构：Swing绘制GUI：
2）Java ，Swing优点：
使用Swing的Jtable，JTabbedPane，能清楚的观察某一时刻各个进程的状态，以及正在运行哪个进程
3）模拟进程的数据结构：
自定义一个类ThreadBean，通过这种数据结构来代表进程。
这个类中有id，time(时间), property(优先级)的属性
4) 进程调度算法：
一、编写了一个SortList类，来完成调度算法
二、每一次通过遍历每个进程，找出优先级以及时间最多的进程，准备被处理机调度。
三、处理机调度后，这个线程的时间以及优先级减1
5）细节的处理
一、果没有进行初始设置进程的优先级和时间就点击了运行，会弹出提示框，不允许运行。
二、数据过滤，输入时间，优先级时只能填写整数，如果不是整数会进行过滤，提示。
三、扩展性
程序各个部分已经模块化，可以直接进行扩展。
通过选择不同的标签来显示几个不同的实验，完成三个实验均可以同时显示，不影响程序性能。
操作系统实验---处理机调度
操作系统实验---处理机调度(总11页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--实验报告实验题目姓名：学号：课程名称：操作系统实验所在学院：信息科学与工程学院专业班级：计算机任课教师：处理机调度实验项目名称一、实验目的与要求：1、给出所选实验题目。
2、给出源程序文件名和执行程序文件名。
源程序中要有详细的注释。
3、给出程序中使用的数据结构和符号说明。
4、给出程序的流程图。
5、给出运行结果。
6、总结收获体会和对题解的改进意见及见解。
二、实验设备及软件：装有Linux操作系统的PC机一台三、实验方法（原理、流程图）设计一个按时间片轮转法调度的算法1.进程控制块内容和先来先服务调度的算法一样，如右图所示。
系统设置一个队头和一个队尾指针，分别指向队列的第一个和最后一个进程。
2.为每个进程确定一个要求运行时间和到达时间。
3.按进程到达的先后次序排成一个循环队列。
4.处理机调度时，开始选择队首第一个进程运行，另外再设一个当前运行进程指针，指向当前正运行的进程。
5.本实验是模拟，所选进程并不实际运行，只是执行：估计运行时间减1和输出当前运行进程名。
6．进程运行一次后，应将当前运行进程指针下移一个位置，指向下一个进程。
同时还应判断该进程的剩余运行时间是否为0。
若不为0，则等待下一轮调度；若为0，则则状态改为完成状态，并撤出就绪队列。
7．若就绪队列不空，重复上述5，6步。
8．程序中应有显示和打印语句，显示每次选中进程名字和队列变化情况。
进程名链接指针到达时间估计运行时间进程状态程序流程图如下：建立就绪队列函数五、实验数据（现象）处理分析进一步生成可执行文件时出现错误1：解决办法：#include <>是一个控制输出的头文件，getch()函数不能使用，所以去掉头文件并且修改getch()函数。
具体修改部分如下图所示：进一步生成可执行文件时出现错误2：解决办法：malloc的功能与头文件#include <>有关，但是本参考代码没有给出头文件，所以添加头文件以后malloc的功能可以实现了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度，以加深了解处理机调度的工作过程。
要求：
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等，来实现处理机的调度。
根据单处理机，多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述6.create函数用于创建队列
7.insert为插入函数，用于将一个时间片运行结束的进程插入到就绪进程的
队尾
8.priority函数：如果有进程就绪，就将处理机分配给该进程让他执行。
调试过程及实验结果
总结每次运行一步，电脑将会将该时刻所有进程控制块的运行状态显示给用户。
包括进程名、要求运行时间、已经运行时间、还需要运行时间、状态等信息。
当每个进程运行一个时间片之后将它从该队列中移除，添加到就绪队列队尾中以便使每个进程可以循环执行。
当要求运行时间和已运行时间相等时，说明该进程运行结束，将该进程撤出该队列并且不再添加到就绪队列中。
直到就绪队列中没有就绪进程为止
附录#define _CRT_SECURE_NO_DEPRECATE #include"stdio.h"
#include"stdlib.h"
#include"string.h"
typedef struct node
{
char pname[10]; //进程名
int rtime; //已运行时间
int sytime; //剩余时间。