试验一进程调度试验

合集下载

实验一进程调度实验

实验一进程调度实验

实验一,进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.二、实验内容及要求1.编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。

可以采用静态或动态最高优先数优先的算法。

2、编写并调试一个模拟的进程调度程序,采用简单轮转法和多队列轮转法的“轮转法”调度算法对五个进程进行调度。

三、实验主要仪器设备和材料硬件环境:LBM-PC或兼容机软件坏境:C语言编程环境四、实验设计方案及原理每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W (Wait).运行R (Rim)、或完成F (Finish)三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

(静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变;动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。

例如:在进程获得一次CPU后就将其优先数减少1或者,进程等待的时间超过某一时限时增加其优先数的值,等等。

) 简单轮转法的基本思想是:所有就绪进程按FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。

如果运行进程用完它的时间片后还为完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。

直至所有的进程运行完毕。

多队列轮转法的基本思想是:设置多个就绪队列,每个队列的优先级不同,每个队列的CPU 时间片人小不等:一个新的进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度:仅当第一队列空闲时,调度程序才调度第二队列中的进程运行,后面的队列同理。

进程调度实验【实验报告】

进程调度实验【实验报告】

实验一进程调度实验专业:信息管理与信息系统学号:2014******姓名:陈*实验日期:2016年11月11日一、实验目的通过本实验,采用动态优先权优先的调度算法编写和调试一个简单的进程调度程序,加深理解了有关进程控制块、进程队列的概念,并体会了优先权调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验方法内容1.算法设计思路(流程图)开始输入所有进程到一个链表中是否所有进程都已完成结束Yi = 1,m = 0在就绪队列中找到优先级最高的进程,用P1表示,state 设为R用P2指向链表第一个节点P2所指进程state = F ?NP2所指进程state = R ?NPriority – 2,CPUTime + 1,AllTime –1,YAllTime = 0?YNState 设为F ,m = 1CPUTime % StartBlock = 0 ?state 设为B ,m = 1YNP2所指进程state = B ?BolckTime - 1BlockTime = 0?State 设为 W YYN P2所指进程state = W ?NPriority + 1YNP2指向下一个节点P2已指向链表末尾?NYM = 1 ?i <= 2 ?i + 1YNNYNY2.算法中用到的数据结构(1)首先定义一个结构体,用以保存一个进程的各种信息,最后一个指针便于将所有进程形成一个链表typedef struct pcb{int id;int arriveTime; //到达时间int priority;int cpuTime;int allTime;int startBlock;int blockTime;char state;struct pcb *next;}PCB;(2)接着建立一个链表存储所有进程,以结构体PCB为节点(头节点为空节点,从第二个节点开始存储数据)。

进程调度实验报告

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。

三、实验过程。

1. 先来先服务(FCFS)调度算法。

先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。

在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。

实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。

2. 最短作业优先(SJF)调度算法。

最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。

在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。

实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。

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

时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。

在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。

实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。

4. 多级反馈队列(MFQ)调度算法。

多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。

在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。

实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。

四、实验总结。

通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。

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

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

《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的:通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容:用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。

3.设计实现:要求给出设计源码,设计源码要有详细注释,#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据,哪一个进程先来那么该进程就会先执行;最短进程优先调度算法则是以每个进程执行所需时间长短为依据,某一个进程执行所需花的时间要短些那么该进程就先执行。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的1. 加深对进程概念和进程调度算法的理解。

2. 掌握进程调度算法的基本原理和实现方法。

3. 培养编程能力和系统分析能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块(PCB)3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一,负责将CPU分配给就绪队列中的进程。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转(RR)等。

1. 先来先服务(FCFS)算法:按照进程到达就绪队列的顺序进行调度。

2. 短作业优先(SJF)算法:优先调度运行时间最短的进程。

3. 优先级调度算法:根据进程的优先级进行调度,优先级高的进程优先执行。

4. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行,时间片结束后进行调度。

五、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、运行时间、优先级、状态等信息。

2. 创建进程队列,用于存储就绪队列、等待队列和完成队列。

3. 实现进程调度算法:a. FCFS算法:按照进程到达就绪队列的顺序进行调度。

b. SJF算法:优先调度运行时间最短的进程。

c. 优先级调度算法:根据进程的优先级进行调度。

d. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行。

4. 模拟进程调度过程:a. 初始化进程队列,将进程添加到就绪队列。

b. 循环执行调度算法,将CPU分配给就绪队列中的进程。

c. 更新进程状态,统计进程执行时间、等待时间等指标。

d. 当进程完成时,将其移至完成队列。

六、实验结果与分析1. FCFS算法:按照进程到达就绪队列的顺序进行调度,简单易实现,但可能导致短作业等待时间过长。

2. SJF算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。

进程的调度实验报告(3篇)

进程的调度实验报告(3篇)

第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。

二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。

2. 实现三种调度算法:FCFS、RR和DP。

3. 创建一个进程队列,用于存储所有进程。

4. 实现调度函数,根据所选算法选择下一个执行的进程。

5. 模拟进程执行过程,打印进程执行状态和就绪队列。

四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。

操作系统实验一进程调度

操作系统实验一进程调度

操作系统实验一进程调度在计算机科学中,操作系统是管理计算机硬件与软件资源的程序,是计算机系统的内核与基石。

而进程调度作为操作系统的核心功能之一,对于系统的性能和资源利用率起着至关重要的作用。

本次操作系统实验一,我们将深入探讨进程调度的原理和实现。

进程,简单来说,是正在运行的程序的实例。

在多道程序环境下,多个进程可能同时竞争计算机系统的资源,如 CPU、内存、I/O 设备等。

进程调度的任务就是从就绪队列中选择一个合适的进程,并将 CPU 分配给它,以实现资源的合理分配和系统的高效运行。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)、优先级调度等。

