搜档网
当前位置:搜档网 › 进程调度算法实验报告

进程调度算法实验报告

进程调度算法实验报告
进程调度算法实验报告

操作系统实验报告(二)

实验题目:进程调度算法

实验环境:C++

实验目的:编程模拟实现几种常见的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较

各种算法的性能优劣。

实验内容:编程实现如下算法:

1.先来先服务算法;

2.短进程优先算法;

3.时间片轮转调度算法。

设计分析:

程序流程图:

1.先来先服务算法

开始

初始化PCB,输入进程信息

各进程按先来先到的顺序进入就绪队列

结束

就绪队列?

运行

运行进程所需CPU时间

取消该进程

2.短进程优先算法

3.时间片轮转调度算法

实验代码:

1.先来先服务算法

#include

#define n 20

typedef struct

{

int id; //进程名

int atime; //进程到达时间

int runtime; //进程运行时间

}fcs;

void main()

{

int amount,i,j,diao,huan;

fcs f[n];

cout<<"请输入进程个数:"<

cin>>amount;

for(i=0;i

{

cout<<"请输入进程名,进程到达时间,进程运行时间:"<>f[i].id;

cin>>f[i].atime;

cin>>f[i].runtime;

}

for(i=0;i

{ //如果两个进程同时到达,按在屏幕先输入的先运行for(j=0;j

{ if(f[j].atime>f[j+1].atime)

{diao=f[j].atime;

f[j].atime=f[j+1].atime;

f[j+1].atime=diao;

huan=f[j].id;

f[j].id=f[j+1].id;

f[j+1].id=huan;

}

}

}

for(i=0;i

{

cout<<"进程:"<

<

f[i+1].atime=f[i].atime+f[i].runtime;

}

}

2.短进程优先算法

#include

#define n 5

#define num 5

#define max 65535

typedef struct pro

{ int PRO_ID;

int arrive_time;

int sum_time;

int flag;

}Pro;//整数排序

int bubble(int temp[])

{

int i,j,tem=0;

for(i=1;i

{ int lastX=1;

for(j=0;j

{ if(temp[j]>temp[j+1])

{ tem=temp[j];

temp[j]=temp[j+1];

temp[j+1]=tem;

lastX=0;

}

}

if(lastX==1) break;

}

return temp[0];

}

//进程排序

Pro bubble(Pro p[])

{

int i,j;

Pro temp={0};

Pro s[num];

for(i=0;i

{ s[i]=p[i];

}

for(i=1;i

{

int lastX=1;

for(j=0;j

{

if(s[j].sum_time>s[j+1].sum_time)

{

temp=s[j];

s[j]=s[j+1];

s[j+1]=temp;

lastX=0;

}

}

if(lastX==1) break;

}

return s[0];

}

void SPF(int p)

{

if(n>0)

{

int i,j,k,l,tc=0;

Pro seq[n];

Pro temp_seq[n];

printf("短进程优先调度算法SPF\n");

printf("请依次输入5个进程的进程号、到达时间和执行时间\n");

printf("成员变量用逗号隔开;进程间用回车隔开\n");

for(i=0;i

scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);

}

printf("调度顺序是:\n");

//初始化tc

int temp[num];

for(i=0;i

{

temp[i]=seq[i].arrive_time;

}

tc=bubble(temp);//tc是断点啊

//flag 表示对应i的pro的队列情况

//-1表示未进入过队列,0表示在队列中,1表示被清除了

for(i=0;i

seq[i].flag=-1;

}

for(i=0;i

for(j=0;j

if(seq[j].flag!=1&&seq[j].arrive_time<=tc){

seq[j].flag=0;

}

}

for(j=0;j

temp_seq[j]=seq[j];

if(seq[j].flag!=0){

temp_seq[j].sum_time=max;

}

}

l=bubble(temp_seq).PRO_ID;

for(j=0;j

if(l==seq[j].PRO_ID){

k=j;

}

}

tc=tc+bubble(temp_seq).sum_time;

seq[k].flag=1;

printf("%d",l);

}

printf("\n");

}

}

void main()

{

SPF(n);

}

3.时间片轮转调度算法

头文件RR.h

#include

#include

#include

#include

#include

#define MaxNum 100

typedef struct pcb //定义进程控制块

{

char Name[MaxNum]; //进程名

int arrivetime; //到达时间

int runtime; //运行时间

int wholetime; //固定运行时间

int FinishTime; //完成时间

double WeightTime; //周转时间

double WeightWholeTime; //带权周转时间

char state; //运行后的状态

struct pcb *next;

}PCB;

//全局变量

int N; //实际进程数

double SumWT; //周转时间之和

double SumWWT; //带权周转时间之和

double AverageWT; //平均周转时间

double AverageWWT; //平均带权周转时间

typedef struct //定义队列,封装头结点,指针分别指向队头和队尾{

PCB *front,*rear;

}queue;

queue *init() //进程队列置空

{

queue *head;

head=(queue*)malloc(sizeof(queue));

head->front=NULL;

head->rear=NULL;

return head;

}

int empty(queue *head) //检验队列是否为空

{

return (head->front?0:1);

}

queue *append(queue *head,char c[MaxNum],int a,int r,char s) //进程队列入队,往后插入{

PCB *p;

p=(PCB *)malloc(sizeof(PCB));

strcpy(p->Name,c);

p->arrivetime=a;

p->runtime=r;

p->wholetime=r;

p->state=s;

//p->FinishTime=0;

//p->WeightTime=0;

//p->WeightWholeTime=0;

p->next=NULL;

if(empty(head))

head->front=head->rear=p;

else

{

head->rear->next=p;

head->rear=p;

}

return head;

}

queue *creat(queue *head) //创建进程队列

{

char c[MaxNum];

char s='R';

int a,r,i;

printf("请输入共有几个进程:\n");

scanf("%d",&N);

for(i=1;i<=N;i++)

{

printf("请输入第%d 个进程的进程名:\n",i);

getchar();

gets(c);

printf("请输入第%d 个进程的到达时间:\n",i);

scanf("%d",&a);

printf("请输入第%d 个进程的服务时间:\n",i);

scanf("%d",&r);

head=append(head,c,a,r,s);

}

return head;

}

void print(queue *head) //输入创建的进程队列

{

PCB *p;

p=head->front;

if(!p)

printf("时间片轮转调度队列为空!\n");

while(p)

{

printf("Name=%s arrivetime=%d runtime=%d state=%c",p->Name,p->arrivetime,p->runtime,p->state);

printf("\n");

p=p->next;

}

}

/*******************时间片轮转法调度算法的实现**************************/

void RR(queue *head,int q)

{

int t=head->front->arrivetime, lt=head->rear->arrivetime;

if(head->front->runtime

t=t+head->front->runtime;

else

t=t+q;

/****进程队列为不空才可调度*****/

while(!empty(head))

{

PCB *p1,*p2;

printf("\n时刻进程运行后的状态\n");

/*第一种情况:当前运行的时间小于最后一个进程到达时间做一下操作*/

while(t

{

p1=head->front;

printf("%2d %s",t,p1->Name);

p1->runtime=p1->runtime-q;

//1.运行时间小于0,删除队首

if(p1->runtime<=0)

{

p1->state='C';

printf(" %c\n",p1->state);

p1->FinishTime=t;

p1->WeightTime=p1->FinishTime-p1->arrivetime;

p1->WeightWholeTime=p1->WeightTime/p1->wholetime;

SumWT+=p1->WeightTime;

SumWWT+=p1->WeightWholeTime;

printf("时刻%2d进程%s运行结束,进程%s周转时间=%5.2f,带权周转时间=%5.2f\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);

head->front=p1->next;

free(p1);

}

//2.运行时间大于0,向后找位置插入

else

{

printf(" %c\n",p1->state);

p2=p1->next;

while(p2->next && p2->arrivetime != t)

{

p2=p2->next;

}

//此时无新进入队列的进程,有两种情况:1.不用找位置往后插入,队首不变,不做操作

//2.找位置往后插入

if(p2->arrivetime != t)

{

PCB *p3=p1,*p4;

while(p3->next && p3->arrivetime

{

p4=p3;

p3=p3->next;

}

if(p3->arrivetime>t)

{

if(p4!=p1) //p1插在p4后,头为p1->next

{

head->front=p1->next;

p1->next=p4->next;

p4->next=p1;

}

else //不做操作

p4=p3=p2=NULL;

}

else

p4=p3=p2=NULL;

}

//此时有新进入队列的进程时:p1插在新进入队列的进程p2后,队首为p1->next

else

{

head->front=p1->next;

p1->next=p2->next;

p2->next=p1;

}

}

//时刻变化

if(head->front->runtime

t=t+head->front->runtime;

else

t=t+q;

}

/*************第一种情况结束**************/

/******************第二种情况:当期运行的时间大于最后一个进程到达的时间做以下操作*********************/

while(t>=lt)

{

p1=head->front;

printf("%2d %s",t,p1->Name);

p1->runtime=p1->runtime-q;

//1.运行时间小于0,删除队首

if(p1->runtime<=0)

{

p1->state='C';

printf(" %c\n",p1->state);

p1->FinishTime=t;

p1->WeightTime=p1->FinishTime-p1->arrivetime;

p1->WeightWholeTime=p1->WeightTime/p1->wholetime;

SumWT+=p1->WeightTime;

SumWWT+=p1->WeightWholeTime;

printf("时刻%2d进程%s运行结束,进程%s周转时间=%5.2f,带权周转时间=%5.2f\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);

//printf("时刻%2d进程%s运行结束",t,p1->pname);

head->front=p1->next;

free(p1);

}

//2.运行时间大于0,直接插在队尾

else

{

printf(" %c\n",p1->state);

//若原队列只有一个进程,不必往队尾插

if(!p1->next)

head->front=p1;

//若原队列有多个进程

else

{

head->front=p1->next;

head->rear->next=p1;

head->rear=p1;

p1->next=NULL;

}

}

//时刻变化,队列为空时不做时刻变化

if(empty(head))

return;

else

{

if(head->front->runtime

t=t+head->front->runtime;

else

t=t+q;

}

}

/*******第二种情况结束*********/

}

}

主程序Main.cpp

#include

#include

#include

#include

#include

#include "RR.h"

void main()

{

queue *head;

int q;

head=init();

head=creat(head);

printf("\n您输入的时间片轮转进程队列为:\n");

print(head);

printf("\n请输入时间片轮转调度的时间片为:");

scanf("%d",&q);

//时间片轮转调度

RR(head,q);

AverageWT=SumWT/N;

AverageWWT=SumWWT/N;

printf("平均周转时间=%5.2f,平均带权周转时间=%5.2f",AverageWT,AverageWWT); }

运行结果:

先来先服务:

短进程:

时间片轮:

心得体会:

这次的实验与上次的实验相比,在很多方面都有更多的难度,所以我们参考了别人很多的程序然后稍作了修改。但是由于自身知识不够,所以没能将三个算法都弄到一个大程序中,只能通过三个程序来实现,这一点是我们的不足。虽然如此,我们还是有了一定的收获,比如更加深刻了解到了先来先服务、短进程、时间片轮这三种作业的原理,而且这一过程中我们觉得时间片轮调度算法更具优势。

实验二--单处理器系统的进程调度

实验二单处理器系统的进程调度 (附实验报告) 1.实验目的 加深对进程概念的理解,明确进程和程序的区别; 深入了解系统如何组织进程、创建进程; 进一步认识如何实现处理器调度。 2.实验预备知识 进程的概念; 进程的组织方式; 进程的创建; 进程的调度。 3.实验内容

编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所作工作进程测试。 4.提示与讲解 这个实验主要要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。 考虑如何组织进程,首先就要设定进程控制块的内容。进程控制块PCB 记录各个进程执行时的情况。不同的操作系统,进程控制块记录的信息内容不一样。操作系统功能越强,软件也越庞大,进程控制块记录的内容也就越多。这里的实验只使用了必不可少的信息。一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类: ①标识信息 每个进程都要有一个惟一的标识符,用来标识进程的存在和区别于其他进程。这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。在后面给出的参考程序中,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。 ②说明信息

用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。 ③现场信息 现场信息记录各个寄存器的内容。当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字寄存器等。在实验中,可选取几个寄存器作为代表。用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。 ④管理信息 管理信息记录进程管理和调度的信息。例如进程优先数、进程队列指针等。实验中,仅包括队列指针。 因此可将进程控制块结构定义如下: struct pcb {int name; int status;

操作系统实验报告--实验一--进程管理

实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同,PCB结构的内容可以作适当的增删)。为了便于处理,程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类,每类数目为r1…r w。随机产生n进程P i(id,s(j,k),t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间,在运行过程中,会随机申请新的资源。 3、每个进程可有三个状态(即就绪状态W、运行状态R、等待或阻塞状态B),并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法:时间片轮转调度算法 本程序用该算法对n个进程进行调度,进程每执行一次,CPU时间片数加1,进程还需要的时间片数减1。在调度算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了1个单位),这时,CPU时间片数加1,进程还需要的时间片数减1,并排列到就绪队列的尾上。 三、实验环境 操作系统环境:Windows系统。 编程语言:C#。 四、实验思路和设计 1、程序流程图

2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态,W(等待)、R(运行)、B(阻塞) //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数,n为初始化进程个数 //r为可随机产生的进程数(r=m-n) //a,b,c分别为A,B,C三类资源的总量 //i为进城计数,i=1…n //h为运行的时间片次数,time1Inteval为时间片大小(毫秒) //对进程进行初始化,建立就绪数组、阻塞数组。 public void input()//对进程进行初始化,建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;

随机进程调度算法

《操作系统原理》实验报告 实验名称:Linux随机进程调度算法实现 班级: 学号: 姓名: 日期: 2012/12/31

一、实验名称 Linux随机进程调度算法实现 二、所属课程名称 《操作系统原理》 三、实验原理 linux 0.11内核目录linux/kernel中的sched.c函数是内核中进程调度管理的程序,其中schedule()函数负责选择系统中下一个要运行的进程。 schedule()函数首先对所有任务(进程)进行检测,唤醒任何一个已经得到信号的进程。具体方法是任务数组中的每个进程,检查其报警定时值alarm。如果进程的alarm时间已经过期(alarm

NR_TASKS:系统能容纳的最大进程数(64个); task[]:任务(进程)数组; 更改代码如下:(linux 0.11内核目录下linux/kernel/sched.c 源文件的scheduling()函数while(1)循环)while (1) { //定义c用来判断系统中是否可运行的任务(进程)存在; c=-1; //c初值设为-1,默认不存在可运行进程; next = 0;//next记录下一个即将运行的进程; i=jiffies % NR_TASKS+1; //i的值是随机产生的; p=&task[i];//p指向在task表中下标为i的进程; while (--i) { //遍历task[]; if(!*--p)continue; //如果task[i]不包含进程,跳过; //如果task[i]包含进程且该进程处于就绪状态,记录 //该任务(进程)序号,跳出无限循环while(1),转向 //switch_to()函数执行该任务(进程); if ((*p)->state == TASK_RUNNING) { next = i; c=i; break; } } if (c) break;//如果没有任何任务(进程)要执行,则跳出, //转向switch_to(),执行0号进程(idle)。 }

实验一进程调度实验报告书

淮海工学院计算机工程学院实验报告书 课程名:《操作系统原理A》 题目:进程调度 班级:软件132 学号:2013122907 姓名:孙莹莹

操作系统原理实验——进程调度实验报告 一、目的与要求 1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。本实验可加深对进程调度算法的理解。 2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果) 3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。 二、实验内容或题目 1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。 2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。 3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。 4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。 三、实验步骤与源程序 (1)流程图

(2)实验步骤 1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下: Id:进程标识符号,取值1—5。 Priority:优先级,随机产生,范围1—5。 Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。 Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。并随机产生,每运行一个时间片need减1;need为0则进程结束。 Status:进程状态R(运行),W(就绪),F(完成);初始时都处于就绪状态。 Next:指向就绪队列中下一个进程的PCB的指针。 2)初始状态及就绪队列组织: 5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。各进程的优先级随机产生,范围1—5。处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head,队尾指针为tail。 3)调度原则以及运行时间的处理: 正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。程序中进程的运行时间以逻辑时间片为单位。

操作系统的进程调度 实验报告

《计算机操作系统2》实验报告 实验一题目:操作系统的进程调度 姓名:学号:12125807 实验日期:2014.12 实验要求: 1.设计一个有n个进程工行的进程调度程序。每个进程由一个进程控制块(PCB)表示。 进程控制块通常应包含下述信息:进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等,且可按调度算法的不同而增删。 2.调度程序应包含2~3种不同的调度算法,运行时可任意选一种,以利于各种算法的分 析比较。 3.系统应能显示或打印各进程状态和参数的变化情况,便于观察诸进程的调度过程 实验目的: 1.进程是操作系统最重要的概念之一,进程调度又是操作系统核心的主要内容。本实习要 求学生独立地用高级语言编写和调试一个简单的进程调度程序。调度算法可任意选择或自行设计。例如,简单轮转法和优先数法等。本实习可加深对于进程调度和各种调度算法的理解。 实验内容: 1.编制和调试示例给出的进程调度程序,并使其投入运行。 2.自行设计或改写一个进程调度程序,在相应机器上调试和运行该程序,其功能应该不亚 于示例。 3.直观地评测各种调度算法的性能。 示例: 1.题目 本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一,并假设起始状态都是就绪状态W。为了便于处理,程序进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数、以及进程需要运行的时间片数,均由伪随机数发生器产生。 进程控制块结构如下:

PCB 进程标识数 链指针 优先数/轮转时间片数 占用CPU时间片数 进程所需时间片数 进程状态 进程控制块链结构如下: 其中:RUN—当前运行进程指针; HEAD—进程就绪链链首指针; TAID—进程就绪链链尾指针。 2.算法与框图 (1) 优先数法。 进程就绪链按优先数大小从高到低排列,链首进程首先投入运行。每过一个时间片,运行进程所需运行的时间片数减1,说明它已运行了一个时间片,优先数也减3,理由是该进程如果在一个时间片中完成不了,优先级应该降低一级。接着比较现行进程和就绪链链首进程的优先数,如果仍是现行进程高或者相同,就让现行进程继续进行,否则,调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链,且改变它们对应的进程状态,直至所有进程都运行完各自的时间片数。 (2) 简单轮转法。 进程就绪链按各进程进入的先后次序排列,进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项(相当于优先数法的优先数记录项位置)。每过一个时间片,运行进程占用处理机的时间片数加1,然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等,若相等说明已到达轮转时间,应将现运行进程排到就绪链末尾,调度链首进程占用处理机,且改变它们的进程状态,直至所有进程完成各自的时间片。(3) 程序框图如下图所示。

操作系统实验报告(进程调度算法)

操作系统实验报告 实验1 进程调度算法 报告日期:2016-6-10 姓名: 学号: 班级: 任课教师: 实验1 进程调度算法

一、实验内容 按优先数调度算法实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 三、实验原理 设计一个按优先数调度算法实现处理器调度的程序。 (1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为: P1,P2,P3,P4,P5。 指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。 要求运行时间——假设进程需要运行的单位时间数。 优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。 状态——可假设有两种状态,“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。 (2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。 (3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程,用指针指出队列的连接情况。例: K2K3K4K5 PCB1 PCB2 PCB3 PCB4 PCB5 (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行: 优先数-1 要求运行时间-1 来模拟进程的一次运行。

进程调度算法实验报告

操作系统实验报告(二) 实验题目:进程调度算法 实验环境:C++ 实验目的:编程模拟实现几种常见的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较 各种算法的性能优劣。 实验内容:编程实现如下算法: 1.先来先服务算法; 2.短进程优先算法; 3.时间片轮转调度算法。 设计分析: 程序流程图: 1.先来先服务算法 开始 初始化PCB,输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列? 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法

3.时间片轮转调度算法 实验代码: 1.先来先服务算法 #include #define n 20 typedef struct { int id; //进程名

int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"<>amount; for(i=0;i>f[i].id; cin>>f[i].atime; cin>>f[i].runtime; } for(i=0;if[j+1].atime) {diao=f[j].atime; f[j].atime=f[j+1].atime; f[j+1].atime=diao; huan=f[j].id; f[j].id=f[j+1].id; f[j+1].id=huan; } } } for(i=0;i #define n 5 #define num 5 #define max 65535 typedef struct pro { int PRO_ID; int arrive_time;

进程调度算法模拟实验

华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制

《操作系统C》课程综合性实验报告 开课实验室:基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备:PC机一台 2.软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如C \C++\Java等编程语言环境。 三、实验内容 (1)用C语言(或其它语言,如Java)实现对N个进程采用某种进程调度算法(如动态优先权调度)的调度。 (2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段: ?进程标识数ID。 ?进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时,ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT,用来将PCB排成队列。 (3)优先数改变的原则: ?进程在就绪队列中呆一个时间片,优先数增加1。 ?进程每运行一个时间片,优先数减3。 (4)为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。

操作系统实验报告(进程调度算法)

操作系统实验报告(进程调度算法)

实验1 进程调度算法 一、实验内容 按优先数调度算法实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 三、实验原理 设计一个按优先数调度算法实现处理器调度的程序。 (1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为: 进程名 指针 要求运行时 间 优先数

状态 其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。 指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。 要求运行时间——假设进程需要运行的单位时间数。 优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。 状态——可假设有两种状态,“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。 (2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。 (3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程,用指针指出队列的连接情况。例: 队首标志 K2

1P1 K 2 P2 K 3 P3 K 4 P4 K 5 P5 0 K4K5K3K1 2 3 1 2 4 1 5 3 4 2 R R R R R PC B1 PC B2 PC B3 PC B4 PC B5 (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行: 优先数-1 要求运行时间-1 来模拟进程的一次运行。 提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。在这里省去了这些工作。

进程模拟调度算法课程设计

一.课程概述 1.1.设计构想 程序能够完成以下操作:创建进程:先输入进程的数目,再一次输入每个进程的进程名、运行总时间和优先级,先到达的先输入;进程调度:进程创建完成后就选择进程调度算法,并单步执行,每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下,主存中有着多个进程,其数目往往多于处理机数目,要使这多个进程能够并发地执行,这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源,提高处理机的利用率及改善系统必(吞吐量、响应时间),在很大程度上取决于处理机调度性能的好坏,因而,处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法,短作业优先调度算法,高优先权调度算法,时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行,系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过PCB对进程进行控制,亦即,系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的,PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言(或C++)编程实现操作模拟操作系统进程调度子系统的基本功能;运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。 三、实现用户界面的开发

进程调度算法实验报告doc

进程调度算法实验报告 篇一:操作系统进程调度算法模拟实验报告 进程调度算法模拟 专业:XXXXX 学号:XXXXX 姓名:XXX 实验日期:20XX年XX月XX日 一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。 二、实验要求 编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算 法分别进行模拟调度。 三、实验方法内容 1. 算法设计思路 将每个进程抽象成一个控制块PCB, PCB用一个结构体描述。 构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存 在三个容器,一个保存正在或未进入就绪队列的进程,一个保存就绪的进程,另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、 完成容器。 当程序启动时,用户可以选择不同的调度算法。然后用户从控制台输入 各个进程的信息,这些信息保存到进程容器中。进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2. 算法流程图主程序的框架: ();//先来先服务 ();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息 ();.m_WaitQueue.empty()||.m_ProcessQueue.empt() (); (); 进程调度过程: ; 3. 算法中用到的数据结构 struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float

实验一处理器调度实验报告

处理器调度一、实验内容 选择一个调度算法,实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。 当就绪状态进程 个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按优先数调度算法实现处理器调度的程序 提示: (1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。进 程控制块的格 式为: 其中,进程名----作为进程的标识,假设五个进程的进程名分别是R, P2, P3, P4,R。 指针—按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块

首地址,最后一个进程中的指针为“ 0”。 要求运行时间-- 假设进程需要运行的单位时间数。 优先数-赋予进程的优先数,调度时总是选取优先数大的进程先执行。 状态-可假设有两种状态,“就绪”状态和“结束“状态,五个进程的初 始状态都为 “就绪“状态,用“ R”表示,当一个进程运行结束后,它的状态变为“结束”, 用“ E”表示。 (2)在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数” 和“要求运行时间”。 (3)为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首 进程,用指针指出队列的连接情况。例: 队首标志 (4)处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优 先数就减“ 1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的 启动运行,而是执行: 优先数- 1 要求运行时间-1 来模拟进程的一次运行提醒注意的是:在实际的系统中,当一个进程被选中运

操作系统进程调度实验报告

实验一进程调度实验 专业:XXXXX 学号:XXXXX 姓名:XXX 实验日期:20XX年XX月XX日

一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。 二、实验要求 编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度。 三、实验方法内容 1.算法设计思路 将每个进程抽象成一个控制块PCB,PCB用一个结构体描述。 构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存在三个容器,一个保存正在或未进入就绪队列的进程,一个保存就绪的进程,另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。 主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。 当程序启动时,用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2.算法流程图 主程序的框架: 开始 选择调度算法void FCFS();//先来先服务 void SJF();//最短进程优先调度void RR();//简单时间片轮转void PD();//最高优先数优先 输入进程信息 将输入容器中以满足进入条件的进程调入就绪队列 判断就绪容器和输入容器是否为空!processScheduler.m_WaitQueue.empty()|| !processScheduler.m_ProcessQueue.empt() void ProcessQueueProcess(); //查看当前时间下,有无进程加 入。若有则把该进程调入就绪队列 void PCBInput();//输入进程信息 Y 打印各进程信息 进行统计计算周转 时间等 结束void PCBDisplay(); //打印当前状况下。就绪队列、完成队列、运行中的进程信息 void SchedulerStatistics(); //调度统计,计算周转时间等 按照选择的算法开 始选择就绪队列的 进程开始执行 void ProcessSelect(); //若当前就绪队列不为空则根 据选择的调度算法开始调度,否则,系统时间加一个时间片.以等待新的进程到

操作系统原理-进程调度实验报告

一、实验目的 通过对进程调度算法的设计,深入理解进程调度的原理。 进程是程序在一个数据集合上运行的过程,它是系统进行资源分配和调度的一个独立单位。 进程调度分配处理机,是控制协调进程对CPU的竞争,即按一定的调度算法从就绪队列中选中一个进程,把CPU的使用权交给被选中的进程。 进程通过定义一个进程控制块的数据结构(PCB)来表示;每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性;在RR中,以1为时间片单位;运行时,输入若干个进程序列,按照时间片输出其执行序列。 二、实验环境 VC++6.0 三、实验内容 实现短进程优先调度算法(SPF)和时间片轮转调度算法(RR) [提示]: (1) 先来先服务(FCFS)调度算法 原理:每次调度是从就绪队列中,选择一个最先进入就绪队列的进程,把处理器分配给该进程,使之得到执行。该进程一旦占有了处理器,它就一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。 将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理,是一种最普遍和最简单的方法。它优先考虑在系统中等待时间最长的作业,而不管要求运行时间的长短。 按照就绪进程进入就绪队列的先后次序进行调度,简单易实现,利于长进程,CPU繁忙型作业,不利于短进程,排队时间相对过长。 (2) 时间片轮转调度算法RR

原理:时间片轮转法主要用于进程调度。采用此算法的系统,其程序就绪队列往往按进程到达的时间来排序。进程调度按一定时间片(q)轮番运行各个进程. 进程按到达时间在就绪队列中排队,调度程序每次把CPU分配给就绪队列首进程使用一个时间片,运行完一个时间片释放CPU,排到就绪队列末尾参加下一轮调度,CPU分配给就绪队列的首进程。 固定时间片轮转法: 1 所有就绪进程按 FCFS 规则排队。 2 处理机总是分配给就绪队列的队首进程。 3 如果运行的进程用完时间片,则系统就把该进程送回就绪队列的队尾,重新排队。 4 因等待某事件而阻塞的进程送到阻塞队列。 5 系统把被唤醒的进程送到就绪队列的队尾。 可变时间片轮转法: 1 进程状态的转换方法同固定时间片轮转法。 2 响应时间固定,时间片的长短依据进程数量的多少由T = N × ( q + t )给出的关系调整。 3 根据进程优先级的高低进一步调整时间片,优先级越高的进程,分配的时间片越长。 多就绪队列轮转法: (3) 算法类型 (4)模拟程序可由两部分组成,先来先服务(FCFS)调度算法,时间片轮转。流程图如下:

作业调度实验报告

作业调度实验报告 Document number:NOCG-YUNOO-BUYTT-UU986-1986UT

实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。 (1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。 (2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。 (3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法:采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二.实验目的: 本实验要求用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析:

1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示,JCB 可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb .\n",p->name); free(p); .wait...",time); if(times>1000) 代替 代替

实验一、进程调度实验报告

实验一、进程调度实验报告

广东技术师范学院实验报告 学院:计算机科学学 院 专业: 计算机科学与 技术(师范) 班级:成绩: 姓名:学号:组别:组员: 实验地点:实验日期:指导教师签名: 实验名称:实验一、进程调度实验 一、实验目的 用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解 二、实验类别 综合性实验。综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识 三、实验内容和步骤 1.编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。 “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。 动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1。或者,进程等待的时间超过某一时限时增加其优先数的值,等等 该题根据老师给的代码用Visual C++运行,结果以及分析如下: 预习情况操作情况考勤情况数据处理情况

结果分析:根据上述输入的三个进程的信息可以得到:优先级最高的是进程cc 最先调度进程cc的状态为运行态,需要执行的时间为10当前就绪队列状态为:进程aa先级比较高,处于就绪队列前面,而进程bb先级是三者中最低的,所以处于就绪队列的最后。而此时这两个进程的状态都为就绪态。

结果分析:当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间,则将它的优先级减1之后,再将三个进程按优先级的大小排列,从中选择优先级大的进程进入运行状态,则该次进入运行态的是进程aa 按照这种方式一直运行下去: 直到:

操作系统模拟进程调度算法

操作系统 ——项目文档报告 进程调度算法 专业: 班级: 指导教师: 姓名: 学号:

一、核心算法思想 1.先来先服务调度算法 先来先服务调度算法是一种最简单的调度算法,该算法既可以用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将他们调入内存,为它们分配资源、创建进程,然后放入就绪队列。在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。 2.短作业(进程)优先调度算法 短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。该算法对长作业不利,完全未考虑作业的紧迫程度。 3.高响应比优先调度算法 在批处理系统中,短作业优先算法是一种比较好的算法,其主要不足之处是长作业的运行得不到保证。如果我们能为每个作业引人动态优先权,并使作业的优先级随着等待时间的增加而以速率a提高,则长作业在等待一定的时间后,必然有机会分配到处理机。该优先权的变化规律可描述为: 优先权=(等待时间+要求服务时间)/要求服务时间 即优先权=响应时间/要求服务时间 如果作业的等待时间相同,则要求服务的时间越短,其优先权越高,因而该算法有利于短作业。 当要球服务的时间相同时,作业的优先权决定于其等待时间,等待时间越长,优先权越高,因而它实现的是先来先服务 对于长作业,作业的优先级可以随着等待时间的增加而提高,当其等待时间足够长时,其优先级便可以升到很高,从而也可获得处理机。 4.时间片轮转算法 在时间片轮转算法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。当执行的时间片用完时,由一个计数器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之,系统能在给定的时间内响应所有用户的请求。 二、核心算法流程图

操作系统:进程调度实验报告

设计性实验报告 一、实验目的 1.在Linux下用C语言编程模拟优先级进程调度算法和时间片轮转进程调度算法。 2.为了清楚地观察每个进程的调度过程,每次调度程序应将各个进程的情况显示出来。 二、总体设计(设计原理、设计方案及流程等) 1、优先级进程调度算法 采用动态优先级进程调度算法,其基本思想是每次调度总是把处理机分配给优先级最高的进程,同时在运行过程中进程的优先级随着执行或等待的时间而降低或增加。 在该实验中每个进程用一个进程控制块( PCB)表示。进程控制块包含如下信息:进程号,进程名、优先数、需要运行时间、已用CPU时间、进程状态。进程号,名字,优先数,运行的时间,事先人为地指定。每个进程的状态可以是就绪,执行,阻塞或完成4种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。就绪队列中的进程在等待一个时间片后,优先级增1。如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时将进程的优先级减1,然后把它插入就绪队列等待CPU。 2、时间片轮转调度算法 采用简单时间片轮转调度算法,其基本思想是:所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还未完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。直至所有的进程运行完毕。 三、实验步骤(包括主要步骤、代码分析等) 1.打开linux虚拟机,用vim编辑器打开代码进行修改和调整。用gcc编译器进行编译编译运行首先运行优先级算法,如图所示:

相关主题