天津理工大学操作系统实验:处理及调度
计算机操作系统-处理机调度实验报告(精品)
![计算机操作系统-处理机调度实验报告(精品)](https://img.taocdn.com/s3/m/9bca3d35bdd126fff705cc1755270722192e590d.png)
中南大学实验名称:处理机调度课程名称:计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程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;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。
操作系统实验之处理机调度实验报告
![操作系统实验之处理机调度实验报告](https://img.taocdn.com/s3/m/67a9f555854769eae009581b6bd97f192279bf85.png)
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一,本次实验的主要目的是通过模拟不同的处理机调度算法,深入理解操作系统对处理机资源的分配和管理策略,比较不同调度算法的性能差异,并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 Python 38。
实验中使用了 Python 的相关库,如`numpy`、`matplotlib`等,用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务(FCFS)调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务,直到完成或阻塞,然后再处理下一个到达的作业。
2、短作业优先(SJF)调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间,但可能导致长作业长时间等待。
3、时间片轮转(RR)调度算法时间片轮转算法将处理机的时间分成固定长度的时间片,每个作业轮流获得一个时间片的处理时间。
当时间片用完后,如果作业还未完成,则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级,优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先,生成一组模拟的作业,包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性,生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中,严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果:平均等待时间:作业在就绪队列中的等待时间的平均值。
平均周转时间:作业从到达系统到完成的时间间隔的平均值。
系统吞吐量:单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验,使用不同的作业集合,并记录相应的性能指标数据。
操作系统实验报告作业调度
![操作系统实验报告作业调度](https://img.taocdn.com/s3/m/0ba3b76db5daa58da0116c175f0e7cd184251892.png)
操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
计算机操作系统:处理机调度模拟实验资料
![计算机操作系统:处理机调度模拟实验资料](https://img.taocdn.com/s3/m/561d8bb371fe910ef12df8a2.png)
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度,以加深了解处理机调度的工作过程。
要求:
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等,来实现处理机的调度。
根据单处理机,多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要,可选择进程数量。
当系统运行时,能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述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; //剩余时间。
操作系统实验报告作业调度
![操作系统实验报告作业调度](https://img.taocdn.com/s3/m/a597782e1fb91a37f111f18583d049649a660e46.png)
操作系统实验报告作业调度操作系统实验报告:作业调度引言:操作系统是计算机系统中最核心的软件之一,它负责管理计算机的资源,为用户提供良好的使用环境。
在操作系统中,作业调度是非常重要的一部分,它决定了计算机如何合理地分配和调度各个作业的执行顺序,以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法,将就绪队列中的作业按照一定的顺序分配给处理器,使得计算机系统能够充分利用资源,提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务(FCFS)调度算法FCFS调度算法是最简单的调度算法之一,它按照作业的到达顺序进行调度,先到达的作业先执行。
这种算法的优点是简单易实现,但是可能会导致长作业等待时间过长,造成资源浪费。
2. 最短作业优先(SJF)调度算法SJF调度算法是根据作业的执行时间来进行调度,执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间,提高系统的响应速度,但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度,优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级,但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片,每个作业在一个时间片内执行,时间片用完后,将处理器分配给下一个作业。
这种算法可以实现公平性,但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中,我们使用了不同的作业调度算法,并对其进行了性能测试。
测试结果显示,FCFS算法在平均等待时间方面表现较差,而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性,但是可能会导致长作业等待时间过长。
结论:作业调度是操作系统中的重要组成部分,合理的作业调度算法能够提高计算机系统的效率和性能。
操作系统实验---处理机调度
![操作系统实验---处理机调度](https://img.taocdn.com/s3/m/a15735d031126edb6e1a1044.png)
操作系统实验---处理机调度(总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的功能可以实现了。
操作系统实验--处理机调度算法实现
![操作系统实验--处理机调度算法实现](https://img.taocdn.com/s3/m/5d896b4e551810a6f424862e.png)
天津理工大学
计算机与通信工程学院
实验报告
2011至2012学年第二学期
课程名称操作系统
实验( 1 )实验名称处理机调度算法的实现
实验时间 2012 年 5月 5日第 1 节至第 6 节学号姓名******专业
主讲教师
辅导教师
软件环境VC++6
试验结果:1.执行结果
2. 结果分析
当程序启动时,用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。
进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
操作系统实验之处理机调度实验报告
![操作系统实验之处理机调度实验报告](https://img.taocdn.com/s3/m/e7516110763231126edb11b2.png)
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;
操作系统实验报告-作业调度
![操作系统实验报告-作业调度](https://img.taocdn.com/s3/m/c20d711cb52acfc789ebc9e2.png)
作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:作业名 A B C D E F到达时间0 2 5 5 12 15服务时间 6 50 20 10 40 82、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
三、主要算法流程图开始响应比高者优先短作业优先先来先服务算法生成调度顺序队列计算平均周转时间及平均带权周转时间结束退出系统YN四、测试数据及运行结果测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间:74.1666666667 带权周转时间:4.83333333333短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:44.8333333333带权周转时间:1.166********响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:48.1666666667带权周转时间:1.5五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])resultlist.append(li[0])list.remove(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间']listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])resultlist.append(li[-1])list.remove(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in work.items():if d.decode('gb2312')==u'作业名':ddsx.append(x)#print d.decode('gb2312')+":"+str(x) print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间'] zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*1.0/len(resultlist)))print('带权周转时间:'+str(dqzzsj*1.0/len(resultlist)))print('')shunxu(fcfs(list1),'先来先服务算法') shunxu(sjf(list2),'短作业优先算法') shunxu(hrrn(list3),'响应比高者优先算法')。
天津理工大学-操作系统实验3:磁盘调度算法的实现
![天津理工大学-操作系统实验3:磁盘调度算法的实现](https://img.taocdn.com/s3/m/d1641f7bce2f0066f433220c.png)
天津理工大学-操作系统实验3:磁盘调度算法的实现实验报告学院(系)名称:计算机与通信工程学院【实验过程记录(源程序、测试用例、测试结果及心得体会等)】#include<iostream>#include<iomanip>#include<math.h>using namespace std;const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber]; //----移动距离; int FindOrder[MaxNumber]; //-----寻好序列。
double AverageDistance; //-----平均寻道长度bool direction; //-----方向true时为向外,false为向里int BeginNum; //----开始磁道号。
int M; //----磁道数。
int N; //-----提出磁盘I/O申请的进程数int SortOrder[MaxNumber]; //----排序后的序列bool Finished[MaxNumber];void Inith(){cout<<"请输入磁道数:";cin>>M;cout<<"请输入提出磁盘I/O申请的进程数:";cin>>N;cout<<"请依次输入要访问的磁道号:";for(int i=0;i<N;i++)cin>>TrackOrder[i];for(int j=0;j<N;j++)MoveDistance[j]=0;cout<<"请输入开始磁道号:";cin>>BeginNum;for(int k=0;k<N;k++)Finished[k]=false;for(int l=0;l<N;l++)SortOrder[l]=TrackOrder[l];}//=====================排序函数,将各进程申请的磁道按从小到大排列=================void Sort(){ //------冒泡排序int temp;for(int i=N-1;i>=0;i--)for(int j=0;j<i;j++){if(SortOrder[j]>SortOrder[j+1]){temp=SortOrder[j];SortOrder[j]=SortOrder[j+1];SortOrder[j+1]=temp;}}}//============FCFS,先来先服务=================================void FCFS(){int temp;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){MoveDistance[i]=abs(TrackOrder[i]-temp);//-------计算移动磁道数temp=TrackOrder[i];//-------寻到后,将此道作为当前所在磁道号,赋给temp FindOrder[i]=TrackOrder[i];//-----寻好的赋给寻好序列}}//========SSTF,最短寻道法=============================void SSTF()int temp,n;int A=M;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){for(int j=0;j<N;j++) //-------寻找最短的寻道长度{if(abs(TrackOrder[j]-temp)<A&&Finished[j]==false) {A=abs(TrackOrder[j]-temp);n=j;}else continue;}Finished[n]=true; //-------将已经寻找到的Finished赋值为trueMoveDistance[i]=A; //-------寻道长度temp=TrackOrder[n]; //-------当前寻道A=M; //-----重置A值FindOrder[i]=TrackOrder[n]; //----寻好的赋给寻好序列}}//=====================SCAN,扫描算法==========================void SCAN(){int m,n,temp;temp=BeginNum;Sort();//------排序cout<<"请选择开始方向:1--向外;0---向里"; //------选择扫描方向cin>>m;if(m==1)direction=true;else if(m==0)direction=false;cout<<"输入错误";for(int i=0;i<N;i++){if(SortOrder[i]<BeginNum)continue;else{n=i;break;}}if(direction==true) //------选择向外{for(int i=n;i<N;i++){MoveDistance[i-n]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[i-n]=SortOrder[i];}for(int j=n-1;j>=0;j--){MoveDistance[N-1-j]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-1-j]=SortOrder[j];}}else //-------选择向里{for(int i=n-1;i>=0;i--){MoveDistance[N-i-4]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[N-i-4]=SortOrder[i];}for(int j=n;j<N;j++){MoveDistance[j]=abs(SortOrder[j]-temp);temp=TrackOrder[j];FindOrder[j]=SortOrder[j];}}}//=================CSCAN,循环扫描算法=======================void CSCAN(){int m,n,temp;temp=BeginNum;Sort();cout<<"请选择开始方向:1--向外;0---向里"; cin>>m;if(m==1)direction=true;else if(m==0)direction=false;elsecout<<"输入错误";for(int i=0;i<N;i++){if(SortOrder[i]<BeginNum)continue;else{n=i;break;}}if(direction==true){for(int i=n;i<N;i++){MoveDistance[i-n]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[i-n]=SortOrder[i];}for(int j=0;j<n;j++){MoveDistance[N-n+j]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-n+j]=SortOrder[j];}}else{for(int i=n-1;i>=0;i--){MoveDistance[n-1-i]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[n-1-i]=SortOrder[i];}for(int j=N-1;j>=n;j--){MoveDistance[N-j+n-1]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-j+n-1]=SortOrder[j];}}}//========计算平均寻道时间============== void Count(){int Total=0;for(int i=0;i<N;i++){Total+=MoveDistance[i];}AverageDistance=((double)Total)/((double)N);}void Show(){cout<<"================从"<<BeginNum<<"号磁道开始====================="<<endl;cout<<setw(20)<<"被访问的下一个磁道号"<<setw(20)<<"移动距离(磁道数)"<<endl;for(int i=0;i<N;i++){cout<<setw(15)<<FindOrder[i]<<setw(15)<<MoveDista nce[i]<<endl;}cout<<setw(20)<<"平均寻道长度:"<<AverageDistance<<endl;cout<<endl;}int main(){int y=1;int s;Inith();while(y){cout<<"请选择寻道方式:1--FCFS; 2--SSTF;3--SCAN;4--CSCSN;";cin>>s;switch(s){case 1:FCFS();Count();Show();break;case 2:SSTF();Count();Show();break;case 3:SCAN();Count();Show();break;case 4:CSCAN();Count();Show();break;}cout<<"是否继续选择寻道算法?1--是;2--否";int p;cin>>p;y=p;}return 0;}实验结果:FCFS方式:Sstf方式:SCAN方式:4.CSCSN。
操作系统实验报告作业调度
![操作系统实验报告作业调度](https://img.taocdn.com/s3/m/76d85ccdd1d233d4b14e852458fb770bf78a3bc0.png)
操作系统实验报告:作业调度1. 引言作业调度是操作系统中的一个重要概念,它涉及到如何合理地安排计算机系统中的作业执行顺序,以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法,以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法,按照一定的顺序从作业队列中选取作业,将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配,以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务(FCFS)先来先服务是最简单的作业调度算法,即按照作业提交的顺序来执行。
当一份作业到达系统后,它将被放入作业队列的末尾。
一旦当前执行的作业完成,系统将选择队列中的下一个作业来执行。
3.2 短作业优先(SJF)短作业优先算法是根据作业的执行时间来进行调度,执行时间越短的作业优先级越高。
当一个作业进入系统时,系统会检查队列中的所有作业,并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度,优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值,系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片,每个时间片的执行时间相等。
当一个作业进入系统时,系统会分配给它一个时间片,如果在时间片内作业没有完成,则将其放回队列的末尾,并执行下一个作业。
4. 实验中的应用在操作系统实验中,作业调度是一个重要的实验内容。
通过实验,我们可以深入了解不同调度算法的特点和适用场景。
实验中,我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列,然后使用不同的调度算法来执行这些作业,并记录它们的执行时间和系统的吞吐量。
通过实验,我们可以比较不同算法在不同场景下的表现,选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念,它决定了系统的性能和效率。
在本文中,我们介绍了作业调度的基本概念和常用算法,并讨论了在实验中的应用。
天津理工大学操作系统实验报告实验一
![天津理工大学操作系统实验报告实验一](https://img.taocdn.com/s3/m/8f6136426c175f0e7dd1373a.png)
实验报告学院(系)名称:计算机与通信工程学院【实验过程记录(源程序、测试用例、测试结果及心得体会等)】设计思想:1.模拟单CPU系统时间片切换、进程切换。
2.使用优先队列,让优先级高的进程位于队列顶端。
在每次时钟周期时,从优先队列队首取出优先级最高的进程,并使其运行一个时钟周期,然后将其优先级减1,已运行时间加1。
然后判断程序是否完成,如果未完成,则重新加入优先队列,参与时钟周期。
数据结构:使用优先队列,以获得优先级最高程序。
源代码:#include<cstdio>#include<queue>using namespace std;// 进程控制块PCBstruct PCB {unsigned int pid; //进程idunsigned int priority; //进程优先级unsigned int claimTime; //需要运行时间unsigned int runTime; //已经运行时间//构造函数PCB(unsigned int id, unsigned int p, unsigned int ct) { pid=id;priority=p;claimTime=ct;runTime=0;}//运行当前进程一个时钟周期,并使进程优先级减1,已运行时间加1 void run() {runTime++;if(priority>0)priority--;}//判断进程是否完成bool isFinished() {if(claimTime==runTime)return true;else return false;}//重载<运算符,以使用STL中的priority_queuebool operator <(const PCB& p)const {if(priority!=return priority<; //比较优先级else//优先级相同的话快完成的任务先执行return claimTime-runTime<}};int main(int argc, char **argv) {int clock=0;priority_queue<PCB> q; //优先队列for(int i=0; i<5; i++) {int p, t;printf("请输入pid=%u的进程的优先级(非负数):\n", i);scanf("%u", &p);printf("请输入pid=%u的进程的要求运行时间(非负数):\n", i);scanf("%u", &t);printf("pid = %u, 优先级 = %u, 要求运行时间 = %u\n\n", i, p, t);(PCB(i, p, t));}while(!()) { //模拟单CPUprintf("当前时钟%2d\t", clock++);PCB t = ();();printf("pid = %u进程运行, 优先级 = %u, 已运行时间 = %u\n", , , ;();printf("执行过后:\tpid = %u, 优先级 = %u, 已运行时间 = %u\n", , , ;if(!())(t);elseprintf("pid=%d进程结束\n", ;}printf("程序结束\n");return 0;}测试用例:执行结果:实验问题:1.在进程优先级相同时,调度结果不确定。
操作系统实验报告一处理机调度
![操作系统实验报告一处理机调度](https://img.taocdn.com/s3/m/b3b31d94a0116c175f0e4887.png)
实验课程名称:
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;//计算平均带权周转时间
}
}
二、实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)测试用例一结果:
测试用例二结果:
三、实验心得
通过本次实验进一步理解了处理机调度问题的处理算法,学习到算法适用的前提是作业提交成功。
在实验编程过程中由于对一些概念理解不清楚导致实验结果出错,但通过调整修改得出正确结果如上。
在实验过程中代码相对简介,输出界面直观整齐易于分析,但仍有缺陷待改进。
天津理工大学 操作系统实验3:磁盘调度算法的实现
![天津理工大学 操作系统实验3:磁盘调度算法的实现](https://img.taocdn.com/s3/m/3407c395964bcf84b9d57bd2.png)
实验报告学院(系)名称:计算机与通信工程学院【实验过程记录(源程序、测试用例、测试结果及心得体会等)】#include<iostream>#include<iomanip>#include<math.h>using namespace std;const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber]; //----移动距离;int FindOrder[MaxNumber]; //-----寻好序列。
double AverageDistance; //-----平均寻道长度bool direction; //-----方向 true时为向外,false为向里int BeginNum; //----开始磁道号。
int M; //----磁道数。
int N; //-----提出磁盘I/O申请的进程数int SortOrder[MaxNumber]; //----排序后的序列bool Finished[MaxNumber];void Inith(){cout<<"请输入磁道数:";cin>>M;cout<<"请输入提出磁盘I/O申请的进程数:";cin>>N;cout<<"请依次输入要访问的磁道号:";for(int i=0;i<N;i++)cin>>TrackOrder[i];for(int j=0;j<N;j++)MoveDistance[j]=0;cout<<"请输入开始磁道号:";cin>>BeginNum;for(int k=0;k<N;k++)Finished[k]=false;for(int l=0;l<N;l++)SortOrder[l]=TrackOrder[l];}//=====================排序函数,将各进程申请的磁道按从小到大排列================= void Sort(){ //------冒泡排序int temp;for(int i=N-1;i>=0;i--)for(int j=0;j<i;j++){if(SortOrder[j]>SortOrder[j+1]){temp=SortOrder[j];SortOrder[j]=SortOrder[j+1];SortOrder[j+1]=temp;}}}//============FCFS,先来先服务=================================void FCFS(){int temp;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){MoveDistance[i]=abs(TrackOrder[i]-temp); //-------计算移动磁道数temp=TrackOrder[i]; //-------寻到后,将此道作为当前所在磁道号,赋给tempFindOrder[i]=TrackOrder[i]; //-----寻好的赋给寻好序列}}//========SSTF,最短寻道法=============================void SSTF(){int temp,n;int A=M;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){for(int j=0;j<N;j++) //-------寻找最短的寻道长度{if(abs(TrackOrder[j]-temp)<A&&Finished[j]==false){A=abs(TrackOrder[j]-temp);n=j;}else continue;}Finished[n]=true; //-------将已经寻找到的Finished赋值为trueMoveDistance[i]=A; //-------寻道长度temp=TrackOrder[n]; //-------当前寻道号。
操作系统处理机调度实验报告
![操作系统处理机调度实验报告](https://img.taocdn.com/s3/m/29b4a8ca0508763231121202.png)
}
运行后结果如下:
[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
《操作系统》实验教学指导书2.1
![《操作系统》实验教学指导书2.1](https://img.taocdn.com/s3/m/1ace8b0383c4bb4cf7ecd194.png)
天津理工大学华信软件学院《操作系统》实验教学指导书2.1课程代码:课程名称:操作系统/ Operating System开课院(系)、实验室:华信软件学院C408机房适用专业:软件工程专业实验指导书名称:《操作系统实验教程(Linux版)》第七章指导教师:张一鸣实验二进程的建立与调度(2.1 进程的建立与控制)1. 实验目的(1)加深对进程概念的理解,明确进程和程序的区别。
(2)进一步理解并发的概念,明确并发与并行的异同。
(3)分析进程竞争资源现象,学习解决进程互斥的方法。
(4)了解Linux系统中进程通信的基本原理。
2. 实验内容(1)进程的创建编写一段源程序,使用系统调用fork()创建一个子进程,当此程序运行时,在系统中有一个父进程和一个子进程活动。
让每一个进程在屏幕上显示一个字符串;父进程显示字符“I am the parent”并显示其进程id和子进程的id;子进程显示字符串“I am the child”,并显示其进程id。
(2)进程的控制进程并发图,如图1所示。
设有7个进程,其执行次序如图1所示。
在Linux下使用C语言利用系统调用命令fork(),execl(),exit(),wait()进行藐视,调用execl()函数的时候,模拟调用/bin/echo下的echo命令,向控制台输出一句可鉴别是哪个进程的字符串即可。
3. 准备知识(1)阅读Linux的sched.h源文件,加深对进程管理概念的理解。
(2)阅读Linux的fork.c源文件,分析进程的创建过程。
4. 实验原理Linux是一个多用户多任务的操作系统,即在同一个时间内,可以有多个进程同时执行。
常用的单CPU单核计算机在同一个时间片内只能执行一条命令,Linux使用了一种称为“进程调度(process scheduling)”的手段来实现。
首先,为每个进程分配一定的运行时间片,该时间片通常以毫秒为单位,然后依照某种调度算法,从就绪队列中选择一个进程投入运行,其他的进程暂时等待。
处理机操作
![处理机操作](https://img.taocdn.com/s3/m/456d46d02cc58bd63186bd1f.png)
第1页 共4页
程序设计如下: 1.实验流程图:
2.实验过程设计 struct pcb { 定义进程控制块 PCB ,其中包含优先级,进程名,还需时间,已用时间的变量 void sort() 建立对进程进行优先级排列函数建立一个函数方法,使得所创建的进程能够按照 其优先级大小进行排序。 建立进程控制块函数,在这个函数里面,接受键盘对 pcb‘结构体变量的输入,调用 sort() 函数方法对每次执行时都会对优先级进行减一运算,对一用事件惊醒加一运算。, void disp(PCB * pr) 建立进程显示函数,用于显示当前进程的状态。 void check() 建立进程查看函数 。 void destroy() 建立进程撤消函数(进程运行结束,撤消进程) void running() /建立进程就绪函数(进程运行时间到,置就绪状态) void main()主函数 {定义进程数组,进程队列,并初始化 通过循环使每个进程入队 对进程按优先数从大到小排列 进程运行函数}
天津理工大学实验报告
学院(系)名称:计算机与通信工程学院 姓名 班级 张萌萌 2013 级 1 班 课程名称 实验时间 批改意见 学号 实验项目 操作系统 2015 年 11 月 16 日 第 7、8 节 20135668 专业 信息与计算科学 处理机调度算法实现 课程代码 实验地点 成绩 0667056 7 号楼 219
教师签字:
实验内容: 1.设定系统中有五个进程,每一个进程用一个进程控制块表示。 2.在每次运行处理机调度程序之前,由终端输入五个进程的“优先数”和“要求运行时间”。 3.为了调度方便,五个进程按照优先数从大到小的顺序形成就绪队列。 处理机调度总是选队首进程运行。采用动态优先数办法,进程每运行一次优先数就减“1”, 同时将运行时间减“1”。 4.进程运行一次后,若要求运行时间不等于零,则再将它加入就绪队列末尾;若要求运行时 间为零,则将其状态置为“结束”,且退出就绪队列。 5.若“就绪”状态的进程队列不为空,重复上面 4,5 步骤,直到所有进程都成为“结束”状 态。 实验目的: 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,操作系统必须按照某 种调度策略决定哪些进程优先占用 CPU。本实验是在单处理机的情况下用优先权的调度策略 实现处理机调度,以加深了解处理机调度的工作过程。 实验要求: 在设计的程序中应有输入语句,输入 5 个进程的“优先数”和“要求运行时间”,也应有显 示或打印语句,能显示或打印每次被选中调度运行进程的进程名,运行一次后队列的变化以 及结束进程的进程名。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告学院(系)名称:计算机与通信工程学院
【实验过程记录(源程序、测试用例、测试结果及心得体会等)】
处理机调度算法的实现
处理机调度算法的实现
7.设定系统中有五个进程,每一个进程用一个进程控制块表示。
8.输入每个进程的“优先数”和“要求运行时间”,
9.为了调度方便,将五个进程按给定的优先数从大到小连成就绪队列。
用一单元指出队列首进程,用指针指出队列的连接情况。
10.处理机调度总是选队首进程运行。
采用动态优先数算法,进程每运行一次优先数就减“1”,同时将运行时间减“1”。
11.若要求运行时间为零,则将其状态置为“结束”,且退出队列。
12.运行所设计程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
#include <stdio.h>
#include <stdlib.h>
struct PCB {
char name[10];
int priority,time;
struct PCB *next;
}*k;
struct LinkQueue {
PCB * front;
PCB * rear;
};
//队列初始化
LinkQueue init(){
LinkQueue Q;
PCB * p;
p=(PCB *)malloc(sizeof(PCB));
if(p) {
Q.front=Q.rear=p;
Q.front->next=NULL;
return Q;
}else{
printf("队列初始化失败,程序运行终止! \n");
exit(0);
}
}
//插入新进程,使优先数从大到小排列
LinkQueue sort(LinkQueue Q,PCB *p) {
PCB * temp1;
PCB * temp2;
if(Q.rear==Q.front) {
Q.front->next=p;
Q.rear=p;
} else {
temp1=Q.front;
temp2=temp1->next;
while(temp2->priority>=p->priority && temp2->next!=NULL) {
temp1=temp2;
temp2=temp1->next;
}
if(temp2->next==NULL && temp2->priority>=p->priority) {
temp2->next=p;
Q.rear=p;
} else {
p->next=temp1->next;
temp1->next=p;
}
}
return Q;
}
LinkQueue input(LinkQueue Q) /* 建立进程控制块函数*/
{
int i;
for(i=1;i<=5;i++)
{
printf("\n 进程号No.%d:\n",i);
k=(PCB *)malloc(sizeof(PCB));
printf("\n 输入进程名:");
scanf("%s",k->name);
printf("\n 输入进程优先数:");
scanf("%d",&k->priority);
printf("\n 输入进程运行时间:");
scanf("%d",&k->time);
printf("\n");
k->next=NULL;
Q=sort(Q,k); /* 调用sort函数*/
}
return Q;
}
LinkQueue running(LinkQueue Q) /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
if(k->time==0) {
printf("运行后进程[%s] 已完成状态为\"结束\".\n",k->name);
free(k);
}else
{
(k->priority)--;
(k->time)--;
printf("运行后优先数:%d 需要运行时间:%d\n",k->priority,k->time);
Q=sort(Q,k); /*调用sort函数*/
}
return Q;
}
void check(LinkQueue Q) /* 建立进程查看函数*/
{ PCB *pr;
pr=(PCB *)malloc(sizeof(PCB));
pr=Q.front->next;
printf("\n **** 输入的五个过程为:\n");
while(pr!=NULL) {
printf("\n 进程名:%s 状态:就绪优先数:%d 需要运行时间:%d\n",pr->name,pr->priority,pr->time); pr=pr->next;
}
}
void main()
{
int h=0;
LinkQueue P;
P=init();
P=input(P);
check(P);
while((P.front->next)!=NULL) {
h++;
k=P.front->next;
P.front->next=k->next;
k->next=NULL;
printf("\n 第%d次运行,被选中进程是:%s ",h,k->name);
P=running(P);
}
printf("\n\n 进程已经完成.\n");
}
心得体会。