先来先服务算法按照进程到达就绪队列的先后顺序进行调度,这种算法简单直观,但可能导致短作业等待时间过长,从而影响系统的整体性能。

短作业优先算法则优先调度运行时间短的进程,能够有效降低平均等待时间,但可能对长作业不利,容易造成“饥饿”现象。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片的 CPU 使用权。

这种算法能够保证每个进程都能得到及时响应,但时间片的大小选择需要权衡系统的开销和响应时间。

优先级调度算法为每个进程赋予一个优先级,优先级高的进程优先获得 CPU 资源。

然而,确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。

在实验中,我们通过模拟实现这些调度算法,来深入理解它们的工作原理和性能特点。

以时间片轮转算法为例,我们首先需要创建一个就绪队列来存放等待调度的进程。

每个进程包含进程 ID、所需运行时间、已运行时间等信息。

在调度过程中,从就绪队列头部取出一个进程,判断其剩余运行时间是否小于等于时间片。

如果是,则该进程运行完毕,从队列中删除;否则,将其已运行时间增加时间片大小,剩余运行时间减少时间片大小,然后将其移到队列尾部,等待下一轮调度。

通过对不同调度算法的模拟实验,我们可以观察到它们在不同场景下的表现。

进程调度实验报告

进程调度实验报告
实际输出数据与预期的输出相同。通过这次试验进一步了解了进程时间片轮转法调度的过程,就是队列的使用学过的时间久了有些生疏,又重新看了数据结构书,请教同学后才写出这个程序。
if(q!=NULL)
{
copy(&q->PCB,&x.PCB);
q->next=NULL;
Q->tail->next=q;
Q->tail=q;
return true;
}
else
return false;
}
LinkQueueNode *deleteq(LinkQueue *Q)//出队
{
int flag;
getchar();
}
printf("******各进程的信息******\n\n");
printf("进程的名字进程的状态进程执行的时间\n");
printf("\n");
display(rq);
display(bq);
}
int QueueState(LinkQueue Q)//判断队列是否为空
{
p->PCB.state=2;
printf("***进程状态为%d\n",p->PCB.state);
p->PCB.cpu_time--;
if(p->PCB.cpu_time>0)
{
p->PCB.state=1;
enterq(&rq,*p);
}
else
free(p);
}
count++;
if(count==counter)

进程调度实验报告答案(3篇)

进程调度实验报告答案(3篇)

第1篇一、实验目的通过本次实验,加深对操作系统进程调度过程的理解,掌握三种基本调度算法(先来先服务(FCFS)、时间片轮转、动态优先级调度)的原理和实现方法,并能够通过编程模拟进程调度过程,分析不同调度算法的性能特点。

