实验二 处理机调度
计算机操作系统-处理机调度实验报告(精品)
中南大学实验名称:处理机调度课程名称:计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程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;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。
处理机调度实验
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、实验结果分析对每种调度算法进行多次实验,使用不同的作业集合,并记录相应的性能指标数据。
操作系统实验--处理机调度算法实现
当程序启动时,用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。
struct proc //定义进程结构体
{
char name[5];
int num;
int pri;
};
void main()//主函数
{ char ch;
struct proc pr[n];//声明结构体数组
int i,k,j;
int count=n;
for(i=0;i<n;i++)//输入5个进程
函数描述:
struct proc/*定义结构体内部包含进程的信息*/
{
char name[5]; /*定义进程名*/
int num; /*定义运行时间*/
int pri; /*定义优先权*/
};
Void main()/*主函数:掌控整个程序的运行过程,是程序的主体部分*/
struct proc pr[n];/*声明结构体数组*/
4.处理机调度总是选队首进程运行。采用动态优先数算法,进程每运行一次优先数就减“1”,同时将运行时间减“1”。
5.若要求运行时间为零,则将其状态置为“结束”,且退出队列。
6.运行所设计程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程
实验过程与实验结果(可包括实验实施的步骤、算法描述、流程、结论等)
for(k=1;k<n;k++)
实验二--单处理器系统的进程调度
实验二–单处理器系统的进程调度
简介
在操作系统中,进程调度是非常重要的一项工作。
进程调度负责将CPU分配
给各个进程,使得每个进程都能够有机会占用CPU资源。
在单处理器系统中,CPU只有一个,因此进程调度是非常重要的。
本次实验将会探究单处理器系统的进程调度,了解各种进程调度算法的实现和
比较,利用模拟操作系统的实验平台进行实验。
实验目的
1.了解进程调度的基本概念和实现方法;
2.学习多种进程调度算法,并比较其优缺点;
3.熟悉模拟操作系统的实验环境,学习如何将算法实现到具体的系统中。
实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。
在单处理器系统中,当有
多个进程需要使用CPU时,操作系统需要进行进程调度,使得每个进程都能够得
到CPU资源。
在进程调度中,需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。
根据不同的调度算法,可以根据这些因素来确定哪个进程应该先占用CPU。
进程调度算法比较
常见的进程调度算法包括:
1.先来先服务算法(FCFS)
2.短作业优先算法(SJF)
3.优先级调度算法
4.时间片轮转算法(RR)
下面将对这些算法进行比较和介绍。
先来先服务算法(FCFS)
先来先服务算法是最简单的一种进程调度算法。
该算法将按照进程的到达时间
的先后顺序进行调度,先到达的进程先得到CPU资源。
这种算法的优点是实现简单,适用于短作业和计算密集型进程。
缺点是无法充分利用CPU资源,导致长作业需要等待较长时间才能被调度,容易产生。
操作系统实验(处理机调度)
实验报告学院(系)名称:计算机与通信工程学院
【实验过程记录(源程序、测试用例、测试结果及心得体会等)】
一、实验效果:
1)打开主界面
2)初始化线程的时间和优先级,设置各个进程的时间和优先级。
3) 开始运行模拟线程。
绿色代表当前正在运行的线程。
二、实验代码
1)本实验使用Java的Swing绘制GUI,能够简单便捷的观察到处理机是如何根据时间和优先级来调度进程的。
代码结构:Swing绘制GUI:
2)Java ,Swing优点:
使用Swing的Jtable,JTabbedPane,能清楚的观察某一时刻各个进程的状态,以及正在运行哪个进程
3)模拟进程的数据结构:
自定义一个类ThreadBean,通过这种数据结构来代表进程。
这个类中有id,time(时间), property(优先级)的属性
4) 进程调度算法:
一、编写了一个SortList类,来完成调度算法
二、每一次通过遍历每个进程,找出优先级以及时间最多的进程,准备被处理机调度。
三、处理机调度后,这个线程的时间以及优先级减1
5)细节的处理
一、果没有进行初始设置进程的优先级和时间就点击了运行,会弹出提示框,不允许运行。
二、数据过滤,输入时间,优先级时只能填写整数,如果不是整数会进行过滤,提示。
三、扩展性
程序各个部分已经模块化,可以直接进行扩展。
通过选择不同的标签来显示几个不同的实验,完成三个实验均可以同时显示,不影响程序性能。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念,它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验,探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法,比较它们在不同负载下的性能表现,进而分析其优缺点,为实际操作系统的调度算法选择提供参考。
三、实验方法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算法将处理机的运行时间划分为若干个时间片,每个任务在一个时间片内执行一定的时间,然后切换到下一个任务。
实验二 进程调度实验
实验二进程调度实验(2学时)一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
二、实验内容:任务:设计一个有N个进程并行的进程调度程序进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和同优先级条件下先来先服务算法。
每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
调度算法的流程图2如下:图2调度算法的流程图三、实验步骤(1) 打开VC,选择菜单项file->new,选择projects选项卡并建立一个名为" ry2"的win32 console applicatoin工程;创建时注意指定创建该工程的目录;(2) 在工程中创建源文件" ry2.cpp":选择菜单项project->add to project->files,在选择框中输入自己想要创建的文件名,这里是" ry2.cpp";在接下来询问是否创建新文件时回答"yes";然后通过Workspace->FileView->Source Files打开该文件,在其中编辑源文件并保存.(3) 通过调用菜单命令项build->build all进行编译连接,可以在指定的工程目录下得到debug-> sy2.exe程序,运行sy2.exe。
计算机操作系统:处理机调度模拟实验资料
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度,以加深了解处理机调度的工作过程。
要求:
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等,来实现处理机的调度。
根据单处理机,多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要,可选择进程数量。
当系统运行时,能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述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; //剩余时间。
操作系统实验---处理机调度
操作系统实验---处理机调度(总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)处理机调度的算法有哪些,各自的优缺点是什么?①先来先服务算法:有利于长作业(进程),不利于短作业(进程);②短作业优先调度算法:有利于短作业(短进程),不利于长作业(长进程);③高优先权调度算法:静态缺点:可能导致低优先权进程长期得不到调度甚至饿死;动态:优先权随进程等待时间增加或执行而变④高响应比优先调度算法⑤基于时间片轮转调度算法:时间片太小,会频繁发生中断,系统开销增大时间片太大,响应进程慢。
⑥多级反馈队列调度算法:具有较好的性能,能很好满足各类型用户的需求。
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) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。
指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态,“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程,用指针指出队列的连接情况。
例:队首标志K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法,进程每运行一次优先数就减“1”。
由于本实习是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后,若要求运行时间 0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改成“结束”(E),且退出队列。
操作系统实验二实验报告
实验二处理机管理(4学时)实验目的正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏,在操作系统中调度的实质是一种资源分配,调度算法是指根据系统的资源分配策略规定的资源分配算法,对不同的系统和系统目标,应采用不的调度算法。
(或)在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。
也就是说能运行的进程数远远大于处理机个数。
为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择一进程占用处理机。
通过本实验,加深对处理机调度的理解。
实验内容处理机管理是操作系统中非常重要的部分。
为深入理解进程管理部分的功能,设计几个调度算法,模拟实现处理机的调度。
编程模拟FCFS调度算法、SJ(P)F算法、高优先权调度算法、基于时间片轮转调度算法。
注:“基于时间片轮转调度算法模拟”为必作,其余选做。
实验准备及实验设备计算机,Tc2.0实验步骤正确理解各调度算法的基本思想;根据各调度算法定义PCB(模拟)的格式:FCFS算法和基于时间片轮转调度算法,可设PCB的格式为:高优先权调度算法可设PC为:在正确理解各调度算的基础上编写出相应的程序。
在所设计的调度程序中,针对不同算法应包含显示和打印语句,以便显示或打印程序运行的初值和运行结果:各PCB的初始状态,选中运行进程的名称、运行后各PCB状态以及每次调度时,就绪队列的进程排列顺序(针对不同算法有所不同)。
(源程序)实验结果(运行所编的模拟调度程序,所得结果略)FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。
SJ(P)F算法不利于长作业(进程),该算法未考虑作业的紧迫程序,因而不能保证紧迫性作业(进程)会被及时处理,并且由于作业(进程)的长短是用户所提供的估计执行时间而定的,致使该算法不一定能真正做到短作业优先调度。
高优先权(分动态和静态优先权)调度算法即照顾了短作业,又考虑了作业到达的紧迫性。
对于静态优先权法,系统开销小,但不够精确,可能出现优先权低的作业(进程)长期没有被调度的情况;对于动态优先权(高响应比优先)法,它既照顾了短作业,又考虑了作业的先后次序,不会使长作业长期得不到服务,但每要进行调度之前,都须做响应比的计算,会增加系统开销。
处理机调度与死锁实验报告
探索处理机调度与死锁的实验本次实验主要针对处理机调度与死锁展开,旨在让学生深入理解操作系统中的重要概念,掌握具体的解决方案。
一、实验目的
1. 探究操作系统中的处理机调度算法并了解其原理。
2. 了解死锁概念及其分类,并学习有关死锁预防和避免的方法。
二、实验内容
1. 处理机调度实验
在实验中,我们学习了几种不同的处理机调度算法:先来先服务(FCFS)、短作业优先(SJF)、优先级调度(PS)、时间片轮转调度(RR)等。
通过模拟不同进程的到达和运行,学生们了解每个算法的特点和缺点,并分析在不同场景下使用算法的合理性。
2. 死锁实验
在死锁实验中,学生们学习了死锁的原理和分类。
为了更好地理解死锁的产生,我们首先逐步增加资源请求数量来模拟进程的资源竞争。
在后面的实验中,我们使用了银行家算法和资源分配图等工具来预防和避免死锁。
三、实验结果
在本次实验中,学生们深入理解了处理机调度的相关概念,并通过实践提高了分析和解决问题的能力。
同时,学生们也掌握了死锁的原理和可能出现的场景,并学会了如何通过预防和避免的方法解决这些问题。
总之,本次实验是一次极为成功的尝试,也是学生们加深对操作系统理论知识的关键步骤。
通过深入探究实验中的内容,可以帮助学生更好地理解和掌握操作系统相关知识,并为今后在实际工作中提供指导和支持。
操作系统处理机调度实验报告
}
运行后结果如下:
[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
实验二 进程调度 实验报告
(5)当所有进程运行完毕后,进程结束;否则,跳转步骤4,直至进程运行完毕。
新计算各进程的响应比,重复该过程,状态为“结束”的进程退出等待服
务队列,直到所有进程处于“结束”状态。
三、主要器材设备和原料
1.PC微机。
2.Windows操作系统。
3.C语言开发集成环境。
四、实验过程和步骤
问题一
1.本实验具体要求
通过时间片轮转法实现进程调度问题。进程按FCFS策略排成一个就绪的循环队列,把CPU分配给队首进程,令其执行一个时间片,当其运行完毕后,把处理机分配给就绪队列中断的队首进程,让其执行一个时间片,循环直到所有进程状态为“结束”。打印每轮运行一次后进程队列的变化及各进程的参数。
3.流程图
问题二
1.本实验具体要求
通过动态响应比实现进程调度问题。每轮运行时都要计算每个进程的响应比,将进程按响应比从大到小排序,响应比大的进程优先得到服务。打印每次运行一次后进程队列的变化及各进程的参数。
2.程序实现步骤
(1)任意输入进程数、进程名、 等待时间、要求运行时间以及进程状态,初始状态都为“就绪”,用“R”表示。当一个进程运行结束后,它的状态“结束”,用“E”表示。
实验目的如下:
1.利用高级语言模拟进程的时间片轮转调度算法,并熟练掌握。
2.利用高级语言模拟进程的响应比高者优先调度算法,并熟练掌握。
二、实验原理
1.问题一
针对系统的所有进程,首先确定所有进程的要求运行时间(已运行时间初始值为0);将所有进程按顺序排成循环队列,用指针指出队列连接情况,同时另用一个标志单元记录轮到运行的进程,此时以轮转法进行调度;先将CPU分配给队首进程,并令其执行一个时间片,当它运行完毕后,将CPU分配给就绪队列中新的队首进程,让其执行一个时间片,进程每被调度一次,该进程已运行时间+1,同时,判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间已运行时间,则表示它尚未执行结束,应待到下一轮时再运行,若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”,并退出队列。此时,把该进程的进程控制块中的指针值送到前面一个进程的指针位置,直到所有的进程都成为“结束”状态。
操作系统实验二进程调度
操作系统实验二进程调度摘要:进程调度是操作系统中重要的功能之一,可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能,用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行,而处理器资源有限,因此需要通过进程调度来合理地安排进程的执行顺序,提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务(FCFS)先来先服务(FCFS)是最简单的调度算法,按照进程到达的顺序进行调度,先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间,容易导致平均等待时间长。
2.最短作业优先(SJF)最短作业优先(SJF)调度算法按照进程所需的CPU时间进行排序,优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间,但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略,将处理器的使用权分割为若干个时间片,每个进程在一个时间片内运行,如果时间片用完仍未运行完,则将该进程放到队列的末尾,并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间,但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度,优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定,不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构:定义进程结构体,包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列:将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法:根据不同的调度算法,实现相应的进程调度算法代码。
可以使用循环遍历进程队列,并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度:在每个时间片结束后,根据调度算法选取下一个要执行的进程,并更新进程的状态和执行时间。
实验二处理机调度
实验二动态高优先权优先调度实验内容:模拟实现动态高优先权优先(若数值越大优先权越高,每运行一个时间单位优先权-n,若数值越小优先权越高,没运行一个时间单位优先权+n),具体如下:设置作业体:作业名,作业的到达时间,服务时间,初始优先权,作业状态(W——等待,R ——运行,F——完成),作业间的链接指针作业初始化:由用户输入作业名、服务时间、初始优先权进行初始化,同时,初始化作业的状态为W。
显示函数:在作业调度前、调度中和调度后进行显示。
排序函数:对就绪状态的作业按照优先权排序。
优先权相同时进入等待队列时间早的作业在前。
注意考虑到达时间调度函数:每次从等待队列队首调度优先权最高的作业执行,状态变化。
并在执行一个时间单位后优先权变化,服务时间变化,状态变化。
当服务时间为0时,状态变为F。
删除函数:撤销状态为F的作业。
实验要求:1、测试数据可以随即输入或从文件中读入。
2、必须要考虑到作业的到达时间3、最终能够计算每一个作业的周转时间。
实验三时间片轮转调度算法模拟实现时间片轮转调度算法,具体如下:设置进程体:进程名,进程的到达时间,服务时间,,进程状态(W——等待,R——运行,F ——完成),进程间的链接指针进程初始化:由用户输入进程名、服务时间进行初始化,同时,初始化进程的状态为W。
显示函数:在进程调度前、调度中和调度后进行显示。
排序函数:对就绪状态的进程按照进入就绪队列的时间排序,新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。
注意考虑到达时间调度函数:每次从就绪队列队首调度优一个进程执行,状态变化。
并在执行一个时间片后化,服务时间变化,状态变化。
当服务时间为0时,状态变为F。
删除函数:撤销状态为F的进行。
实验要求:1、测试数据可以随即输入或从文件中读入。
2、必须要考虑到进程的到达时间3、最终能够计算每一个进程的周转时间的带权周转时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二处理机调度一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,为了使系统中的各进程有条不紊地运行,必须选择某种调度策略,以选择一个进程占用处理机。
本次实验设计一个模拟单处理机调度的算法,以加深处理机调度的算法的理解。
二、实验要求1.按照轮转(时间片)算法设计模拟调度程序。
2.输出进程的调度过程。
三、思路分析由于本实验是按照处理机调度算法模拟实现处理机的调度,与真正的处理机调度过程不完全相同,如没有实现中断,进程的运行也不是真正的运行,而是在屏幕上打印其运行时间等。
以下是实验的大致思路:(1)建立三个队列:PCB队列,就绪队列,完成队列。
PCB队列:保存将进入系统的进程。
(由于没有实现中断,所以将进入系统运行的进程必须在程序运行前给出)。
就绪队列:到达进程进入系统的时间,将该进程放入就绪队列,等待调度。
完成队列:将“运行”完的进程放入完成队列。
(2)进程运行过程是在屏幕上打印相关信息。
使用轮转算法调度的进程应打印的信息包括:进程占用处理机序列,该进程每次占用处理机的开始时间与结束时间。
可参考下图:(3)统计出进程的周转时间T和带权周转时间W。
四、流程图五、实验内容编写程序实现轮转算法的模拟调度程序。
(可参考FCFS算法的模拟调度程序。
//************************************************************************ ******////* 实验二处理机调度*////************************************************************************ ******//#include<stdio.h>#include<string.h>#include<iostream.h>#include<malloc.h>#define slice_time 10 //定义时间片的长度为10//定义进程控制块PCBstruct pcb{int id; //进程号int status; //进程状态0-Ready, 1-Run, 2-Finish int arrive_time; //进程到达时间int time; //估计运行时间int run_time; //已运行时间int wait_time; //等待时间int priority; //优先级struct pcb* next; //链接指针};#define length sizeof(struct pcb)int cur_time=0; //系统当前运行时间int num=0; //进程的个数struct pcb *ready_head=NULL;struct pcb *pcb_head=NULL;struct pcb *finish_head=NULL;/*读文件数据,将文件中给出的进程放入PCB队列,以便后续使用返回值:0-失败1-成功*/int readData(){FILE *fp;char fname[20];cout<<"注意:文件中应包含以下信息:\n";cout<<"进程ID 到达时间估计运行时间优先级\n";cout<<"并且应按到达时间顺序排列!\n\n";cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL)cout<<"错误,文件打不开,请检查文件名"<<endl;return 0;}else{//建立PCB链表struct pcb *p1, *p2;pcb_head=NULL;p1=p2=(struct pcb*)malloc(length);fscanf(fp,"%d %d %d %d",&p1->id,&p1->arrive_time,&p1->time,&p1->priority);p1->status=0; p1->run_time=0; p1->wait_time=0; //初始化while(!feof(fp)){num++;if(num==1){pcb_head=p1;p1->next=NULL;}elsep2->next=p1;p2=p1;p1=(struct pcb*)malloc(length);fscanf(fp,"%d %d %d %d",&p1->id,&p1->arrive_time,&p1->time,&p1->priority);p1->status=0; p1->run_time=0; p1->wait_time=0;}p2->next=NULL;free(p1);fclose(fp);return 1;}}//建立就绪队列(前提:PCB队列是按到达时间排序的)//返回值:0-就绪队列空1-就绪队列不空int readyProcess(){struct pcb *p1, *pready;p1=pcb_head;pready=ready_head;//将pready指向就绪队列最后一个结点if(pready){while(pready->next){pready=pready->next;}}/*将新到达进程插入就绪队列末尾*/while(p1){if(p1->arrive_time<=cur_time){if(pready){pready->next=p1;}if(ready_head==NULL){ready_head=p1;}pready=p1;p1=p1->next;pready->next=NULL;}else{pcb_head=p1; //确定新的PCB队列头if(ready_head){return 1; //就绪队列中有元素}else{return 0;}}}if(p1==NULL) //已经处理完PCB队列中的结点,将pcb队列头赋NULL {pcb_head=NULL;}if(ready_head){return 1; //就绪队列中有元素}else{return 0;}}/*轮转算法中时间片用完的进程插入就绪队列的末尾*///参数:p-插入的进程void insertReadyQueueByRR(struct pcb* p){struct pcb *pready;readyProcess(); //若有新进程进入系统,先将其放入就绪队列if(ready_head==NULL){ready_head=p;return;}pready=ready_head;//将pready指向就绪队列最后一个结点while(pready->next)pready=pready->next;pready->next=p;p->next=NULL;}//按先进先出的方法从就绪队列中取出一个就绪进程//返回值p-从队列中取出的进程0-就绪队列空,无进程取出pcb* getReadyProcessByFIFO(){struct pcb * p;if(ready_head){p=ready_head;ready_head=ready_head->next;return p;}elsereturn 0;}//按先来先服务算法模拟调度过程void runProcessByFCFS(){struct pcb *p, *pFinish=NULL;int t=0,t_sum=0;float w=0.0, w_sum=0.0;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<en dl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间周转时间带权周转时间"<<endl;ready_head=NULL;while(pcb_head||ready_head) //当系统中还有未“运行”完的进程,则循环{while(1) //一直循环,直到有进程进入系统,能从就绪队列中取出进程{if(readyProcess()){p=getReadyProcessByFIFO();break;}elsecur_time++;}p->status=1;cout<<p->id<<"\t\t"<<cur_time-p->arrive_time<<"\t\t"; //“运行”cur_time+=p->time; //修改系统当前“运行”时间//统计数据t=cur_time-p->arrive_time;t_sum+=t;cout<<t<<"\t\t";w=(float)t/p->time;w_sum+=w;cout<<w<<endl;p->status=2; //“运行”完if(finish_head==NULL) //“运行”完的进程加入完成队列finish_head=pFinish=p;elsepFinish->next=p;}p->next=NULL;cout<<"平均周转时间为:"<<(float)t_sum/num<<"\t"<<"平均带权周转时间为:"<<(float)w_sum/num<<endl;}//时间片轮转算法void runProcessByRR(){struct pcb *p, *pFinish=NULL;int t=0,t_sum=0;float w=0.0, w_sum=0.0;//输出RR算法执行流cout<<endl<<"*****************************************************"<<en dl;cout<<"RR算法执行流:"<<endl; cout<<"进程名本次开始时间本次结束时间周转时间带权周转时间"<<endl;ready_head=NULL;while(pcb_head||ready_head){while(1){if(readyProcess()){p=getReadyProcessByFIFO();break;}elsecur_time++;}p->status=1;cout<<p->id<<"\t\t"<<cur_time<<"\t\t";if(p->time-p->run_time>slice_time) //判断本次时间片用完,该进程是否能“运行”完{ //未“运行”完,插入就绪队列cur_time+=slice_time;p->run_time+=slice_time;cout<<cur_time<<endl;p->status=0;insertReadyQueueByRR(p);}else{ //“运行”完,插入完成队列cur_time=cur_time+p->time-p->run_time;cout<<cur_time<<"\t";//统计数据t=cur_time-p->arrive_time;t_sum+=t;cout<<t<<"\t\t";w=(float)t/p->time;w_sum+=w;cout<<w<<endl;p->status=2;if(finish_head==NULL)finish_head=pFinish=p;elsepFinish->next=p;p->next=NULL;}}cout<<"平均周转时间为:"<<(float)t_sum/num<<"\t"<<"平均带权周转时间为:"<<(float)w_sum/num<<endl;}void main(){if(readData())//runProcessByFCFS();runProcessByRR();}。