当前位置：文档之家 › 进程调度模拟实验

进程调度模拟实验

  • 格式：doc
  • 大小：45.00 KB
  • 文档页数：9

进程调度模拟实验 1.实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度过程的理解。 2.实验内容 用C语言、Pascal语言或其他开发工具实现对N（N=5）个进程的调度模拟，要求至少采用两种不同的调度算法（如简单轮转法Round Robin和优先权高者优先算法Highest Priority First），分别进行模拟调度。 每个用来标识进程的进程控制块PCB用结构（记录）来 描述，根据需要，它包括以下字段： 进程标识数ID。 进程优先数Priority，并规定优先数越大的进程，其优先权越高。采用简单轮转法时该字段无用。 进程已经占用的CPU时间CPUTIME（以时间片为单位，下同）。 进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。 进程被阻塞的时间BLOCKTIME，表示已经阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。 进程状态STATE。 队列指针NEXT，用来将PCB排成队列。 优先数改变的原则（采用简单轮转法时该字段无用）： 进程在就绪队列中等待一个时间片，优先数增加1； 进程每运行一个时间片，优先数减3。 假设在进行调度前，系统中有5个进程，它们的初始状态可以编程输入（更具有灵活性），也可以初始化为如下内容：

ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE 0 9 0 3 2 3 READY 1 38 0 3 -1 0 READY 2 30 0 6 -1 0 READY 3 29 0 3 -1 0 READY 4 0 0 4 -1 0 READY

为了清楚地观察诸进程的调度过程，程序应该将每个时间片内各进程的情况显示出来并暂停，参考格式如下：

运行/Running：I 就绪队列/Ready Queue：Idi，Idj，… 阻塞队列/Block Queue：Idk，Idl，… ====================================================================== 进程号 优先数 已运行时间 需要时间 开始阻塞时间 阻塞时间 状态 0 P0 C0 A0 T0 B0 S0 1 P1 C1 A1 T1 B1 S1 2 P2 C2 A2 T2 B2 S2 3 P3 C3 A3 T3 B3 S3 4 P4 C4 A4 T4 B4 S4 ====================================================================== 3.实验分析和思考 在实际的进程调度中，还有哪些可行的算法，怎样模拟？ 在实际的进程调度中，除了按算法选择下一个运行的进程之外，操作系统还应该做哪些工作？ 为什么对进程的优先数可以按上述原则进行修改？有什么好处？ 4.实验学时安排： 6学时，在调度与死锁内容学习之后进行。

// 模拟操作系统四种进程调度算法（先进先出、短进程优先、高优先权优先、简单时间片轮转） // 本实验可以模拟任意一种，可以自定义进程个数、自定义初始化他们的ＰＣＢ。 //Ｃ＋＋代码：

#include "stdafx.h" #include using std::cout; using std::cin; using std::cerr;

enum Status{running,ready,blocked}; enum Policy{fifo,spf,hpf,rr};

