文档库 最新最全的文档下载
当前位置:文档库 › 基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料

基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料

基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料
基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料

JLU

《操作系统》课程设计[基于反馈(Feed Back,FB)排队算法的

CPU调度的模拟实现]

程序代码:

// 223.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include //Definitions for memory and string functions.

#include //Defines the ctype macros.

#include //memory management functions and variables.

#include

#include

#include //Definitions for low level I/O functions.

#include //Symbols and structures for process management.

#include //Direct MSDOS console input/output.

#include

#include // Struct and function declarations for dealing with time. #include //Defines structs, unions, macros, and functions for dealing //with MSDOS and the Intel iAPX86 microprocessor family.

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

//////////////////////////////////////////

typedef int Status; //指定用Status和Boolean代表int类型

typedef int Boolean;

//////////////////////////////////////////

typedef struct QNode

{

char name[5];

int time;

int timeType;

struct QNode *next;

}QNode,*QueuePtr;

typedef struct

{

QueuePtr front;//队头指针

QueuePtr rear; // 队尾指针

}LinkQueue;

int count=0; //时间计数变量

LinkQueue qRun,qWait,qReady1,qReady2,qReady3,qReady4;

//////////////////////////////////////////////////////////////////////////

void menu1();

void menu2();

void gotoxy(int x,int y);

void clrscr(void); //清屏函数

void clreol(void); //在文本窗口中清除字符到行末

void clreoscr(void); //clear end of screen

Status InitQueue(LinkQueue &Q);

Status creatPro(LinkQueue &quePro);

void dealTime();

void runPro(void);

void run();

void wait();

void wake();

void endPro();

//////////////////////////////////////////////////////////////////////////

//DOS界面坐标定位函数/////////////////////////////////////////////////////

void gotoxy(int x,int y)

{

CONSOLE_SCREEN_BUFFER_INFO csbiInfo; //variablendklaration HANDLE hConsoleOut;

hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);

GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);

csbiInfo.dwCursorPosition.X = x; //cursorposition X koordinate festlegen

csbiInfo.dwCursorPosition.Y = y; //cursorposition Y koordinate festlegen

SetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition); //den cursor an die festgelegte koordinate setzen

}

Status InitQueue(LinkQueue &Q)

{ // 构造一个空队列Q

if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))

exit(OVERFLOW);

Q.front->next=NULL;

return OK;

}

Status EnQueue(LinkQueue &Q,char e[5],int proTime,int tType)

{ // 插入元素e为Q的新的队尾元素

QueuePtr p;

if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败

exit(OVERFLOW);

strcpy(p->name,e);

p->time=proTime;

p->timeType=tType;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

return OK;

}

Status DeQueue(LinkQueue &Q,char e[5])

{ // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR QueuePtr p;

if(Q.front==Q.rear)

return ERROR;

p=Q.front->next;

strcpy(e,p->name);

Q.front->next=p->next;

if(Q.rear==p)

Q.rear=Q.front;

free(p);

return OK;

}

Status QueueTraverse(LinkQueue &Q,int x,int y)

{

QueuePtr p;

p=Q.front->next;

while(p)

{

gotoxy(x,y);

printf("%s",p->name);

gotoxy(x,y+1);

printf("%d",p->time);

p=p->next;

x+=6;

}

printf("\n");

return OK;

}

void print()

{

if(qRun.front!=qRun.rear){

QueueTraverse(qRun,17,5);

}

if(qWait.front!=qWait.rear){

QueueTraverse(qWait,17,8);

}

if(qReady1.front!=qReady1.rear){

QueueTraverse(qReady1,17,11);

}

if(qReady2.front!=qReady2.rear){

QueueTraverse(qReady2,17,14);

}

if(qReady3.front!=qReady3.rear){

QueueTraverse(qReady3,17,17);

}

if(qReady4.front!=qReady4.rear){

QueueTraverse(qReady4,17,20);

}

}

Status creatPro(LinkQueue &quePro)

{

char proName[5];

int proTime;

QueuePtr p;

b: gotoxy(22,3);

printf("进程名: ");

gotoxy(36,3);

printf("所需时间: ");

gotoxy(30,3);

scanf("%s",&proName);

gotoxy(46,3);

scanf("%d",&proTime);

if(proTime<=0)

{

gotoxy(22,3);

printf("信息提示: 输入时间错误!请按Enter键返回!");gotoxy(15,3); getchar();getchar();

gotoxy(0,0);

menu1();

goto b;

}

getchar();

if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败

exit(OVERFLOW);

strcpy(p->name,proName);

p->time=proTime;

p->timeType=10; //进入时间片为10的就绪队列,即优先级最高的就绪队列

p->next=NULL;

quePro.rear->next=p;

quePro.rear=p;

return OK;

}

void dealTime()

{

char e[5];

int tType=qRun.front->next->timeType;

++count;

qRun.front->next->time--;

if(qRun.front->next->time==0)

{

DeQueue(qRun,e);

runPro();

count=0;

}

else

if(qRun.front->next->timeType==count)

{

if(qRun.front->next->timeType==10)

EnQueue(qReady2,qRun.front->next->name,qRun.front->next->time,tType+10); if(qRun.front->next->timeType==20)

EnQueue(qReady3,qRun.front->next->name,qRun.front->next->time,tType+20);

if(qRun.front->next->timeType==40)

EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);

if(qRun.front->next->timeType==80)

EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);

DeQueue(qRun,e);

runPro();

count=0;

}

}

void runPro(void)