二、实验环境1. 操作系统:Linux/Windows2. 编程语言:C/C++3. 开发环境:Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法:FCFS、时间片轮转、动态优先级调度。

2. 编写代码模拟进程调度过程,包括进程创建、进程调度、进程运行、进程结束等环节。

3. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

4. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

四、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。

2. 实现进程调度函数,根据所选调度算法进行进程调度。

3. 编写主函数,初始化进程信息,选择调度算法,并模拟进程调度过程。

4. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

5. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

五、实验结果与分析1. FCFS调度算法实验结果:按照进程到达时间依次调度,每个进程结束后,调度下一个进程。

分析:FCFS调度算法简单,易于实现,但可能会导致进程的响应时间较长,特别是当有大量进程到达时,后到达的进程可能会长时间等待。

2. 时间片轮转调度算法实验结果:每个进程完成一个时间片后,放弃处理机,转到就绪队列队尾。

分析:时间片轮转调度算法能够保证每个进程都能得到一定的运行时间,但可能会出现进程饥饿现象,即某些进程长时间得不到运行。

3. 动态优先级调度算法实验结果:每个进程完成一个时间片后,优先级减1,插入到就绪队列相关位置。

分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。

操作系统进程调度实验

操作系统进程调度实验

操作系统实验报告实验一:进程调度实验学号 2015141443031姓名专业通信工程日期 2016.12.12 、一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

二、进程调度1、进程的状态2、进程的结构——PCB进程都是由一系列操作(动作)所组成,通过这些操作来完成其任务。

因此,不同的进程,其内部操作也不同。

在操作系统中,描述一个进程除了所需要的程序外,最主要的是需要一个与动态过程想联系的数据结构,该数据结构用来描述进程的外部特性(名字、状态等)以及与其他进程的(通信关系)等信息,该数据结构称为进程控制块(PCB、Process Control Block)。

进程控制块PCB与进程一一对应,PCB中记录了系统所需的全部信息、用于描述进程状况所需的全部信息和控制运行所需的全部信息。

因此,系统可以通过进程的PCB来对进程进行管理。

三、试验内容设计一个有N个进程共行的进程调度程序。

进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数以及需要的运行时间可以实现人为的指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加一来表示。

如果运行一个时间片后,进程的已占用CPU 时间已达到所需要的运行时间,则撤销该进程,如果运行一个时间片后进程的已占用CPU 时间还未达到所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减一(即降低一级),然后把它插入就绪队列等待CPU。

单进程调度实验报告

单进程调度实验报告

一、实验目的1. 理解单进程调度算法的基本原理。

2. 掌握单进程调度算法的设计与实现。

3. 分析不同单进程调度算法的性能。

二、实验内容本次实验主要设计了以下三种单进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)和最短剩余时间优先(SRTF)。

1. 先来先服务(FCFS)算法FCFS算法是一种最简单的调度算法,按照进程到达的顺序进行调度。

具体实现步骤如下:(1)创建一个进程队列,用于存储所有就绪进程。

(2)将到达的进程依次加入队列。

(3)从队列中取出第一个进程,分配CPU执行。

(4)执行完成后,将该进程从队列中移除。

2. 最短作业优先(SJF)算法SJF算法根据进程需要的执行时间来调度进程,优先选择执行时间最短的进程。

具体实现步骤如下:(1)创建一个进程队列,用于存储所有就绪进程。

(2)遍历队列,找出执行时间最短的进程。

(3)将选出的进程分配CPU执行。

(4)执行完成后,将该进程从队列中移除。

3. 最短剩余时间优先(SRTF)算法SRTF算法是对SJF算法的改进,它考虑了进程的动态变化。

具体实现步骤如下:(1)创建一个进程队列,用于存储所有就绪进程。

(2)遍历队列,找出剩余执行时间最短的进程。

(3)将选出的进程分配CPU执行。

(4)执行过程中,若队列中有其他进程的剩余执行时间更短,则将当前进程挂起,并将新进程分配CPU执行。

(5)执行完成后,将该进程从队列中移除。

三、实验过程1. 编写单进程调度算法的程序代码。

2. 对比三种算法的性能,包括平均周转时间、平均等待时间和平均带权周转时间。

3. 分析不同算法的优缺点。

