处理机调度实验报告
武汉理工大学操作系统处理机调度实验报告【范本模板】

学生学号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语句进行各个调度算法的选择,最后经过不断的调试和运行,实现四个调度算法分别是先来先服务、短进程优先、优先级和最高响应比优先。
二、调试说明(调试手段、过程及结果分析)调试过程出现的问题比较多,第一个问题是对于不同作业提交的先后顺序要加以考虑,对于作业提交时间进行排序选择,必须选择提交时间在上一个作业结束时间之前的作业进行短进程,优先级,最高响应比排序,经过排序选择后,出现的问题是在进行作业调度完,有的作业出现了负的结束时间,经过调试分析,发现不能直接用上一个作业的结束时间直接当做下一个作业的开始时间,每次进行作业调度前要进行提交时间与上一个作业结束时间的比较,如果在作业提交前,下一个作业还没有提交,那么在下一个作业的开始时间就是它的提交时间。
计算机操作系统-处理机调度实验报告(精品)

中南大学实验名称:处理机调度课程名称:计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程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. 实验设计在本次实验中,我们选择了三种常见的处理机调度算法进行比较,分别是先来先服务(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测试。
处理机调度实验

int timeSlice=2;
int hodeUpTime=5; int changePrio=0; void sort();
void changeRunPrio(); void changeReadyPrio();
//改变 run 的优先级函数声明 //改变 ready 的优先级函数声明
int randomPrio(double from,double to){ //产生 from 到 to 之间的随机数 return 1+(int)((to)*rand()/(RAND_MAX+from));
四、 实验总结(包括:实验效果分析、心得体会、遗留问题) 过本实验。了解了处理机调度的常用策略:优先权调度和时间片 轮转两种调度算法,熟悉了处理机调度算法的具体流程,同时也对操 作系统中处理机调度的概念有了更深的理解。 教师评语
成绩:
教室签名:
年
月
日
pid name status type prio res totalTime count runTime Finished…… 1005 pid5 0 1 2 6 12 1 12 1003 pid3 0 1 -1 6 12 1 12 1001 pid1 0 1 0 6 12 1 12 1004 pid4 0 0 -1 6 12 2 12 1002 pid2 0 0 -1 6 12 1 12
三、 实验结果(包括:运行结果、结果分析) 动态优先调度算法运行结束后结果:
pid name status type prio res totalTime count runTime
Rnning…… 1005 pid5 1 1 1 6 12 0 11 Finished…… 1003 pid3 0 1 -1 6 12 1 12 1001 pid1 0 1 0 6 12 1 12 1004 pid4 0 0 -1 6 12 2 12 1002 pid2 0 0 -1 6 12 1 12
操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一,本次实验的主要目的是通过模拟不同的处理机调度算法,深入理解操作系统对处理机资源的分配和管理策略,比较不同调度算法的性能差异,并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 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. 背景处理器调度算法是操作系统中的重要组成部分,用于优化多道程序在处理器上的执行顺序,提高系统的整体性能和响应时间。
通过合理的调度算法,可以使多个进程公平竞争处理器资源,并满足不同进程的优先级要求。
本次实验旨在探究不同的处理器调度算法在不同场景下的效果,以及调度算法对系统性能的影响。
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算法在长作业的场景中表现较差,平均等待时间和平均周转时间较长。
处理机调度操作系统实验报告

scanf("%s",q->name);
scanf("%d",&q->needtime);
q->cputime = 0;
q->priority = P_TIME - q->needtime;
q->process = ready;
q->next = NULL;
printf("2 ROUNDROBIN\n");
printf("3 EXIT\n");
}
pcb* get_process(){
pcb *q;
pcb *p; //头指针
pcb *t; //尾指针
int i = 0;
printf("input name and time\n");
while (i < P_NUM){
int i = 0;
printf("input name and time\n");
while (i<P_NUM){
q=(pcb *)malloc(sizeof(pcb));
scanf("%s",q->name);
scanf("%d",&q->needtime);
q->cputime = 0;
q->count = 0;
t->cputime++;
}
}
void priority_cal(){
pcb *p;
p = get_process();
int cpu = 0;
实验一 处理机调度实验报告

实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分,其目的是合理地分配处理机资源,以提高系统的性能和效率。
本次实验的主要目的是通过模拟处理机调度算法,深入理解不同调度算法的工作原理和性能特点,并能够对它们进行比较和分析。
二、实验环境本次实验使用了以下软件和工具: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。
分析:优先级调度算法可以根据进程的优先级进行调度,提高系统响应速度,但可能导致低优先级进程长时间等待。
处理机调度算法实验报告

实验二处理机调度算法(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;
处理机调度与死锁实验报告

探索处理机调度与死锁的实验本次实验主要针对处理机调度与死锁展开,旨在让学生深入理解操作系统中的重要概念,掌握具体的解决方案。
一、实验目的
1. 探究操作系统中的处理机调度算法并了解其原理。
2. 了解死锁概念及其分类,并学习有关死锁预防和避免的方法。
二、实验内容
1. 处理机调度实验
在实验中,我们学习了几种不同的处理机调度算法:先来先服务(FCFS)、短作业优先(SJF)、优先级调度(PS)、时间片轮转调度(RR)等。
通过模拟不同进程的到达和运行,学生们了解每个算法的特点和缺点,并分析在不同场景下使用算法的合理性。
2. 死锁实验
在死锁实验中,学生们学习了死锁的原理和分类。
为了更好地理解死锁的产生,我们首先逐步增加资源请求数量来模拟进程的资源竞争。
在后面的实验中,我们使用了银行家算法和资源分配图等工具来预防和避免死锁。
三、实验结果
在本次实验中,学生们深入理解了处理机调度的相关概念,并通过实践提高了分析和解决问题的能力。
同时,学生们也掌握了死锁的原理和可能出现的场景,并学会了如何通过预防和避免的方法解决这些问题。
总之,本次实验是一次极为成功的尝试,也是学生们加深对操作系统理论知识的关键步骤。
通过深入探究实验中的内容,可以帮助学生更好地理解和掌握操作系统相关知识,并为今后在实际工作中提供指导和支持。
实验一_处理器调度____(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度一、实习内容选择一个调度算法,实现处理器调度。
二、实习目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
三、实习题目本实习有两个题,学生可选择其中的一题做实习。
第二题:设计一个按时间片轮转法实现处理器调度的程序。
[提示]:(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为:Q1,Q2,Q3,Q4,Q5。
指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数,初始值为“0”。
状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。
当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。
(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如,当前轮到P2执行,则有:标志单元,K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。
由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位的时间。
请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。
在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5) 进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。
实验一处理器调度实验报告

实验一处理器调度之杨若古兰创作一、实验内容选择一个调度算法,实现处理器调度.二、实验目的在采取多道程序设计的零碎中,常常有若干个进程同时处于就绪形态.当就绪形态进程个数大于处理器数时,就必须按照某种计谋来决定哪些进程优先占用途理器.本实验模拟在单处理器情况下处理器调度,帮忙先生加深了解处理器调度的工作.三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示:(1)假定零碎有五个进程,每一个进程用一个进程控制块PCB 来代表.进程控制块的格式为:其中,进程名----作为进程的标识,假设五个进程的进程名分别是P1,P2,P3,P4,P5.指针----按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块首地址,最初一个进程中的指针为“0”.请求运转时间----假设进程须要运转的单位时间数.优先数----赋予进程的优先数,调度时老是拔取优先数大的进程先履行.形态----可假设有两种形态,“就绪”形态和“结束“形态,五个进程的初始形态都为“就绪“形态,用“R”暗示,当一个进程运转结束后,它的形态变成“结束”,用“E”暗示.(2)在每次运转你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“请求运转时间”.(3)为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首进程,用指针指出队列的连接情况.例:队首标记(4)处理器调度老是选队首进程运转.采取动态改变优先数的法子,进程每运转一次优先数就减“1”.因为本实验是模拟处理器调度,所以,对被选中的进程其实不实际的启动运转,而是履行:优先数-1请求运转时间-1来模拟进程的一次运转.提醒留意的是:在实际的零碎中,当一个进程被选中运转时,必须恢复进程的现场,它据有处理器运转,直到出现等待事件或运转结束.在这里省去了这些工作.(5)进程运转一次后,若请求运转时间≠0,则再将它加入队列(按优先数大小拔出,且置队首标记);若请求运转时间=0,则把它的形态点窜为“结束”(),且退出队列.(6)若“就绪”形态的进程队列不为空,则反复上面(4)和(5)的步调,直到所有进程都成为“结束”形态.(7)在所设计的称序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运转一次后进称对列的变更.(8)为五个进程任意确定一组“优先数”和“请求运转时间”,启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名和进程控制块的动态变更过程.四、程序中使用的数据结构及符号说明:#define num 5//假定零碎中进程个数为5struct PCB{char ID;//进程名int runtime;//请求运转时间int pri;//优先数char state; //形态,R-就绪,F-结束};struct PCB pcblist[num];//定义进程控制块数组五、流程图:(1)(2)子程序init()(3) 子程序max_pri_process()流程图:(4)子程序show()流程图:(5)子程序run()流程图://按优先数调度算法实现处理器调度的程序#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和runtimescanf("%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;int key;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 i,j;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;//将当前运转进程的优先数减1 pcblist[i].runtime--;//请求运转时间减1{if(pcblist[i].runtime==0)pcblist[i].state='F';//运转完则将该进程形态置为结束elsepcblist[i].state='R';//未运转完将其形态置为就绪}show();//显示每次运转后各PCB的情况getchar();//等待回车进入下一次运转} } }}void main()//按动态优先数调度主程序{init();//初始化各个进程PCBrun();//进程调度模拟}七、实验总结本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现,了解到进程与进程控制块之间的联系,进程运转过程中形态和已运转时间的判断和计算,选中运转的进程名和选中进程运转后的各进程控制块形态.。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
(2)局部变量
insert()函数:
指针变量head为指向链表的头指针;
指针变量tail为一个遍历链表指针;
指针变量pretail为一个指向tail所指向的结点前一个结点的指针,用来查找插入位置;
指针变量p指向新申请到的新结点;
create()函数中:
指针变量p指向新申请到的新结点;
整型变量i用来实现for循环。
display(head);
getchar();
}
printf("结束!");
}
2、程序运行结果截图如下:
第一题截图:
选择菜单显示:
输入数据后
五、实习总结
六、教师评语及成绩
评语:
成绩:
年月日
入口参数:无
出口参数:建立的链表的头指针
函数流程图如图二所示:
(3)输出模拟函数:PCB* module(PCB *head)
用来模拟进程运行,并将结果显示给用户,此函数没有返回值。此函数只是依次把链表的第一个进程结点运行一次,然后改变优先数和执行完所需时间,再插入到链表中去,并保持链表有序,如果一个进程结点执行时间变为0,则将其从链表里删除,并且释放内存,一直重复下去,直到此链表为空,因为此函数中插入结点和create
printf("=========================\n");
while (h!=NULL)
{
printf("进程名=%s,要求运行时间=%d,优先数=%d,状态=%c\n",h->NAME ,h->TIME,h->PRIORITY ,h->STATE );
h=h->next;
}
printf("=========================\n");
}
return (head);
}
cpp文件
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include"chuli.h"
void display(PCB *head)
{
PCB *h=head;
printf("\n就绪队列中的进程为:\n");
printf("\t\t\t\t=========================\n");
free(run);
}
return head;
}
void main()
{
PCB *head=NULL;
head=creat(head);
display(head);
while (head!=NULL)
{
head=module(head);
int TIME;//表示进程所需要的运行时间
int PRIORITY;//表示进程的优先级
char STATE;//表示进程的状态,为r时表示就绪,为e时表示已执行完
struct PCB *next;
};
PCB*insert(PCB *head,PCB *p)
{
struct PCB *tail,*pretail;//tail为一个遍历指针,pretail是指向tail所指的前一个结点的指针
if (run->TIME>0) head=insert(head,run);
else
{
printf("\t\t\t\t%s is finished!\n",run->NAME);
printf("\t\t\t\t=========================\n");
printf("\t\t\t\t进程名=%s,要求运行时间=%d,优先数=%d,状态=%c\n",run->NAME ,run->TIME,run->PRIORITY ,run->STATE );
head=NULL;
for(i=1;i<=5;i++)
{
printf("\n进程号No.%d:\n",i);
p=(struct PCB *)malloc(sizeof(struct PCB));
printf("请输入进程的名字:");
scanf("%s",name);
strcpy(p->NAME,name);
实验报告
(学院)系:信息工程学院
专业:网络工程
姓名:
班级:
学号:
指导教师:
2012年12月26日
操作系统实验报告
姓名
学号
日期
12月26日
实验室
机房152
指导教师
设备编号
实习题目
设计一个按优先数调度算法实现处理器调度的程序
一、实验内容
选择一个调度算法,实现处理器调度。
二、实验目的
在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
}
if((p->PRIORITY) >(tail->PRIORITY))
{
if(head==tail)//如果此时链表中只有一个进程结点
{
p->next =head;
head=p;
}
else//如果此时链表中有多个进程结点
{
pretail->next =p;
pretail=p;
p->next =tail;
入口参数:建立的链表的头指针
出口参数:无
函数流程图如图三所示
四、程序实现及运行结果截图
1、源程序文件夹
处理机
头文件
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
struct PCB//定义结构体PCB
{
char NAME[10];//表示进程名字
if (run->TIME==0) run->STATE='e';
printf("进程名=%s,要求运行时间=%d,优先数=%d,状态=%c\n",run->NAME ,run->TIME,run->PRIORITY ,run->STATE );
printf("=========================\n");
三、实验过程
1、数据结构设计:
(1)全局变量
struct PCB//定义结构体PCB
{
char NAME[10];//表示进程名字
int TIME;//表示进程所需要的运行时间
int PRIORITY;//表示进程的优先级
char STATE;//表示进程的状态,为r时表示就绪,为e时表示已执行完
struct PCB *next;
}
PCB* module(PCB *head)
{
PCB *run;
run=head;
head=head->next;
run->TIME--;
run->PRIORITY--;
run->next=NULL;
printf("%s is running!\n",run->NAME);
printf("=========================\n");
}
}
else
{
tail->next =p;
p->next =NULL;
}
return head;
}
PCB* creat(PCB* head)
{
struct PCB *p;//head为头指针,p指向新申请到的结点
int i;
char name[10];
int time;
int priority;
char state='r';
printf("请输入该进程执行完所需的时间(>0):");
scanf("%d",&time);
p->TIME =time;
printf("请输入该进程的优先级:");
scanf("%d",&priority);
p->PRIORITY =priority;
p->STATE =state;
head=insert(head,p);
display()函数:
指针变量h为指向链表的头指针;
module()函数
指针变量run为一个遍历链表指针;
main()函数
2、算法设计
(1)主函数
void main()
函数功能:初始化一些信息,再通过菜单选择要执行的操作:
主函数流程如图1所示。
2)创建函数PCB* creat(PCB* head)用来建立一个就绪进程链表,其中每个结点为一个PCB结构体,此链表是一个按照PRIORITY(进程优先数)排序的有序链表,此函数返回建立的链表的头指针。
pretail=tail=head;
if(head==NULL)
{