{

char e[5];

int pTime,f1=0,f2=0,f3=0,f4=0;

if(qReady1.front!=qReady1.rear)

{

pTime=qReady1.front->next->time;

EnQueue(qRun,qReady1.front->next->name,pTime,qReady1.front->next->timeType);

DeQueue(qReady1,e);

f1=1; }

else

{

if(qReady2.front!=qReady2.rear)

{

pTime=qReady2.front->next->time;

EnQueue(qRun,qReady2.front->next->name,pTime,qReady2.front->next->timeType); DeQueue(qReady2,e);

f2=1;

}

else

{

if(qReady3.front!=qReady3.rear)

{

pTime=qReady3.front->next->time;

EnQueue(qRun,qReady3.front->next->name,pTime,qReady3.front->next->timeType);

DeQueue(qReady3,e);

f3=1;

}

else

{

if(qReady4.front!=qReady4.rear)

{

pTime=qReady4.front->next->time;

EnQueue(qRun,qReady4.front->next->name,pTime,qReady4.front->next->timeType);

DeQueue(qReady4,e);

f4=1;

}

}

}

}

gotoxy(0,4);

menu2();

if(f1==0 && f2==0 && f3==0 && f4==0)

{

gotoxy(0,0);

menu1();

gotoxy(22,3);

printf("信息提示:无就绪进程,请输入其他功能选项!");

}

gotoxy(0,4);

menu2();

}

void run()

{

if(qRun.front==qRun.rear)

runPro();

else

dealTime();

}

void endPro()

{

char e[5];

if(qRun.front==qRun.rear)

{

gotoxy(0,0);

menu1();

gotoxy(22,3);

printf("信息提示:无运行进程,请按Enter键运行进程!");

gotoxy(15,3);

}

else

{

DeQueue(qRun,e);

gotoxy(0,0);

menu1();

gotoxy(22,3);

printf("信息提示:选择菜单功能或按Enter键执行进程!");

gotoxy(0,4);

menu2();

print();

} }

void wait()

{

char e[5];

if(qRun.front!=qRun.rear)

{

EnQueue(qWait,qRun.front->next->name,qRun.front->next->time,qRun.front->next->timeType); DeQueue(qRun,e);

gotoxy(0,4);

menu2();

print();

gotoxy(22,3);

printf("信息提示: 选择菜单功能或按Enter键执行进程!");

} else

{

gotoxy(0,0);

menu1();

gotoxy(22,3);

printf("信息提示:无运行进程,请输入其他功能选项!");

}

}

void wake()

{

char e[5];

if(qWait.front!=qWait.rear)

{

EnQueue(qReady1,qWait.front->next->name,qWait.front->next->time,qWait.front->next->timeType );

DeQueue(qWait,e);

gotoxy(0,4);

menu2();

print();

gotoxy(22,3);

printf("信息提示: 选择菜单功能或按Enter键执行进程!");

}

else

{

gotoxy(0,0);

menu1();

gotoxy(22,3);

printf("信息提示:无等待进程,请输入其他功能选项!");

}

}

void menu1()

{

printf(" ┏━━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┓\n");

printf(" ┃ 1-> 创建进程┃2-> 撤销进程┃3-> 阻塞进程┃4-> 唤醒进程┃0->退出系统┃\n");

printf(" ┣━━━━━━━╋━━━━━━┻━━━━━━┻━━━━━━┻━━━━━━┫\n");

printf(" ┃菜单选择: ┃┃\n");

}

void menu2()