四、实验结果与分析1. 实验结果(1)FCFS算法平均周转时间:20.0平均等待时间:10.0平均带权周转时间:1.0(2)SJF算法平均周转时间:15.0平均等待时间:7.5平均带权周转时间:0.75(3)SRTF算法平均周转时间:12.0平均等待时间:6.0平均带权周转时间:0.62. 实验分析(1)FCFS算法FCFS算法简单易实现,但会导致长作业饥饿现象,即长作业在系统中等待时间过长。

进程调度算法实验报告

进程调度算法实验报告

实验报告实验一:进程调度算法一、实验目的1.利用高级语言实现三种不同及进程调度算法:短作业优先算法、时间片轮转调度算法和优先级调度算法。

2.通过实验理解有关进程控制块,进程队列等的概念。

二、实验原理各调度算法思想:1.先来先服务算法(FCFS):按照进程进入就绪队列的先后次序来分配CPU,一旦一个进程占有CPU,就一直运行下去,知道该进程完成工作,才释放CPU。

2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择队列中的第一个进程执行,且仅能执行一个时间片,在使用完一个时间片后,即使进程并未完成其运行,也必须将CPU交给下一个进程;如果一个时间片未使用完就完成了该进程,则剩下的时间分配给下一个进程。

3.优先权调度算法;在创建进程时就确定优先权,确定之后在整个程序运行期间不再改变,根据优先级排列,系统会把CPU分配给优先权最高的进程。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义:PCB块结构体类型struct PCB{int name;int arrivetime; //到达时间int servicetime; //服务时间//int starttime[max]; //开始时间int finishtime; //完成/结束时间int turntime; //周转时间int average_turntime; //带权周转时间int sign; //标志进程是否完成int remain_time; //剩余时间int priority; //优先级}pcb[max];主程序的流程以及各程序模块之间的层次(调用)关系:主程序中从键盘得到进程的数量,创建PCB,调用layout()函数显示选择界面。

Layout()函数中选择相应的算法并调用相关函数如:FCFS()、time_segment();、Priority(),这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。

进程调度 实验报告

进程调度 实验报告
实验一 进程调度 实验报告
一、实验目的 多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那
个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度 问题,加深对进程调度的理解。 二、实验内容 1.优先权法、轮转法
简化假设 1)进程为计算型的(无 I/O) 2)进程状态:ready、running、finish 3)进程需要的 CPU 时间以时间片为单位确定 2.算法描述 1) 优先权法——动态优先权
/*******************优先权调度算法所需函数 *****************************************************/ struct process1*creatlist1(int n) {
srand((int)time(0)); struct process1 *first =new process1; first ->next=NULL; for (int i=0;i<n;i++) {
struct process1 *s; s =new process1; s->pcb =i; s-> privilege=random(20)+5; s->cpu=random(20)+1; insert1(first,s ); } return first; } void insert1(struct process1 *first,struct process1 *s) //插入节点 { struct process1 *p=search(first,s); s->next=p->next; p->next=s; //return; }

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

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

实验报告课程名称计算机操作系统实验名称进程调度算法模拟专业班级计1103学生姓名贾梦洁指导教师王潇潇实验报告课程名称操作系统原理实验名称实验一进程调度算法模拟姓名贾梦洁学号201107010330专业班级计1103实验日期2014年 4月11日成绩指导教师王潇潇一.实验要求:①进程数不少于5个;②进程调度算法任选;可以用动态优先数加时间片轮转法实现进程调度,每运行一个时间片优先数减3;③用C语言编程;④程序运行时显示进程调度过程。

二.实验内容设计一个简单的进程调度算法,模拟OS中的进程调度过程;三.实验步骤:①设计PCB及其数据结构:进程标识数:ID进程优先数:PRIORITY(优先数越大,优先级越高)进程已占用时间片:CPUTIME,每得到一次调度,值加1;进程还需占用时间片:ALLTIME,每得到一次调度,该值减1,一旦运行完毕,ALLTIME为0)进程队列指针:NEXT,用来将PCB排成队列进程状态:STATE(一般为就绪,可以不用)②设计进程就绪队列及数据结构;③设计进程调度算法,并画出程序流程图;④设计输入数据和输出格式;结构格式:当前正运行的进程:0当前就绪队列:2,1,3,4⑤编程上机,验证结果。

