实验2.1 进程调度
进程调度实验【实验报告】
实验一进程调度实验专业:信息管理与信息系统学号: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为节点(头节点为空节点,从第二个节点开始存储数据)。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。
通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。
就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。
2、调度算法常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。
四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。
在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。
这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后,它将被挂起,等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
实验进程调度
淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:实验一进程管理班级:Z软件52学号:2017140595姓名:郭文静1、实验目的与要求进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C/C++语言编写一个进程调度模拟程序,至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
通过本实验可加深对进程调度算法的理解。
1、设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2、模拟调度程序至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
3、程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
2、实验内容或题目2.1优先级算法说明(1)PCB的结构:优先级算法中,设PCB的结构如右图所示,其中各数据项的含义Array如下:Id:进程标识符号,取值1—5。
Prior:优先级,随机产生,范围5—10。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为1—5。
并随机产生,每运行一个时间片need减1;need为0则进程结束。
Status:进程状态R(运行),J(就绪),F(完成);初始时都处于就绪状态。
Next:指向就绪队列中下一个进程的PCB的指针。
(2)初始状态及就绪队列组织:5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。
各进程的优先级随机产生,范围1—5。
处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head。
(3)调度原则以及运行时间的处理:正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。
进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。
程序中进程的运行时间以逻辑时间片为单位。
2.2时间片轮转算法说明(1)PCB的结构(如下图所示):轮转法中,设PCB的结构如右图所示,其中各数据项的含义如下:Span:在某一轮中,分配给先运行进程的时间片数,取值1—3。
《操作系统》上机实验报告—进程调度
《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态,使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列,并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束,则还需要执行{cpu++;coutvv"运行次数:"vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q;void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;q->round++;q->process=execute;}pcb *get_next(pcb *k,pcb *head){ -pcb *t;t=k; do{t=t->next;}while (t && t->process==finish);if(t==NULL){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。
进程调度算法实验报告
计算机操作系统实验报告实验二进程调度算法一、实验名称:进程调度算法二、实验内容:编程实现如下算法:1.先来先服务算法;2.短进程优先算法;3.时间片轮转调度算法。
三、问题分析与设计:1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法,该算法既可以用于作业调度,也可用于进程调度。
当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将他们调入内存,为它们分配资源、创建进程,然后放入就绪队列。
在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业(进程),2.短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。
而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。
该算法对长作业不利,完全未考虑作业的紧迫程度。
3.时间片轮转算法在时间片轮转算法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
当执行的时间片用完时,由一个计数器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之,系统能在给定的时间内响应所有用户的请求。
实验进程调度的实验报告
一、实验目的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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
实验二 进程调度 实验报告
(1)输入进程数、进程名、要求运行时间、已运行时间以及进程状态,初
始状态都为“就绪”,用“R”表示。当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2)把所有进程按顺序排成循环队列,用指针进行连接。
(3)运行队列中的队首进程,执行一个时间片,同时将该进程的“已运行
时间”+1,同时判断“要求运行时间”和“已运行时间”是否相等,如果相等,则将该进程状态修改为“E”,并退出循环队列,指针指向下一个进程;若不相等,则指针直接指向下一个进程,执行下一个时间片。
3.流程图
五、实验结果和分析(运行结果截图)
问题一
问题二
2.问题二
本题采用的是动态改变响应比的办法。首先根据公式
计算每个进程的响应比即优先数,根据响应比的大小降序排列,响应比大
的进程优先得到服务,每次执行一个时间片。由于本实验是模拟操作系统调
度进程的过程,被选中的进程并不实际的启动运行,而是执行: 要求运行
时间-1、等待时间为0,其它进程等待时间+1。进入下一轮运行时进程重
实验目的如下:
1.利用高级语言模拟进程的时间片轮转调度算法,并熟练掌握。
2.利用高级语言模拟进程的响应比高者优先调度算法,并熟练掌握。
二、实验原理
1.问题一
针对系统的所有进程,首先确定所有进程的要求运行时间(已运行时间初始值为0);将所有进程按顺序排成循环队列,用指针指出队列连接情况,同时另用一个标志单元记录轮到运行的进程,此时以轮转法进行调度;先将CPU分配给队首进程,并令其执行一个时间片,当它运行完毕后,将CPU分配给就绪队列中新的队首进程,让其执行一个时间片,进程每被调度一次,该进程已运行时间+1,同时,判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间已运行时间,则表示它尚未执行结束,应待到下一轮时再运行,若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”,并退出队列。此时,把该进程的进程控制块中的指针值送到前面一个进程的指针位置,直到所有的进程都成为“结束”状态。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。
在多道程序设计环境下,进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。
2.2 最短作业优先(SJF)最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。
2.3 时间片轮转(RR)时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放入就绪队列的末尾,继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能,我们设计了一系列实验。
首先,我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。
最后,我们对实验结果进行分析。
实验结果显示,FCFS算法对于执行时间较长的进程会出现较长的平均等待时间,而SJF算法能够有效减少平均等待时间。
进程的调度实验报告(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("无效的调度算法选择。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
实验一、进程调度实验报告
精选文档广东技术师范学院实验报告学院:计算机科学学专业:计算机科学与班级:成绩:院技术(师范)姓名:学号:组别:组员:实验地点:实验日期:指导教师署名:预习状况操作状况考勤状况数据办理状况实验名称:实验一、进度调动实验一、实验目的用高级语言编写和调试一个进度调动程序,以加深对进度的见解及进度调动算法的理解二、实验种类综合性实验。
综合高级语言编程、进度调动模型、进度调动算法及数据构造等多方面的知识三、实验内容和步骤1.编写并调试一个模拟的进度调动程序,采纳“最高优先数优先”调动算法对五个进度进行调动。
“最高优先数优先”调动算法的基本思想是把CPU 分派给就绪行列中优先数最高的进度。
静态优先数是在创立进度时确立的,并在整个进度运转时期不再改变。
动向优先数是指进度的优先数在创立进度时可以给定一个初始值,而且可以按必然原则改正优先数。
比方:在进度获取一次CPU后就将其优先数减少1。
或许,进度等候的时间超出某一时限时增添其优先数的值,等等该题依据老师给的代码用Visual C++ 运转,结果以及分析以下:结果分析:依据上述输入的三个进度的信息可以获取:优先级最高的是进度cc 最初调动进度 cc 的状态为运转态,需要履行的时间为10 目前就绪行列状态为:进度aa先级比较高,处于就绪行列前面,而进度 bb 先级是三者中最低的,因此处于就绪行列的最后。
而此时这两个进度的状态都为就绪态。
结果分析:当进度 cc 了一个时间片今后而它已占用 CPU 时间已达到所需要的运转时间,则将它的优先级减 1 今后,再将三个进度按优先级的大小摆列,从中选择优先级大的进度进入运转状态,则该次进入运转态的是进度 aa依据这类方式向来运转下去:直到 :结果分析:当进度 bb 的 CPU 占用时间等于它需要的履行时间时,进度 bb 度完成。
则这时进度调动中还有两个进度:进度 aa 进度 cc结果分析:当调动进度中只剩下进度aa 程 cc 这时依据进度优先级的大小,进度aa入运转态。
操作系统实验报告 进程调度
华中师范大学计算机科学系《操作系统》实验报告实验题目:进程调度学生姓名:日期:2011-12-9实验2进程调度【实验目的】(1)通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
(2)了解Windows2000/XP中进程(线程)的调度机制。
(3)学习使用Windows2000/XP中进程(线程)调度算法,掌握相应的与调度有关的Win32 API函数。
【实验内容】在Windows XP、Windows 2000等操作系统下,使用的VC、VB、java或C等编程语言,利用相应的WIN32 API函数,编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。
【实验步骤、过程】(含原理图、流程图、关键代码,或实验过程中的记录、数据等)1、进程调度算法:采用多级反馈队列调度算法。
其基本思想是:当一个新进程进入内在后,首先将它放入第一个队列的末尾,按FCFS原则排队等待高度。
当轮到该进程执行时,如能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚为完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行,以此类推。
2、实验步骤:(1)按先来先服务算法将进程排成就绪队列。
(2)检查所有队列是否为空,若空则退出,否则将队首进程调入执行。
3、流程图:是4、代码:#include<iostream>#include<string>using namespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};//////////////////////////////////////////////////////////////////////////////////////////////////void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法//////////////////////////////////////////////////////////////////////////////////////////////////void main(){int TimePice;int num;cout<<" *********创建进程*********\n"<<endl;cout<<" 输入进程个数:";cin>>num;const int Size =30;Process process[Size] ;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<"\n 输入第"<< i+1<<" 个进程的名字、运行时间和优先级:"<<endl;cin>> name;cin>> CpuTime>> Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}int a;cout<<endl;cout<<" *******输入此进程时间片大小:******: ";cin>>TimePice;cout<<"\n *******选择调度算法:*************\n"<<endl;cout<<"**************************************************************"<<endl; cout<<"* 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先*"<<endl; cout<<"**************************************************************"<<endl; cin>> a;for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" // 说明: 在本程序所列进程信息中,优先级一项是指进程运行后的优先级!! "; cout<<endl; cout<<endl;if(a==1)Fcfs(process,num,TimePice);else if(a==2)TimeTurn( process, num, TimePice);else if(a==3){Sort( process, num);Priority( process , num, TimePice);}else // 最短作业算法,先按时间从小到到排序,再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;}for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;}}void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}//// 先来先服务算法的实现void Fcfs( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}else if(process[num-1].LeftTime<=0){process[num-1].LeftTime=0;cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!\n"<<endl;num--;}else{cout<<endl;process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<=0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<=0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}}cout<<endl;system(" pause");cout<<endl;}}/// 时间片轮转调度算法实现void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}else if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;}elsesystem(" pause");cout<<endl;system(" pause");cout<<endl;}}/// 优先级调度算法的实现void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! \n"<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;// 输出其他进程for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}【实验小结】本次试验的题目——进程管理。
实验报告二 进程调度算法
实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法(SPF)•实现时间片轮转调度算法(RR)二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。
三、实习题目• 1.先来先服务(FCFS)调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。
该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。
• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。
采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
进程调度实验报告
进程调度实验报告1. 引言进程调度是操作系统中一个重要的概念,它决定了各个进程在CPU上运行的次序和时间长度。
合理的进程调度能够提高系统的运行效率和响应速度。
本实验旨在研究不同的进程调度算法对系统性能的影响,并通过实验结果对比评估各个算法的优劣。
2. 实验过程2.1 实验环境搭建在进行实验之前,我们需要搭建一个适合的实验环境。
首先,选择一种操作系统作为实验的基础环境,在这个环境上进行后续步骤。
其次,选择一种编程语言或工具来实现不同的进程调度算法。
最后,准备一组测试用例,包含不同类型的进程和不同长度的时间片等。
2.2 实验步骤以下是实验的具体步骤: 1. 首先,选择合适的进程调度算法,如FCFS、SJF、RR 等。
2. 实现所选算法,并将其应用于测试用例上。
3. 模拟进程的运行过程,记录每个进程的等待时间、周转时间等指标。
4. 重复步骤1~3,使用不同的进程调度算法进行对比实验。
5. 分析实验结果,总结每种算法的优缺点。
2.3 实验数据分析根据实验得到的数据,我们可以对不同的进程调度算法进行分析。
可以从以下几个方面对算法的性能进行评估: - 平均等待时间:衡量了进程等待的时间长度,可以用来评估系统的效率和响应速度。
- 平均周转时间:衡量了进程从被提交到完成执行所经历的时间长度,可以用来评估系统的性能。
- CPU利用率:衡量了CPU 的利用效率,高CPU利用率意味着系统负载较高,可能导致响应速度下降。
- 算法复杂度:考虑到实际应用中所需的计算量,评估进程调度算法的复杂度。
3. 实验结果与讨论3.1 FCFS算法FCFS(First-Come, First-Serve)是最简单的进程调度算法,按照进程提交的顺序进行调度。
它的优点是简单易懂,适用于长作业时间的进程。
然而,它也存在着一些问题,如可能导致饥饿现象和平均周转时间较长。
3.2 SJF算法SJF(Shortest Job First)算法按照进程执行时间的长度进行调度,执行时间最短的进程先执行。
操作系统实验之进程调度报告
实验一:进程调度一、实习内容1.模拟批处理多道操作系统的进程调度;2.模拟实现同步机构避免并发进程执行时可能与时间相关的错误;二、实习目的进程调度时进程管理的主要内容之一,通过设计,编制,调试一个简单的进程调度模拟系统,对进程调度,进程运行状态变换及PV操作加深理解和掌握。
三、实习题目采用剥夺式优先算法,对三个进程进行模拟调度模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。
【提示】(1)对三个进程进行模拟调度,对各进程的优先数静态设置,P1,P2,P3三个进程的优先数为1,2,3,并指定P1的优先数最高,P3的优先数最低,每个进程都处于执行态“e”,就绪态“r”,等待态“w”三种状态之一,并假定初始态为“r”。
(2)每一个进程用一个PCB表,PCB表的内容根据具体情况设置,该系统在运行过程中能显示或打印各进程和参数的变化情况,以便观察各进程的调度。
(3)在完成必要的初始化后,便进入进程调度程序,首先由P1进入执行,当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时,转进程调度。
(4)在进入临界区前后,调PV操作。
(5)如果被唤醒的进程优先数高于现有执行的进程,则剥夺现行进程的执行权。
(6)当三个进程都处于等待状态时,本模拟系统退出执行。
四、示例1.数据结构:(1)进程控制块PCBstruct{int id;char status;int priority;int waiter1;}(2)信号量struct{int value;int waiter2;}sem[2](3)现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈,用来保护被中断时的断点地址等信息。
(4)全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
五、程序框图:六、程序说明:本程序是用C语言编写,模拟三个进程的运行情况,过程在运行中要调用P操作申请信号量,如果该过程得到其申请的信号量,就继续运行,否则P操作阻塞该申请过程的运行,并将过程置为所申请信号量的等待者,如果已有其它过程在等待同一信号量则将该申请过程排在所有等待进程之后。
操作系统实验二进程调度
操作系统实验二进程调度摘要:进程调度是操作系统中重要的功能之一,可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能,用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行,而处理器资源有限,因此需要通过进程调度来合理地安排进程的执行顺序,提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务(FCFS)先来先服务(FCFS)是最简单的调度算法,按照进程到达的顺序进行调度,先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间,容易导致平均等待时间长。
2.最短作业优先(SJF)最短作业优先(SJF)调度算法按照进程所需的CPU时间进行排序,优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间,但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略,将处理器的使用权分割为若干个时间片,每个进程在一个时间片内运行,如果时间片用完仍未运行完,则将该进程放到队列的末尾,并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间,但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度,优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定,不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构:定义进程结构体,包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列:将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法:根据不同的调度算法,实现相应的进程调度算法代码。
可以使用循环遍历进程队列,并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度:在每个时间片结束后,根据调度算法选取下一个要执行的进程,并更新进程的状态和执行时间。
实验2.1进程调度
实验2.1进程调度实验2.1 进程调度一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。
二、实验要求 1.设计进程调度算法,进程数不定2.包含几种调度算法,并加以实现3.输出进程的调度过程——进程的状态、链表等。
三、参考例1.题目——优先权法、轮转法简化假设1)进程为计算型的(无I/O ) 2)进程状态:ready 、running 、finish 3)进程需要的CPU 时间以时间片为单位确定 2.算法描述 1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。
2)轮转法四、实验流程图开始键盘输入进程数n ,和调度方法的选择优先权法?轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?结束NYY注意:1.产生的各种随机数的取值范围加以限制,如所需的CPU 时间限制在1~20之间。
2.进程数n 不要太大通常取4~8个3.使用动态数据结构 4.独立编程5.至少三种调度算法6.若有可能请在图形方式下,将PCB 的调度用图形成动画显示。
五.实验过程:(1)输入:进程流文件(1.txt ),其中存储的是一系列要执行的进程,每个作业包括四个数据项:进程名进程状态(1就绪 2等待 3运行) 所需时间优先数(0级最高) 进程0 1 50 2 进程1 2 10 4 进程2 1 15 0 进程3 3 28 5 进程4 2 19 1 进程5 3 8 7 输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO 算法,优先数调度算法,时间片轮转调度算法产生n需的时间片数,已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0?撤销该进程就绪队列为空吗?=轮转时间片数?NYYY 结束N(2)程序代码#include#include#includeconst int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<maxpcb;i++)< p="">{strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;< p="">}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quant ity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;< p="">cout<<"进程名进程状态所需时间优先数"<<endl;< p="">for(i=0;i<quantity;i++)< p="">{cout<<" "<<pcbs[i].name<<" "<<pcbs[i].privilege<<endl;<="" "<<pcbs[i].status<<"="" "<<pcbs[i].time<<"="" p="">}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<maxpcb;i++)< p="">{pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"********************************************** *******"<<endl;< p="">cout<<"FIFO算法执行流:"<<<"进程名等待时间"<<endl;<=""p="">for(i=0;i<quantity;i++)< p="">{cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;<="" p="">for(j=i+1;j<quantity;j++)< p="">{ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++)< p="">{ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" p="" quantity<<endl;<="" 平均等待时间:"<}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++)< p="">{current_privilege=1000;for(j=0;j<quantity;j++)< p="">{if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privile ge))< p="">{ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"********************************************** *************"<< endl;<="" p="">cout<<"优先数调度执行流:"<<endl;< p="">cout<<"进程名等待时间"<<endl;< p="">for(i=0;i<quantity;i++)< p="">{cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;<="" p="">}total=0;for(i=0;i<quantity;i++)< p="">{ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" p="" quantity<<endl;<="" 平均等待时间:"<}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++)< p="">{if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; } if(number>1){for(i=0;i<quantity;i++)< p="">{if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"********************************************** *********"<<endl;< p="">cout<<"时间片轮转调度执行流:"<<endl;< p="">for(i=0;i<total;i++)< p="">{cout<<pcbs[queue[i]].name<<" ";<="" p="">cout<<endl;< p="">}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<="">//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}(3)运行结果:输入进程流文件名1.txt即可得出以下输出结果:</endl<</endl;<></pcbs[queue[i]].name<<"></total;i++)<></endl;<></endl<<"*************************************************** ****"<<endl;<></quantity;i++)<></quantity;i++)<></total<<"></quantity;i++)<></pcbs[queue[i]].name<<"></quantity;i++)<></endl;<></endl;<></endl<<"*************************************************** ********"<<></current_privilege))<></quantity;j++)<></quantity;i++)<></total<<"></quantity;i++)<></quantity;j++)<></pcbs[i].name<<"></quantity;i++)<></endl<<"*************************************************** **"<<endl;<></maxpcb;i++)<></pcbs[i].name<<"></quantity;i++)<></endl;<></endl;<></endl;<></maxpcb;i++)<>。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验2.1 进程调度一、 实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。
二、 实验要求1. 设计进程调度算法,进程数不定2. 包含几种调度算法,并加以实现3. 输出进程的调度过程——进程的状态、链表等。
三、 参考例1.题目——优先权法、轮转法简化假设1) 进程为计算型的(无I/O )2) 进程状态:ready 、running 、finish3) 进程需要的CPU 时间以时间片为单位确定2.算法描述1) 优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。
2) 轮转法四、 实验流程图 开始 键盘输入进程数n ,和调度方法的选择优先权法? 轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?结束 N YY注意:1.产生的各种随机数的取值范围加以限制,如所需的CPU 时间限制在1~20之间。
2.进程数n 不要太大通常取4~8个3.使用动态数据结构4.独立编程5.至少三种调度算法6.若有可能请在图形方式下,将PCB 的调度用图形成动画显示。
五.实验过程:(1)输入:进程流文件(1.txt ),其中存储的是一系列要执行的进程, 每个作业包括四个数据项:进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO 算法,优先数调度算法,时间片轮转调度算法产生n需的时间片数,已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空吗? =轮转时间片数?NY YY 结束 N(2)程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl; }//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}}(3)运行结果:输入进程流文件名1.txt即可得出以下输出结果:。