{

printf(" ┣━━━━━┳━┻┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┫\n");

printf(" ┃Run: ┃┃┃┃┃┃┃┃┃┃┃

\n");

printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");

printf(" ┃Wait: ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");

printf(" ┃Ready1 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┃Time:10 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");

printf(" ┃Ready2 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┃Time:20 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");

printf(" ┃Ready3 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┃Time:40 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");

printf(" ┃Ready4 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┃Time:80 ┃┃┃┃┃┃┃┃┃┃┃\n");

printf(" ┗━━━━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┛\n");

}

void main()

{

char a=NULL;

system("color 0B");

InitQueue(qRun);

InitQueue(qWait);

InitQueue(qReady1);

InitQueue(qReady2);

InitQueue(qReady3);

InitQueue(qReady4);

menu1();

menu2();

gotoxy(15,3);

scanf("%c",&a);

while(1)

{

gotoxy(0,0);

menu1();

switch(a)

{

case '1':creatPro(qReady1);

print();

gotoxy(22,3);

printf("信息提示: 选择菜单功能或按Enter键执行进程!");

while(1)

{

f: gotoxy(15,3);

a=getchar();

if(a=='\n')

{

gotoxy(22,3);

printf("信息提示: 选择菜单功能或按Enter键执行进程!"); run();

gotoxy(0,4);

menu2();

print();

}

else

break;

}

getchar();

break;

case '2':endPro();goto f;break;

case '3':wait(); goto f; print(); break;

case '4':wake(); goto f; print(); break;

case '0': gotoxy(22,3); exit(0); break;

default:

gotoxy(22,3);

printf("信息提示: 输入错误!请选择正确的菜单功能选项!"); goto f;

}

print();

}

}

处理器调度习题

处理器调度 选择题 当CPU执行操作系统代码时,则处理机处于( )。 A.执行态 B.目态 C.管态 D.就绪态 ( )是机器指令的扩充,是硬件的首次延伸,是加在硬件上的第一层软件。 A.系统调用 B.操作系统 C.内核 D.特权指令 操作系统提供给程序员的接口是( )。 A.进程 B.系统调用 C.库函数 D.B和C 用户程序向系统提出使用外设的请求方式是( )。 A.作业申请 B.原语 C.系统调用 D.I/O指令 当作业正常完成进入完成状态时,操作系统( )。 A.将输出该作业的结果并删除内存中的作业 B.将收回该作业的所占资源并输出结果 C.将收回该作业的所占资源及输出结果,并删除该作业 D.将收回该作业的所占资源及输出结果,并将它的控制块从当前的队列中删除 下列选项是关于作业和进程关系的描述,其中哪一个是不正确的( )。 A.作业的概念主要用在批处理系统中,而进程的概念则用在几乎所有的OS中。 B.作业是比进程低一级的概念。 C.一个作业至少由一个进程组成。 D.作业是用户向计算机提交任务的实体,而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 作业从后备作业到被调度程序选中的时间称为( )。 周转时间B.响应时间C.等待调度时间D.运行时间 设有三个作业J1,J2,J3,它们同时到达,运行时间分别为T1,T2,T3,且T1≤T2≤T3,若它们在一台处理机上按单道运行,采用短作业优先算法,则平均周转时间为( )。 A.T1+T2+T3 B.1/3(T1+T2+T3) C.T1+2/3T2+1/3T3 D.T1+1/3T2+2/3T3 从作业提交给系统到作业完成的时间间隔称为作业的( )。 A.中断时间 B.等待时间 C.周转时间 D.响应时间 设有四个作业同时到达,每个作业执行时间均为2 h,它们在一台处理机上按单道方式运行,则平均周转时间为( )。 A.1 h B.5 h C.2.5 h D.8 h FCFS调度算法有利于( )。 A.长作业和CPU繁忙型作业 B.长作业和I/O繁忙型作业 C.短作业和CPU繁忙型作业 D.短作业和I/O繁忙型作业 下列哪种说法不是SJ(P)F调度算法的缺点( )。 A.对于长作业(进程)不利 B.未考虑作业(进程)的紧迫程度 C.不能有效降低作业(进程)的平均等待时间 D.由于根据的是用户提供的估计执行时间,因此不一定真正做到短而优先。 选择排队进程中等待时间最长的进程被优先调度,该调度算法是( )。 A.先来先服务调度算法B.短进程优先调度算法 C.优先权调度算法D.高响应比优先调度算法 在采用动态优先权的优先权调度算法中,如果所有进程都具有相同优先权初值,则此时的优先权调度算法实际上和( )相同。

多级反馈队列调度算法的实现

学生实习报告 课程名称_ 数据结构与数据处理应用训练 题目名称多级反馈队列调度算法的实现 学生学院计算机与计算科学 专业班级 学号 学生姓名 指导教师 2012年 2月 16 日 多级反馈队列调度算法的实现 【摘要】 多级反馈队列调度算法是操作系统中CPU处理机调度算法之一,该算法既能使高优先级的进程(任务)得到响应又能使短进程(任务)迅速完成。UNIX操作系统便采取这种算法,而本次试验就是试用C语言模拟某多级反馈队列调度算法。本次试验中前三级就绪队列采用时间片轮转法,时间片大小分别为2、4和8,最后一级就绪队列采用FIFO调度,将任务进入多级队列进行模拟,任务从优先级高的队列到优先级地的队列的顺序逐一进入,还用了算法支持抢占式,最后完成模拟,得到各个任务先后完成的顺序,还有得到各个任务的响应时间、离开时间、周转时间。 【关键词】队列优先级任务时间 1 内容与要求 【内容】 多级反馈队列调度算法是操作系统中CPU处理机调度算法之一,该算法既能使高优先级的进程(任务)得到响应又能使短进程(任务)迅速完成。UNIX操作系统便采取这种算法,本次试验就是试用C语言模拟某多级反馈队列调度算法,通过输入任务号、到达时间、运行时间,求出任务完成的先后顺序以及各个任务

的响应时间、离开时间、周转时间。 【要求】 多级反馈队列调度算法描述: 1、该调度算法设置四级就绪队列:前三级就绪队列采用时间片轮转法,时间片大小分别为 2、4和8;最后一级就绪队列采用FIFO调度。 2、任务在进入待调度的队列等待时,首先进入优先级最高的队列等待。 3、首先调度优先级高的队列中的任务。若高优先级中队列中已没有调度的任务,则调度次优先级队列中的任务,依次类推。 4、对于同一个队列中的各个任务,按照队列指定调度方法调度。每次任务调度执行后,若没有完成任务,就被降到下一个低优先级队列中。 5、在低优先级的队列中的任务在运行时,又有新到达的任务,CPU马上分配给新到达的任务。(注:与原来的题目不同,原题是在低优先级的队列中的任务在运行时,又有新到达的任务时,要在运行完这个时间片后,CPU马上分配给新到达的任务,而本题不需要在运行完这个时间片,即正在进行的任务立刻停止,CPU 马上分配给新到达的任务) 6、为方便实现,时间以1为单位,用整数数据表示;且每个时间点,最多只有一个任务请求服务(即输入)。 2 总体设计 算法总体思路: 这是建立在一个时间轴上的,即时刻,一个一个时刻(时间点)进行。 2.1.1 主函数思路:

操作系统处理器调度算法C++程序

一、先来先服务算法 1.程序简介 先来先服务算法按照作业进入系统后备作业队列的先后次序挑选作业,先进入系统的作业将优先被挑选进入主存,创建用户进程,分配所需资源,然后,移入就绪队列.这是一种非剥夺式调度算法,易于实现,但效率不高.只顾及作业的等候时间,未考虑作业要求服务时间的长短,不利于短作业而优待长作业,不利于I/O繁忙型作业而有利于CPU繁忙型作业.有时为了等待场作业执行结束,短作业的周转时间和带全周转时间将变得很大,从而若干作业的平均周转时间和平均带权周转时间也变得很大。 2.分析 1.先定义一个数组代表各作业运行的时间,再定义一个数组代表各作业到达系统的时间,注意到达系统的时间以第一个作业为0基础(注意:若各程序都同时到达系统,则到达系统时间都为0)。 2.输入作业数。 3.然后运用循环结构累积作业周转时间和带权周转时间。 4.最后,作业周转时间和带权周转时间分别除以作业数即可得到平均作业周转时间和平均带权周转时间。 3.详细设计 源程序如下: #include #include using namespace std; int main() { int n,a[100],b[100]; double s[100],m[100],T=0,W=0; cout<<"请输入作业数:"<>n; cout<<"请分别输入各作业到达系统的时间:"<>b[i]; } cout<<"请分别输入各作业所运行的时间:"<>a[i];s[0]=0; s[i+1]=s[i]+a[i]; m[i+1]=(s[i+1]-b[i])/a[i]; T=T+s[i+1]-b[i]; W=W+m[i+1]; }

C语言模拟CPU调度

C语言模拟CPU调度 C语言模拟CPU调度 CPU在处理多个进程时,要根据各种情况对处理的进程进行调度。这其中就包括对各个进程优先级的处理,和调度算法的处理。下面这个C语言程序,是我在大学期间学习《操作系统》课程的CPU调度时编写的,模拟了CPU的两种调度模式和各种模式所对应的多种调度算法。为了模拟得更为形象,采用了图形屏幕输出。 #include<stdlib.h> #include<stdio.h> #include<conio.h> #include<graphics.h> #include<math.h> #include<dos.h> #define NULL 0 /*-----------------------------------------------------------------*/ struct event /*事件结点结构*/ { int evtype; /*1:进程产生。2:进程执行。3:激

活阻塞进程。 4:进程执行完5:进程阻塞* 6:返回事件*/ int pnum; /*执行该事件的进程号*/ int t; /*事件发生的时间*/ int ifblock; /*如果是执行事件标准其有无阻塞,其它事件时无定义*/ struct event *next; }; struct process /*进程结点结构*/ { int pnum; /*进程号*/ int plong; /*进程长度*/ int prior; /*进程优先级*/ int blocknum; /*进程当前的阻塞数*/ int runtime; /*执行次数*/ struct process *next; }; struct headnod /*队列头结点结构*/ { struct process *head; /*队列头*/ int totalpro; /*队列中的进程数*/

处理器调度(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度 一、实验容 选择一个调度算法,实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按时间片轮转法实现处理器调度的程序。 [提示]: (1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为: 其中,Q1,Q2,Q3,Q4,Q5。 指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数,初始值为“0”。 状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。 当一个进程运行结束后,它的状态为“结束”,用“E”表示。 (2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如,当前轮到P2执行,则有: 标志单元 K1 K2 K 3 K4 K5

(4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能,所以,对被选中的进程并不实际的启动运行,而是执行: 已运行时间+1 来模拟进程的一次运行,表示进程已经运行过一个单位的时间。 请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。在这时省去了这些工作,仅用“已运行时间+1”来表示进程已 经运行满一个时间片。 (5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一 个轮到运行的进程。同时,应判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间 已运行时间,则表示它尚未执行结束,应待到下一轮时再运行。若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”(E)且退出队列。此时,应把该进程的进程控制块中的指针值送到前 面一个进程的指针位置。 (6)若“就绪”状态的进程队列不为空,则重复上面的(4)和(5)的步骤,直到所有 的进程都成为“结束”状态。 (7)在所设计的程序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及 运行一次后进程队列的变化。 (8)为五个进程任意确定一组“要求运行时间”,启动所设计的处理器调度程序,显示 或打印逐次被选中的进程名以及进程控制块的动态变化过程。 四. 所用数据结构及符号说明 typedef struct PNode//PCB { struct PNode *next; //定义指向下一个节点的指针 char name[10]; //定义进程名,并分配空间 int All_time; //定义总运行时间 int Runed_Time; //定义已运行时间 char state; //定义进程状态Ready/End } *Proc; //指向该PCB的指针 int ProcNum; //总进程数

多级反馈队列调度算法

#include #include <> #include<> #define NULL 0 #define MAL(type) (type *)malloc(sizeof(type)) using namespace std; typedef struct LNode {char name[5]; char state; int runtime; int needtime; struct LNode *next; }LNode; LNode *H; int T,D,J; void print() {LNode *p=H; printf("\n进程名需执行时间已执行时间状态\n"); for(int i=0;iname,p->needtime,p->runtime,p->state); p=p->next; } system("PAUSE");

void input() {int i; printf("请输入进程数:"); scanf("%d",&J); for(i=0;iname); printf("请输入第%d个进程需要的执行时间:",i+1); scanf("%d",&q->needtime); if(q->needtime<=0) {printf("所需时间要大于0\n 请重新输入——\n");i--;} else {q->runtime=0; q->state='N'; q->next=NULL; } if(i==0) H=p=q; else {p->next=q;p=q;} } printf("\n进程初始化态为:"); print();

加权公平队列调度算法

2008年2月 February 2008 —28— 计 算 机 工 程Computer Engineering 第34卷 第4期 Vol.34 No.4 ·博士论文· 文章编号:1000—3428(2008)04—0028—03 文献标识码:A 中图分类号:TP391 一种新的加权公平队列调度算法 尹德斌,谢剑英 (上海交通大学自动化系,上海 200240) 摘 要:传统公平队列调度算法(WFQ 、WRR 等)普遍存在基于数据包的权重参数计算问题,由此产生的高复杂度使其难以获得广泛应用。该文提出一种新的加权公平队列调度算法,使用服务概率和随机数实现加权公平调度,显著降低了算法的复杂度。同时使用自适应服务概率计算解决了数据包变长度带来的不公平性。通过队列管理技术有效地提高了交换机的缓冲区利用率,并减小了排队延迟抖动。仿真结果证明了算法的有效性和实用性。 关键词: 队列调度;加权公平排队;自适应队列管理;分组交换网络 New Weighted Fair Queue Scheduling Algorithm YIN De-bin, XIE Jian-ying (Department of Automation, Shanghai Jiaotong University, Shanghai 200240) 【Abstract 】Traditional weighted fair queue algorithms have the main drawback: the calculation of the weight parameters according to each packet.The paper proposes a new weighted fair queueing algorithm(SPFQ), which uses service probability to schedule packets and a random number to decide which packet to be served next. In addition, a novel adaptive service probability parameter calculation method is used to solve the unfair problem induced by the variable packet length and an adaptive queue management technology to improve the utilization of the server's queue buffer and reduce the delay burstiness. Simulation results demonstrate the validity and practicability of SPFQ. 【Key words 】queue scheduling; weighted fair queueing; adaptive queue management; packet switching network 1 概述 队列调度是当前互联网技术领域的一个研究热点。其中,加权公平队列调度算法由于能够根据各业务流的权重进行区分服务而受到广大研究者的广泛关注[1-9]。其中最著名的是加权公平WFQ [1]和加权轮询WRR [6]两类算法。WFQ 及其改进算法[3,5,7]都基于通用处理机共享模型[2],使用虚时间(virtual time)进行数据包转发。WFQ 算法在业务流受漏斗约束的情况下可以提供精确的带宽保证和最大时延上限,并且数据包的转发不受其他业务流特性影响。但是它的计算复杂度太高。WRR [2,6]是另一类复杂度相对较低的常用加权队列调度算法;各业务流在一次轮询中所允许发送的数据包个数由队列权重决定。DRR [4]引入了差额计数器(dificit conter),记录由数据包长度不同引起的服务量差。轮询类算法复杂度较低,但无法提供确定的带宽保证和时延上限。 国内的研究者近年来也提出了许多队列调度算法。文 献[8]针对SS 和BF 两种业务流,提出了一种对数自适应调度算法,但该算法对类内各业务流之间如何调度并没有说明,且不能提供公平服务和隔离特性。文献[9]提出了一种用于区分服务网络的虚时钟核心无状态队列调度算法,各数据包自身携带虚时钟状态信息,中心服务器根据虚时钟进行转发,但需要根据虚时钟将入队列数据包插入到转发队列中,这无疑是一项沉重的计算负担。另外,该算法并未考虑虚时钟清零问题。本文提出了一种新的加权队列调度算法SPFQ 。由于采用了指数移动平均算法和阀值触发的平均数据包长度更新,使得服务概率计算频度大大降低,从而显著降低了算法的复杂度。 2 SPFQ 队列调度算法 2.1 SPFQ 的基本原理 SPFQ 算法依据各业务流的平均数据包长度将它们的权重转换成归一化服务概率,通过该参数实现加权服务。为了降低算法的复杂度,系统采用事件触发方式计算队列的平均长度。在算法实现中,使用单独模块计算服务概率,以减轻调度器的负荷。 2.2 SPFQ 的结构 数据包分类器图1 SPFQ 算法结构 基金项目:国家自然科学基金资助项目(60572157);国家“863”计划基金资助项目(2003AA123310) 作者简介:尹德斌(1978-),男,博士,主研方向:包交换网络的队列调度和管理;谢剑英,教授、博士生导师 收稿日期:2007-03-10 E-mail :yin_db@https://www.wendangku.net/doc/1010861720.html,

模拟一种处理机调度算法讲解

课程设计报告 设计名称:模拟实现一种处理机调度算法 学生姓名: xxx 专业:计算机科学与技术 班别: xxxxxxxx 学号: xxxxxx 指导老师: xxxxx 日期: 2014 年 6 月 20 日

初始条件: 1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。 2.实践准备:掌握一种计算机高级语言的使用。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求) 1.模拟进程调度,能够处理以下的情形: ⑴能够选择不同的调度算法(要求中给出的调度算法); ⑵能够输入进程的基本信息,如进程名、优先级、到达 时间和运行时间等; ⑶根据选择的调度算法显示进程调度队列; ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2.设计报告内容应说明: ⑴需求分析; ⑵功能设计(数据结构及模块说明); ⑶开发平台及源程序的主要部分; ⑷测试用例,运行结果与运行情况分析; ⑸自我评价与总结: i)你认为你完成的设计哪些地方做得比较好或比较出 色; ii)什么地方做得不太好,以后如何改正;

iii)从本设计得到的收获(在编写,调试,执行过程中 的经验和教训); iv)完成本题是否有其他方法(如果有,简要说明该方 法); 进程调度模拟设计——先来先服务、优先级法1、背景: 当计算机系统是多道程序设计系统时,通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态,这种情形就会发生。如果只有一个CPU可用,那么就必须选择下一个要运行的进程。在操作系统中,完成选择工作的这一部分称为调度程序,该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程,好的算法将提高资源利用率,减少处理机的空闲时间,避免有些作业长期得不到相应的情况发生等,从而设计出受欢迎的操作系统。较常见的几种进程调度算法有:先来先服务调度算法;短作业优先调度算法;时间片轮转调度算法;优先级调度算法;高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外,系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略,动态地把处理机

处理器调度习题教学内容

处理器调度习题

处理器调度 选择题 ?当CPU执行操作系统代码时,则处理机处于( )。 ?A.执行态 B.目态 C.管态 D.就绪态 ?( )是机器指令的扩充,是硬件的首次延伸,是加在硬件上的第一层软件。 ?A.系统调用 B.操作系统 C.内核 D.特权指令 ?操作系统提供给程序员的接口是( )。 ?A.进程 B.系统调用 C.库函数 D.B和C ?用户程序向系统提出使用外设的请求方式是( )。 ?A.作业申请 B.原语 C.系统调用 D.I/O指令 ?当作业正常完成进入完成状态时,操作系统( )。 ?A.将输出该作业的结果并删除内存中的作业 ?B.将收回该作业的所占资源并输出结果 ?C.将收回该作业的所占资源及输出结果,并删除该作业 ?D.将收回该作业的所占资源及输出结果,并将它的控制块从当前的队列中删除 ?下列选项是关于作业和进程关系的描述,其中哪一个是不正确的( )。 ?A.作业的概念主要用在批处理系统中,而进程的概念则用在几乎所有的OS中。 ?B.作业是比进程低一级的概念。 ?C.一个作业至少由一个进程组成。 ?D.作业是用户向计算机提交任务的实体,而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 ?作业从后备作业到被调度程序选中的时间称为( )。 ?周转时间B.响应时间C.等待调度时间D.运行时间 ?设有三个作业J1,J2,J3,它们同时到达,运行时间分别为T1,T2,T3,且T1≤T2≤T3,若它们在一台处理机上按单道运行,采用短作业优先算法,则平均周转时间为( )。 ?A.T1+T2+T3 B.1/3(T1+T2+T3) ?C.T1+2/3T2+1/3T3 D.T1+1/3T2+2/3T3 ?从作业提交给系统到作业完成的时间间隔称为作业的( )。 ?A.中断时间 B.等待时间 C.周转时间 D.响应时间 ?设有四个作业同时到达,每个作业执行时间均为2 h,它们在一台处理机上按单道方式运行,则平均周转时间为( )。 ?A.1 h B.5 h C.2.5 h D.8 h ?FCFS调度算法有利于( )。 ?A.长作业和CPU繁忙型作业 B.长作业和I/O繁忙型作业 ?C.短作业和CPU繁忙型作业 D.短作业和I/O繁忙型作业 ?下列哪种说法不是SJ(P)F调度算法的缺点( )。 ?A.对于长作业(进程)不利 ?B.未考虑作业(进程)的紧迫程度 ?C.不能有效降低作业(进程)的平均等待时间 ?D.由于根据的是用户提供的估计执行时间,因此不一定真正做到短而优先。 ?选择排队进程中等待时间最长的进程被优先调度,该调度算法是( )。 ?A.先来先服务调度算法B.短进程优先调度算法 ?C.优先权调度算法D.高响应比优先调度算法 ?在采用动态优先权的优先权调度算法中,如果所有进程都具有相同优先权初值,则此时的优先权调度算法实际上和( )相同。 ?A.先来先服务调度算法B.短进程优先调度算法

操作系统论文-----多级反馈队列调度算法

在多道程序环境下,主存中有着多个进程,其数目往往多过于处理机数目。这就要求系统能按某种算法,动态的把处理机分配给就绪队列中的一个进程,使之执行。 在OS中的调度的实质是一种资源分配,因而调度算法是指:根据系统的资源分配策略所规定的资源分配算法。对于不同的系统和系统目标,通常采用不同的调度算法,目前存在的多种调度算法中,有的算法适用于作业电镀,有的算法适用于进程调度;但也有些调度算法即可用于作业调度,也可用于进程调度。 多级反馈队列调度算法是一种CPU处理机调度算法,它不必事先知道各种进程所需的执行时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。 多级反馈队列调度算法的思想 设置多个就绪队列,并为各个队列赋予不同的优先级和不同长度的时间片;第一个队列的优先级最高,进程所执行时间片最小。 新创建的进程挂到第一优先级的队列后,然后按FCFS 原则排队等待调度。当轮到其执行时,如它能在时间片内完成,便撤离系统;如果不能完成,便被挂入第二级队列后,……; 仅当第一级队列空闲时,调度程序才调度第二级队列中的进程运行,依次类推……;新进程可抢占低级进程的处理机。 多级(假设为N级)反馈队列调度算法可以如下原理: 1、设有N个队列(Q1,Q2....QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列中的作业(进程)的优先级也是不一

样的。一般来说,优先级Priority(Q1) > Priority(Q2) > ... > Priority(QN)。怎么讲,位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高(也就是说,Q1中的作业一定要比Q2中的作业先被处理机调度),依次类推其它的队列。 2、对于某个特定的队列来说,里面是遵循时间片轮转法。也就是说,位于队列Q2中有N个作业,它们的运行时间是通过Q2这个队列所设定的时间片来确定的(为了便于理解,我们也可以认为特定队列中的作业的优先级是按照FCFS来调度的)。 3、各个队列的时间片是一样的吗?不一样,这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的,也就是说,优先级越高的队列中它的时间片就越短。同时,为了便于那些超大作业的完成,最后一个队列QN(优先级最低的队列)的时间片一般很大(不需要考虑这个 问题)。 多级反馈队列调度算法描述: 1、进程在进入待调度的队列等待时,首先进入优先级最高的Q1等待。 2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程,则调度次优先级队列中的进程。例如:Q1,Q2,Q3三个队列,只有在Q1中没有进程等待时才去调度Q2,同理,只有Q1,Q2都为空时才会去调度Q3。 3、对于同一个队列中的各个进程,按照时间片轮转法调度。比如Q1 队列的时间片为N,那么Q1中的作业在经历了N个时间片后若还没有完成,则进入Q2队列等待,若Q2的时间片用完后作业还不能完成,一直进入下一级队列,直至完成。 4、在低优先级的队列中的进程在运行时,又有新到达的作业,那么在运行完这个时间片后,CPU马上分配给新到达的作业(抢占式)。 我们来看一下该算法是如何运作的: 假设系统中有3个反馈队列Q1,Q2,Q3,时间片分别为2,4,8。 现在有3个作业J1,J2,J3分别在时间 0 ,1,3时刻到达。而它们所需要的CPU时间分别是3,2,1个时间片。 1、时刻0 J1到达。于是进入到队列1 ,运行1个时间片,时间片还未到,此时J2到达。 2、时刻1 J2到达。由于时间片仍然由J1掌控,于是等待。 J1在运行了1个时间片后,已经完成了在Q1中的 2个时间片的限制,于是J1置于Q2等待被调度。现在处理机分配给 J2。 3、时刻2 J1进入Q2等待调度,J2获得CPU开始运行。 4、时刻3 J3到达,由于J2的时间片未到,故J3在Q1等待调度,J1也在Q2等待调度。

处理器调度习题(习题教学)

处理器调度 选择题 ?当CPU执行操作系统代码时,则处理机处于( )。 ?A.执行态B.目态C.管态D.就绪态 ?( )是机器指令的扩充,是硬件的首次延伸,是加在硬件上的第一层软件。 ?A.系统调用B.操作系统C.内核D.特权指令 ?操作系统提供给程序员的接口是( )。 ?A.进程B.系统调用C.库函数D.B和C ?用户程序向系统提出使用外设的请求方式是( )。 ?A.作业申请B.原语C.系统调用D.I/O指令 ?当作业正常完成进入完成状态时,操作系统( )。 ?A.将输出该作业的结果并删除内存中的作业 ?B.将收回该作业的所占资源并输出结果 ?C.将收回该作业的所占资源及输出结果,并删除该作业 ?D.将收回该作业的所占资源及输出结果,并将它的控制块从当前的队列中删除 ?下列选项是关于作业和进程关系的描述,其中哪一个是不正确的( )。 ?A.作业的概念主要用在批处理系统中,而进程的概念则用在几乎所有的OS中。 ?B.作业是比进程低一级的概念。 ?C.一个作业至少由一个进程组成。 ?D.作业是用户向计算机提交任务的实体,而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 ?作业从后备作业到被调度程序选中的时间称为( )。 ?周转时间B.响应时间C.等待调度时间D.运行时间 ?设有三个作业J1,J2,J3,它们同时到达,运行时间分别为T1,T2,T3,且T1≤T2≤T3,若它们在一台处理机上按单道运行,采用短作业优先算法,则平均周转时间为( )。 ?A.T1+T2+T3 B.1/3(T1+T2+T3) ?C.T1+2/3T2+1/3T3 D.T1+1/3T2+2/3T3 ?从作业提交给系统到作业完成的时间间隔称为作业的( )。 ?A.中断时间B.等待时间C.周转时间D.响应时间 ?设有四个作业同时到达,每个作业执行时间均为2 h,它们在一台处理机上按单道方式运行,则平均周转时间为( )。 ?A.1 h B.5 h C.2.5 h D.8 h ?FCFS调度算法有利于( )。 ?A.长作业和CPU繁忙型作业B.长作业和I/O繁忙型作业 ?C.短作业和CPU繁忙型作业D.短作业和I/O繁忙型作业 ?下列哪种说法不是SJ(P)F调度算法的缺点( )。 ?A.对于长作业(进程)不利 ?B.未考虑作业(进程)的紧迫程度 ?C.不能有效降低作业(进程)的平均等待时间 ?D.由于根据的是用户提供的估计执行时间,因此不一定真正做到短而优先。 ?选择排队进程中等待时间最长的进程被优先调度,该调度算法是( )。 ?A.先来先服务调度算法B.短进程优先调度算法 ?C.优先权调度算法D.高响应比优先调度算法 ?在采用动态优先权的优先权调度算法中,如果所有进程都具有相同优先权初值,则此时的优先权调度算法实际上和( )相同。 ?A.先来先服务调度算法B.短进程优先调度算法

按优先数调度算法实现处理器调度的模拟设计与实现

实验1 处理器调度 一、实验内容 选择一个调度算法,实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 三、实验题目 按优先数调度算法实现处理器调度的模拟设计与实现。 四、源程序 #include #include using namespace std; //----------------------- struct _proc { char name[32]; struct _proc *next; int run_time; int priority; int state;//就绪为 }; _proc *root; //向就绪队列中插入进程,按照降序 void Insert(_proc* pr) { _proc *q=root;//方便插入,记录插入位置的前面的进程 _proc *p=root->next; if(root->state!=0) { while(p!=NULL)//找插入位置 { if(p->priority>pr->priority)//优先级小于时,继续遍历 { q=p; p=p->next; }

else//找到插入 { break; } } } pr->next=p;//插入 q->next=pr; ++root->state;//进程个数加一 } //创建进程 _proc Creat(char name[],int priority,int run_time) { _proc pr; strcpy(https://www.wendangku.net/doc/1010861720.html,,name); pr.priority=priority; pr.run_time=run_time; pr.state=0; pr.next=NULL; return pr; } //删除就绪队列中对首进程 _proc* Delete() { _proc* pr=root->next; root->next=root->next->next; --root->state; return pr; } //对就绪队列排序,按照降序 void Sort() { if(root->next->run_time==0)//要执行时间为时,从就绪队列中删除该进程{ Delete(); root->next->state=1;

多级反馈队列_实验_操作系统

实验名称:多级反馈队列调度 09091201丁奎荣 一、实验目的: 1、综合应用下列知识点设计并实现操作系统的进程调度,进程状态转换,多组级反馈队列进程调度算法。 2、加深理解操作系统进程调度的过程。 3、加深理解多级反馈队列进程调度算法。 二、实验内容: 1、采用一种熟悉的语言,编制程序,最好采用C/C++,界面设计可采用其它自己喜欢的语言。 2、采用多级反馈队列进程调度算法进行进程调度。 3、每个进程对应一个PCB。在PCB中包括进程标识符pid、进程的状态标志status、进程优先级priority、进程的队列指针next和表示进程生命周期的数据项life(在实际系统中不包括该项)。 4、创建进程时即创建一个PCB,各个进程的pid都是唯一的,pid时在1到100范围的一个整数。可以创建一个下标为1到100的布尔数组,“真”表示下标对应的进程号是空闲的,“假”表示下标对应的进程号已分配给某个进程。 5、进程状态status的取值为“就绪ready”或“运行run”,刚创建时,状态为“ready”。被进程调度程序选中后变为“run”。 6、进程优先级priority是0到49范围内的一个随机整数。 7、生命周期life是1到5范围内的一个随机整数。 8、初始化时,创建一个邻接表,包含50各就绪队列,各就绪队列的进程优先级priority分别是0到49。 9、为了模拟用户动态提交任务的过程,要求动态创建进程。进入进程调度循环后,每次按ctrl+f即动态创建一个过程,然后将该PCB插入就绪队列中。按ctrl+q 退出进程调度循环。 10、在进程调度循环中,每次选择优先级最大的就绪进程来执行。将其状态从就绪变为运行,通过延时一段时间来模拟该进程执行一个时间片的过程,然后优先级减半,生命周期减一。设计图形用户界面GUI,在窗口中显示该进程和其他所

cpu的调度算法

xen调度器比较(转载) 2010-04-30 11:50 Xen的CPU调度算法主要有3种,BVT(borrowed virtual time)调度算法、SEDF (simple earliest deadline first)调度算法、以及Credit调度算法。 一、BVT调度算法 1.BVT调度算法的基本原理 BVT算法由 KermethJ.Duda于1999年提出。BVT是一种公平性优先的调度算法。该算法将时间分为实际时间和虚拟时间:真实时间为硬件计时器记录的时间;虚拟时间为对真实时间经过某种规则计算后得到的时间值。该算法用虚拟时间来监控进程的执行时间,每次总是调度具有最早的有效虚拟时间的VCPU。这这种调度算法考虑到了运行实时和交互件的戍用程序的一些Guest操作系统,允许这些操作系统“借”一些时间片,就是说:在一定范围内将未来分配给它运行的时问片先“借”过来用一段时间。这种“借”过来的虚拟时间片只能是当前真实的时间片中的某个虚拟时间片,不能借下一个真实时间片中的虚拟时问片。在系统初始化时,每个VCPU将分配一个权值来代表该VCPU 能获得的处理器份额。VCPU根据其权值来实现处理器的公平共享。系统用实际虚拟时间和有效虚拟时间来记录VCPU运行状态。其计算方式如下: Ai =At + t/wi Ei <—Ai - (warp?wi:0) 其中,t表示VCPU实际运行时长(由真实时间计算);wi 表示该VCPU的权值大小;Ei表示有效虚拟时间;Ai表示实际虚拟时间;warp为时间偏移标记,表示VCPU能否提前运行;矶为VCPU能提前运行的虚拟时间长度。BVT算法是一种抢占式的working-conserving模式算法。该算法通过warp值来调整EVT使VCPU获得处理器的时间提前,即VCPU从预定的有效虚拟时间中借用了一定的虚拟时间以获得更高的调度优先级。此外,该算法还用Li和Ui来限制VCPU的warp值的大小及进行warp操作的频率,以防止进程过度借用虚拟时间。 2.BVT的优缺点 BVT调度算法的优点在于可以将物理时间片公平、均匀地分配给各个Guest操作系统,每个Guest操作系统两次被调度的时间间隔不会超过一个真实的时间片;能够满足I/O密集型和实时应用的低时延要求,能较好地调度某些实时性要求比较高的操作系统;在单CPU和多CPU环境下的调度开销都比较小。BVT调度算法的缺点有以下几点。首先,BVT不支持non-working-conserving。也就是说,每当当前domain被加载运行时,它将获得整个CPU。用户不能把某个将某个domain对CPU的使用限制在某个比例以下。其次,每个Guest OS只能借用分给它的时间片部分,而不会剥夺其他Guest OS的时间片。即当确定了各个domain的时间片分配比例后,这个比例在下次分配之前不会改变。 二、SEDF调度算法 1.SEDF调度算法的基本原理 SEDF算法源于C.L.Liu在1973年提出的最早截止期限(EDF:Earliest DeadlineFirst)调度算法。Xen中的每个VCPU在初始化时,将由调度算法为该VCPU设定一个截止期限作为其被调度时的参考因素。当进行VCPU调度时,调度程序将优先调度截止期限最早的VCPU。与Credit算法一样,当前对SEDF算法的研究还仅限于对配置有该算法的Xen的性能(磁盘读写速度、网络吞吐量、CPU分配精度、I/O性能)影响进行了分析。 SEDF算法为一种动态

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

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

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

操作系统第三章作业讲解

第三章 作业讲解 1、有5个作业进入就绪队列等待运行,预计它们的运行时间分别为9、6、3、5与X ,它们以什么样的调度顺序运行时会取得最小的响应时间?(答案与X 值有关) 答:短作业优先调度算法是使响应时间最小的调度算法: 0 < X ≤ 3时,调度顺序为: X 、3、5、6、9 3 < X ≤ 5时,调度顺序为: 3、X 、5、6、9 5 < X ≤ 6时,调度顺序为: 3、5、X 、6、9 6 < X ≤ 9时,调度顺序为: 3、5、6、X 、9 X > 9时,调度顺序为: 3、5、6、9、X 2、假设一个系统中有4个进程,它们的到达时间和服务时间如表所示,忽略I/O 以及其他开销时间,若分别按先来先服务(FCFS )、非抢占及抢占的短进程优先(SPF )、高响应比优先(HRRN )、时间片轮转(RR ,时间片=1)、多级反馈队列调度算法(FB ,第i 级队列的时间片=2i-1)进行CPU 调度,请给出各进程的完成时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。 算法 时间 进程 平均时间 A B C D FCFS 完成时间 周转时间 带权周转时间 5 5 1 7 6 3 16 13 1.44 23 1 7 2.43 10.25 1.97 SPF (非抢占) 完成时间 周转时间 带权周转时间 5 5 1 7 6 3 23 20 2.22 14 8 1.14 9.75 1.835 SPF (抢占) 完成时间 周转时间 带权周转时间 7 7 1.4 3 2 1 23 20 2.22 14 8 1.14 9.25 1.435 HRRN 完成时间 周转时间 带权周转时间 5 5 1 7 6 3 16 13 1.44 23 17 2.43 10.25 1.97 RR (q=1) 完成时间 周转时间 带权周转时间 12 12 2.4 4 3 1.5 23 20 2.22 22 16 2.29 12.75 2.1 FB (q=2i-1) 完成时间 周转时间 带权周转时间 13 13 2.6 6 5 2.5 23 20 2.22 21 15 2.14 13.25 2.365 3、若有4个周期性任务,任务A 要求每30ms 执行一次,执行时间为15ms ;任务B 要求每50ms 执行一次,执行时间为5ms ;任务C 要求每50ms 执行一次,执行时间为15ms ;任务D 要求每100ms 执行一次,执行时间为10ms ,应如何按最低松弛度优先算法对它们进行CPU 调试? (要求画出0-150ms 时段的调度时序图,并列出每次切换时每个任务的松弛度) 进程 到达时间 服务时间 A 0 5 B 1 2 C 3 9 D 6 7

相关文档
相关文档 最新文档