假设调度前,系统中有5个进程,其初始状态如下:ID 0 1 2 3 4PRIORITY 9 38 30 29 0 可否考虑用CPUTIME 0 0 0 0 0 数组或链表ALLTIME 3 2 6 3 4去实现STA TE ready ready ready ready ready①以时间片为单位调度运行;②每次调度ALLTIME不为0,且PRIORITY最大的进程运行一个时间片;③上述进程运行后其优先数减3,再修改其CPUTIME和ALLTIME,重复②,③④直到所有进程的ALLTIME均变为0。

实验源代码:#include<stdio.h>#include<malloc.h>typedef int Status;#define ERROR 0#define OK 1typedef struct PCB{char NAME[10]; //进程名字int PRIO; //进程优先数int ROUNT; //轮转时间片int COUNT; //计数器int NEEDTIME; //需要的CPU时间int CPUTIME; //占用cpu时间char *STATE; //进程状态}ElemPCB;typedef struct QNode{ElemPCB pcb;struct QNode *next;}QNode, *QueuePtr;typedef struct{ //就绪队列QueuePtr RUN; //当前运行进程指针QueuePtr READY; //头指针QueuePtr TAIL; //尾指针}READYQueue;typedef struct{ //完成队列QueuePtr FINISH; //头指针QueuePtr TAIL; //尾指针}FINISHQueue;Status Create(READYQueue &ready);Status Print(READYQueue ready,FINISHQueue finish);Status Printr(READYQueue ready,FINISHQueue finish);Status Fisrt(READYQueue &ready);Status Insert1(READYQueue &ready);Status Insert2(READYQueue &ready);Status Prisch(READYQueue &ready,FINISHQueue &finish);Status Roundsch(READYQueue &ready,FINISHQueue &finish);void main(){char ch;READYQueue ready;FINISHQueue finish;ready.READY=ready.TAIL=(QueuePtr)malloc(sizeof(QNode)); //存储分配ready.RUN=(QueuePtr)malloc(sizeof(QNode));ready.RUN->next=NULL;finish.FINISH=finish.TAIL=(QueuePtr)malloc(sizeof(QNode));Create(ready);//创建后就绪对列中printf("\n就绪对列中初始值:\n");Print(ready,finish);Fisrt(ready);printf("请输入要选择调度的算法(p--优先数调度,r--时间片轮转法):\n");while(1){do{ch=getchar();scanf("%c",&ch);}while(ch!='p' && ch!='r');switch(ch){case 'p'://优先数调度Prisch(ready,finish);break;case 'r'://时间片轮转法Roundsch(ready,finish);break;}}}Status Print(READYQueue ready,FINISHQueue finish){ //打印就绪队列中的进程状态QueuePtr p,q;p=ready.READY;q=finish.FINISH;//运行中的进程if(ready.RUN->next!=NULL){printf("%s",ready.RUN->next->);printf(":%s\t",ready.RUN->next->pcb.STATE);printf("优先数:%d\n",ready.RUN->next->pcb.PRIO);}//就绪队列的进程while(p!=ready.TAIL){printf("%s",p->next->);printf(":%s\t",p->next->pcb.STA TE);printf("优先数:%d\n",p->next->pcb.PRIO);p=p->next;}//完成队列的进程while(q!=finish.TAIL){printf("%s",q->next->);printf(":%s\t",q->next->pcb.STA TE);printf("优先数:%d\n",q->next->pcb.PRIO);q=q->next;}return OK;}Status Printr(READYQueue ready,FINISHQueue finish){ //打印就绪队列中的进程状态QueuePtr p,q;p=ready.READY;q=finish.FINISH;//运行中的进程if(ready.RUN->next!=NULL){printf("%s",ready.RUN->next->);printf(":%s\t",ready.RUN->next->pcb.STATE);printf("剩余时间:%d\n",ready.RUN->next->pcb.NEEDTIME);}//就绪队列的进程while(p!=ready.TAIL){printf("%s",p->next->);printf(":%s\t",p->next->pcb.STA TE);printf("剩余时间:%d\n",p->next->pcb.NEEDTIME);p=p->next;}//完成队列的进程while(q!=finish.TAIL){printf("%s",q->next->);printf(":%s\t",q->next->pcb.STA TE);printf("剩余时间:%d\n",q->next->pcb.NEEDTIME);q=q->next;}return OK;}Status Create(READYQueue &ready){QueuePtr p;int n;printf("请输入进程个数:");scanf("%d",&n);while(i<n){p=(QueuePtr)malloc(sizeof(QNode));printf("输入第%d进程名:",i+1);scanf("%s",p->);printf("输入进程需要的时间:");scanf("%d",&p->pcb.NEEDTIME);printf("输入进程的进程优先数:");scanf("%d",&p->pcb.PRIO);p->pcb.STATE="W";p->pcb.ROUNT=2;p->pcb.COUNT=0;i++;p->next=NULL;ready.TAIL->next=p;ready.TAIL=p;}return OK;}Status Fisrt(READYQueue &ready){if(ready.READY==ready.TAIL)return ERROR;ready.RUN->next=ready.READY->next;ready.RUN->next->pcb.STA TE="RUN"; //修改进程状态if(ready.TAIL==ready.READY->next)ready.READY=ready.TAIL;elseready.READY->next=ready.READY->next->next; //头指针后移printf("\n%s被从就绪队列调度运行\n",ready.RUN->next->);}Status Insert1(READYQueue &ready){int i=0,j=0;QueuePtr p=ready.READY,q;ElemPCB temp;QueuePtr s=(QueuePtr)malloc(sizeof(QNode));s->pcb=ready.RUN->next->pcb;s->next=NULL; //将未完成的进程插入就绪队列ready.TAIL->next=s;ready.TAIL=s;//按优先数从大到小排序for(p;p!=ready.TAIL;p=p->next){for(q=p->next;q!=ready.TAIL;q=q->next){if(p->next->pcb.PRIO < q->next->pcb.PRIO){temp=p->next->pcb;p->next->pcb=q->next->pcb;q->next->pcb=temp;}}}return OK;}Status Insert2(READYQueue &ready){QueuePtr p=ready.RUN->next;if(p->pcb.NEEDTIME > 0){ready.TAIL->next=p; //插入到就绪队列ready.TAIL=p;ready.RUN->next=NULL;}return OK;}Status Prisch(READYQueue &ready,FINISHQueue &finish){int i=0 ;while(ready.RUN->next!=NULL){ready.RUN->next->pcb.CPUTIME++;ready.RUN->next->pcb.NEEDTIME--;ready.RUN->next->pcb.PRIO-=3;if(ready.RUN->next->pcb.NEEDTIME==0){finish.TAIL->next=ready.RUN->next; //插入到完成队列finish.TAIL=ready.RUN->next; //尾指针后移ready.RUN->next->pcb.STA TE="FINISH";ready.RUN->next=NULL;if(ready.READY!=ready.TAIL){Fisrt(ready);}}else if(ready.READY != ready.TAIL && (ready.RUN->next->pcb.PRIO) < (ready.READY->next->pcb.PRIO)){ready.RUN->next->pcb.STA TE="W";printf("%s被调到就绪队列里\n",ready.RUN->next->);Insert1(ready);Fisrt(ready);}i++;printf("\n进程执行第%d个时间片的结果:\n",i);Print(ready,finish);}return OK;}Status Roundsch(READYQueue &ready,FINISHQueue &finish){int i=0;while(ready.RUN->next!=NULL){ready.RUN->next->pcb.CPUTIME++;ready.RUN->next->pcb.NEEDTIME--;ready.RUN->next->pcb.COUNT++;if(ready.RUN->next->pcb.NEEDTIME==0){finish.TAIL->next=ready.RUN->next; //插入到完成队列finish.TAIL=ready.RUN->next; //尾指针后移ready.RUN->next->pcb.STA TE="FINISH";ready.RUN->next=NULL;if(ready.READY!=ready.TAIL){Fisrt(ready);}}else if(ready.RUN->next->pcb.COUNT==ready.RUN->next->pcb.ROUNT){ready.RUN->next->pcb.COUNT=0;if(ready.READY != ready.TAIL){ready.RUN->next->pcb.STATE="W";printf("%s被调到就绪队列里\n",ready.RUN->next->);Insert2(ready);Fisrt(ready);}}i++;printf("\n进程执行第%d个时间片的结果:\n",i);Printr(ready,finish);}return OK;}四.实验运行结果:(中间过程截图略)五.实验总结通过这次实验,对于进程调度算法的知识有了更加深刻的掌握。

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

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