typedef class PCB {//定义ＰＣＢ类。 public: int id,priority,cputime,alltime,startblock,blocktime; Status state; class PCB *next; PCB() { priority=0; } }PCB,*PCBptr,**PCBpp;

char x; PCBpp pp;//两个全局变量

void Print(PCBptr head) {//打印head为头指针的ＰＣＢ链表信息。 PCBptr p; cout<<"\n运行/Running："; for(p=head;p->next;p=p->next) { if(p->next->state==running) { cout<<"ID"id; break; } } cout<<"\n就绪队列/Ready Queue："; for(p=head;p->next;p=p->next) if(p->next->state==ready) cout<<"ID"id<<' '; cout<<"\n阻塞队列/Block Queue："; for(p=head;p->next;p=p->next) if(p->next->state==blocked) cout<<"ID"id<<' ';

cout<<"\n-----------------------------------------------------------------------\n" <<" 进程号 优先数 已运行时间 还需要时间 开始阻塞时间 阻塞时间 状态\n"; for(p=head;p->next;p=p->next) { cout<<" "id<<" "priority<<" "cputime<<" "alltime<<" "startblock<<" "blocktime<<" "; switch(p->next->state) { case ready:cout<<"就绪";break; case running:cout<<"运行";break; case blocked:cout<<"阻塞";break; default:exit(0); } cout<<'\n'; } cout<<"------------------------------------------------------------------------\n" <<"按任意键以继续..."; cin>>x; }

void Delete(PCBptr head,PCBptr p) {//删除以head为头指针的ＰＣＢ链表中p所指向的结点。 PCBptr q=head; while(q->next!=p) q=q->next; q->next=p->next; delete p; }

void InsertSort(PCBpp Rdy,PCBpp RdyEd,Policy algthm) {//直接插入排序。 if(*(Rdy+1))//队列不为空 if(RdyEd-1!=Rdy+1) {//Ready+1队列中不只一个。 switch(algthm) { case hpf: if((*(RdyEd-1))->priority>(*(RdyEd-2))->priority) { PCBpp tt; *Rdy=*(RdyEd-1); *(RdyEd-1)=*(RdyEd-2); for(tt=RdyEd-3;(*Rdy)->priority>(*tt)->priority;tt--) *(tt+1)=*tt; *(tt+1)=*Rdy; } break; case spf: if((*(RdyEd-1))->alltime<(*(RdyEd-2))->alltime) { PCBpp tt; *Rdy=*(RdyEd-1); *(RdyEd-1)=*(RdyEd-2); for(tt=RdyEd-3;(*Rdy)->alltime<(*tt)->alltime;tt--) *(tt+1)=*tt; *(tt+1)=*Rdy; } } } }

void RunToBlk(PCBpp Run,PCBpp &BlkEd) {//定义运行态转为阻塞态。 (*Run)->state=blocked; *BlkEd=*Run; BlkEd++; }

void RdyToRun(PCBpp &Rdy,PCBpp Run,Policy algthm) {//定义就绪态转为运行态。 if(algthm==hpf||algthm==spf) { if(*(Rdy+1)) { (*(Rdy+1))->state=running; *Run=*(Rdy+1); Rdy++; } } else { if(*Rdy) { (*Rdy)->state=running; *Run=*Rdy; Rdy++; } } }

void RunToRdy(PCBpp Run,PCBpp Rdy,PCBpp &RdyEd,Policy algthm) {//定义运行态转为就绪态。 (*Run)->state=ready; *RdyEd=*Run; RdyEd++; if(algthm==hpf||algthm==spf) InsertSort(Rdy,RdyEd,algthm); }

//上面是定义的函数，下面是主函数。 int main() { cout<<"*******************实验开始*******************\n\n需要做几个进程并发执行的实验？"; int n; if(!(cin>>n)) {cerr<<"错误：输入不正确！"; exit(0);}

PCBptr Listhead,Listp,Listq;//建立n个 Listhead=new PCB; // Listp=Listhead; // for(int i=0;i<=n-1;i++) // { Listq=new PCB; // Listp->next=Listq; // Listp=Listq; // } Listp->next=0; //ＰＣＢ的队列。

Policy algorithm; int num1,num2; L1: cout<<"\n请选择算法（０表示ＦＩＦＯ，１表示ＳＰＦ，２表示ＨＰＦ，３表示ＲＲ）：";

合集下载

任务调度实验报告

任务调度实验报告

一、实验目的1. 理解任务调度的基本概念和原理。

2. 掌握任务调度的常用算法和策略。

3. 通过实验，验证任务调度算法的性能和效率。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 任务调度算法：基于优先级、基于时间、基于轮转等。

2. 实验任务：模拟多任务并行执行，测试不同调度算法的性能。

四、实验步骤1. 定义任务类```pythonclass Task:def __init__(self, task_id, arrival_time, execution_time): self.task_id = task_idself.arrival_time = arrival_timeself.execution_time = execution_timeself.finish_time = 0self.wait_time = 0```2. 定义任务调度类```pythonclass TaskScheduler:def __init__(self):self.tasks = []def add_task(self, task):self.tasks.append(task)def schedule_tasks(self, algorithm):passdef get_task_info(self):for task in self.tasks:print(f"Task ID: {task.task_id}, Arrival Time:{task.arrival_time}, Execution Time: {task.execution_time}, Finish Time: {task.finish_time}, Wait Time: {task.wait_time}")```3. 定义基于优先级的调度算法```pythonclass PriorityScheduler(TaskScheduler):def schedule_tasks(self):self.tasks.sort(key=lambda x: x.arrival_time)self.tasks.sort(key=lambda x: x.execution_time, reverse=True)for task in self.tasks:task.finish_time = task.arrival_time + task.execution_timetask.wait_time = task.finish_time - task.arrival_time```4. 定义基于时间的调度算法```pythonclass TimeScheduler(TaskScheduler):def schedule_tasks(self):current_time = 0for task in self.tasks:if task.arrival_time <= current_time:task.finish_time = current_time + task.execution_time task.wait_time = task.finish_time - task.arrival_time current_time = task.finish_time```5. 定义基于轮转的调度算法```pythonclass RoundRobinScheduler(TaskScheduler):def __init__(self, quantum):super().__init__()self.quantum = quantumdef schedule_tasks(self):current_time = 0index = 0while index < len(self.tasks):task = self.tasks[index]if task.arrival_time <= current_time:if task.execution_time <= self.quantum:task.finish_time = current_time +task.execution_timetask.wait_time = task.finish_time -task.arrival_timecurrent_time = task.finish_timeindex += 1else:task.finish_time = current_time + self.quantumtask.wait_time = task.finish_time -task.arrival_timecurrent_time = task.finish_timetask.execution_time -= self.quantumelse:current_time = max(current_time, task.arrival_time) index += 1```6. 添加任务并执行调度```pythonscheduler = PriorityScheduler()scheduler.add_task(Task(1, 0, 5))scheduler.add_task(Task(2, 1, 3))scheduler.add_task(Task(3, 4, 2))scheduler.schedule_tasks()scheduler.get_task_info()```五、实验结果与分析1. 基于优先级的调度算法：任务执行顺序为3, 1, 2，平均等待时间为2.6667。

作业调度实验报告

作业调度实验报告

一、根据调度算法设计流程图：实验
步骤
}
}
}
三、整合完成所有程序并实现作业调度（见源代码）。

四、进行调试阶段，对程序修改优化，进行数据测试。

五、实验结果分析
六、总结
实验
WindowsXP和CV++6.0集成开发环境
环境
实验运行的初始界面：
实验结
果与分
析
测试数据：
a1 1 2 a1
a2 2 3 a2
运行结果：
进行多次循环录入：返回算法选择界面：
测试数据：
b1 2 4 b1
b2 1 3 b2
运行结果：
实验分析和总结：
1）测试的数据必须是符合JCB模块中相同类型的，如在源码中式int类型的，而在测试的时候输入float类型就出错。

2）各个库函数的运用需要掌握相应的功能，否则会照成代码冗余、繁杂、不优化等各种问题。

3）通常在dos下运用的都是英文，而想要用汉字提示就必须考虑一些问题。

在源码中我们用制表符（\t）来控制提示，输出的数字是不能与之对齐的，所以我们要将“\t”改成空格。

4）这编写和调试程序时，为了尽快调通程序应该按照流程图的结构（保证流程图思路是对的情况下）来建立编程思路。

5）此程序也借用了现有的一些代码，并且它还不是最优化的，它还可以进行改进和优化，比如：在回调函数的引用时跳到了另一个页面，见下图：
继续Enter的时候就到下一页：
而不是在同一页面。

6）总之，在编程旅途中是一个很艰辛的过程，要在这里开拓一片蓝天就必须有孜孜不倦的精神。

进程调度(1)优先数调度算法

进程调度(1)优先数调度算法

实验五进程调度（1）优先数调度算法实验目的进程调度是处理器管理的核心内容。

本实验要求用高级语言编写和调试一个简单的进程调度程序，通过本实验加深对进程控制块、进程队列等概念的了解，掌握优先数调度算法和时间片调度算法的具体实施方法。

实验类型综合性实验预习要求已完成进程管理理论课程的学习，了解进程、进程调度的基本概念以及典型进程调度算法的基本思想。

实验设备与环境PII以上电脑一台，已经安装VC++、GCC或其他C语言编译环境实验原理操作系统是计算机系统中必不可少的系统软件。

它是计算机系统中各种资源的管理者和各种活动的组织者、指挥者。

进程调度解决了竞争处理器的问题。

进程调度程序按照某种调度算法从就绪队列中选择一个进程，让它占用处理器。

或者说，进程调度程序把处理器分配给了一个被选中的进程。

所以，有时也把进程调度程序称为“处理器调度”程序。

在优先数调度算法方面：不同的系统确定优先数的方法可以不同，但一般都从任务的紧迫性和系统效率等方面考虑。

例如，让系统进程的优先数大于用户进程的优先数，重要计算问题的进程优先数大于一般计算问题的进程优先数，交互式作业进程的优先数大于批处理作业进程的优先数等。

实验任务设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。

动态优先级法1、设计进程控制块PBC表结构，分别适用优先数调度算法2、 PBC结构通常包括以下信息：进程名、进程优先数、轮转时间片、进程的CPU时间，进程状态等。

根据调度算法不同，PCB结构可作适当的调整。

3、建立进程队列。

对不同的算法编制不同的入链程序。

程序要求达到的运行效果：在设置好进程数量、调度算法后，系统能按设定的参数运行，并在屏幕上交替显示就绪队列和完成队列的进程名等信息。

实验步骤和方法1、数据结构设计：PCB结构：name 进程名pri /round 进程优先数/进程轮转时间片cputime 进程占用的CPU时间needtime 进程到完成还要的时间state 进程状态（假设状态为Ready、Run、Finish）next 链指针2、算法设计时间以时间片为计量单位。

进程调度算法的实现实验报告记录

进程调度算法的实现实验报告记录

进程调度算法的实现实验报告记录————————————————————————————————作者：————————————————————————————————日期：南昌大学实验报告---（4）进程调度算法的实现学生姓名：学号：专业班级：实验类型：□验证□综合■设计□创新实验日期：实验成绩：一、实验目的通过实验加强对进程调度算法的理解和掌握。

二、实验内容编写程序实现进程调度算法，具体可以编写程序实现先来先服务算法或优先度高者调度算法。

三、实验要求1、需写出设计说明；2、设计实现代码及说明；3、运行结果；四、主要实验步骤1、分析实验内容，画出算法流程图；2、根据流程图写出实验代码；3、编译代码，验证结果正确与否；4、对程序进行修改，得到最后结果。

流程图如下：开始系统随机产生数据将数据按照到达时间从小到大排序用户输入数据进程到达时前一个进程是否已经完成完成时间=服务时间+前一个进程完成时间完成时间=服务时间+到达时间周转时间=完成时间-到达时间带权周转时间=完成时间/服务时间是否所有进程已完成计算输出结果结束YN YN YN五、实验数据及处理结果六、实验体会或对改进实验的建议在做这个实验的时候，一开始以为很简单，只要做简单的加减乘除就行了，但是仔细做过以后发现需要考虑很多情况。

比如说输入进程到达时间的时候，要是乱序的该怎么办？还有到达时间和服务时间等等定义的都是整型变量，但是带权周转时间确会得到小数，此时就需要用到强制转换。

在做系统产生随机数的时候也要考虑随机数的范围，如到达时间可以为0，但是服务时间却不能为0，否则带权周转时间的计算会出错。

七、参考资料《计算机操作系统》《计算机操作系统实验指导书》《C程序设计》《C语言程序设计_现代方法》八、实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 5 //进程个数，可改变int rt[N]; //到达时间int st[N]; //服务时间int ct[N]; //完成时间int cyt[N]; //周转时间float rct[N]; //带权周转时间float av[2];int n,m,c=1,which;void line() //美化程序，使程序运行时更加明朗美观{printf("------------------------------------------------------------------\n");}void start() //表示FCFS算法开始{line();printf(" FCFS算法开始\n");printf(" ——Designed by Zhang Hong\n"); line();}void end() //表示FCFS算法结束{line();printf(" FCFS算法结束,谢谢使用\n");line();}void input(){printf("请输入%d个进程的到达时间：",N);for (n=0;n<N;n++)scanf("%d",&rt[n]);printf("请输入%d个进程对应的服务时间：",N);for (n=0;n<N;n++)scanf("%d",&st[n]);}void random(){srand((unsigned)time(NULL));for (n=0;n<N;n++){rt[n]=rand()%100;for (m=0;m<n;m++)if (n!=0 && rt[n]==rt[m]){rt[n]=rand()%100;m=0;}st[n]=rand()%98+1;for (m=0;m<n;m++)if (n!=0 && st[n]==st[m]){st[n]=rand()%98+1;m=0;}}}void ordination() //重新排序，应对出现输入的到达时间为乱序的情况{int temp;for (n=0;n<N;n++)for (m=0;m<N-n-1;m++)if (rt[m+1]<rt[m]){temp=rt[m+1];rt[m+1]=rt[m];rt[m]=temp;temp=st[m+1];st[m+1]=st[m];st[m]=temp;}}void fcfs() //执行fcfs算法{av[0]=0;av[1]=0;ct[0]=rt[0]+st[0];for (n=1;n<N;n++){if (ct[n-1]>=rt[n]) //考虑当前一个进程完成而后一个进程还没有到达的情况ct[n]=ct[n-1]+st[n];elsect[n]=rt[n]+st[n];}for (n=0;n<N;n++)cyt[n]=ct[n]-rt[n];for (n=0;n<N;n++)rct[n]=(float)cyt[n]/(float)st[n];for (n=0;n<N;n++){av[0]+=(float)cyt[n]/N;av[1]+=rct[n]/N;}}void output() //输出结果{line();printf("进程名\t");for (n=0;n<N;n++)printf("\t%c",65+n);printf("\t平均\n到达时间");for (n=0;n<N;n++)printf("\t%d",rt[n]);printf("\n服务时间");for (n=0;n<N;n++)printf("\t%d",st[n]);printf("\n完成时间");for (n=0;n<N;n++)printf("\t%d",ct[n]);printf("\n周转时间");for (n=0;n<N;n++)printf("\t%d",cyt[n]);printf("\t%0.1f",av[0]);printf("\n带权周转时间");for (n=0;n<N;n++)printf("\t%0.1f",rct[n]);printf("\t%0.1f",av[1]);printf("\n");line();}void main(){start();for (;c==1;){for (;;){printf("输入数据还是由系统随机产生数据？\n1、输入数据\t2、系统随机产生数据\n请输入：");scanf("%d",&which);if (which==1){input();break;}elseif (which==2){random();break;}printf("输入错误，请重新输入！");}ordination(); //进程按照到达时间进行排序fcfs();output();printf("继续输入，退出输入。