实验一进程调度实验专业: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 dqzztime;}; //定义一个结构体,里面包含的有一个进程相关的信息4.主要的常量变量vector<PCB>m_ProcessQueue;//进程输入队列vector<PCB>m_WaitQueue;//进程就绪队列vector<PCB>m_FinishQueue;//完成队列vector<PCB>::iterator m_iter;//迭代器PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。

进程调度实验报告范文

进程调度实验报告范文

进程调度实验报告范文i快鬲紳狡犬爹整芦SHAAN某IUNIVERSITYOFSCIENCE&TECHNOLOG¥操作系统实验报告实验1进程调度算法报告日期:2022-6-10姓名:学号:班级:任课教师:实验1进程调度算法一、实验内容按优先数调度算法实现处理器调度。

二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

三、实验原理设计一个按优先数调度算法实现处理器调度的程序。

假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:进程名指针要求运行时间优先数状态其中,进程名一一作为进程的标识,假设五个进程的进程名分别为Pi,P2,P3,P4,P5。

指针一一按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”要求运行时间一一假设进程需要运行的单位时间数。

优先数一一赋予进程的优先数,调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态,“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。

在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

为了调度方便,把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程,用指针指出队列的连接情况。

例:队首标志K2KiPiK2P2K3P3K4P4K5P5K4K5K3K12312415342RRRRRPCB1PCB2PCB3PCB4PCB5处理器调度总是选队首进程运行。

采用动态改变优先数的办法,进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1、设计分配和归还磁盘空间的程序,能显示或 打印分配的磁盘空间的块号。 2、在完成一次分配或归还后能显示或打印各空 闲块组的情况(各组的空闲块数和块号)。
五、实验报告要求


给出程序中使用的数据结构。 给出源程序,源程序中要附有详细的注释。 给出程序运行时的结果。 总结收获体会及对该题解的改进意见和见解。
三、实验原理

(1) 磁盘空闲块组织: 假定磁盘存储空间已被划分成长度为n的等长 块,共有M块可供使用。UNIX系统中采用空闲 块成组链接的方法来管理磁盘存储空间,将磁 盘中的每N个空闲块(N<M)分成一组,最后一 组可以不足N块,每组的第一块中登记了下一 组空闲块的块数和块号,第一组的块数和块号 登记在专用块中。
实验三 文件管理
一、实验目的和要求

实验目的:使学生深入理解UNIX系统磁盘空 闲空间管理的方式。 实验要求: 要求用C语言设计一个模拟UNIX系统的空闲 块成组链接法:显示分组情况、实现磁盘存储 空间的分配与回收。
二、实验主要内容

设计一个模拟UNபைடு நூலகம்X系统的空闲块成组链接法 对磁盘空间管理。 要求程序实现: 1.实现磁盘存储空间的分配 2.实现磁盘存储空间的回收
三、实验原理
3、磁盘空间的回收: 归还一块时给出归还的块号,若当前组不满 规定块数时,将归还块登记入该组; 若当前组已满,则另建一新组,这时归还块作 为新一组的第一块,应把主存中登记的一组链 接情况MA复制到归还块中,然后在MA重新登记 一个新组。 归还一块的算法如下图。
四、程序是设计要求:
例如:


现模拟UNIX系统的空闲块成组链接,假定共有 8块可供使用,每3块为一组,则空闲块成组链 接的初始状态为: 开始时,空闲块号是顺序排列的,但经若干次 的分配和归还操作后,空闲块的链接就未必按 序排列了。 用二维数组A[M][N] 来模拟管理磁盘空 间,用A[i]表示第I块,第0块A[0]作为专用块。
三、实验原理
2、磁盘空间的分配: 成组链接的分组情况记录在磁盘物理块中,为了查找 链接情况,必须把它们读入主存,故当磁盘初始化后, 系统先将专用块内容复制到主存中。定义一个数组MA 存放专用块内容,即MA: =A[0]。 申请一块磁盘空间时,查MA,从中找出空闲块号,当 一组的空闲块只剩第一块时,则应把该块中指出的下 一组的空闲块数和块号复制到专用块中,然后把该块 分配给申请者。 当一组的空闲块分配完后则把专用块内容(下一组链 接情况)复制到主存,再为申请者分配。分配算法如 下图:
相关文档
最新文档