《操作系统》上机实验报告—进程调度
操作系统实验报告(进程调度)

华中师范大学计算机科学系《操作系统》实验报告实验题目:进程调度学生姓名:日期:2011-12-9实验2进程调度进程完成,撤消该进程就绪队列首进程投入运行 时间片到,运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】(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)是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。
(5)重复步骤(2)、(3)、(4),直到就绪队列为空。
计算机操作系统进程调度实验报告

计算机操作系统进程调度实验报告实验报告:计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。
进程调度作为操作系统的重要功能之一,主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。
本实验旨在通过实践学习进程调度的原理和实现细节,加深对操作系统的理解。
2.实验原理与步骤(1)实验原理:进程调度的目标是充分利用计算机资源,提高系统的吞吐率和响应时间。
常用的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。
在本实验中,我们将实现时间片轮转调度算法,并对比不同算法的性能差异。
(2)实验步骤:1)设计进程数据结构:创建进程控制块(PCB)结构体,包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。
2)生成进程:根据指定的进程个数和服务时间范围,生成随机的进程并初始化进程控制块。
3)时间片轮转调度算法:根据时间片大小,按照轮转调度的方式进行进程调度。
4)性能评估:通过记录进程的等待时间和周转时间,比较不同调度算法的性能差异。
3.实验结果与分析通过实验我们生成了10个进程,并使用时间片大小为2进行轮转调度。
下表列出了各个进程的信息及调度结果。
进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出,时间片轮转调度算法相对公平地分配了CPU给各个进程,减少了等待时间和周转时间。
但是,对于长时间服务的进程,可能出现饥饿问题,即一些耗时较长的进程无法得到充分的CPU时间。
与时间片轮转算法相比,先来先服务(FCFS)算法对于短作业具有更好的响应时间,但可能导致长作业等待时间过长。
最短作业优先(SJF)算法能够最大化短作业的优先级,提高整体性能。
4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节,加深了对操作系统的理解。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了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)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
进程调度操作系统实验报告

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理,通过实际编程和模拟,观察不同调度算法对系统性能的影响,并掌握进程调度的实现方法。
二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一,它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 执行。
这种算法简单直观,但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程,能有效减少平均等待时间,但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成,则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序,优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号(PID)、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行,直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序,放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列,按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的,放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序,放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间=完成时间到达时间带权周转时间=周转时间/服务时间平均周转时间=总周转时间/进程数平均带权周转时间=总带权周转时间/进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
《操作系统》上机实验报告—进程调度
《操作系统》上机实验报告实验算法主体内容及#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兀。
操作系统进程调度实验报告
《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号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.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据,哪一个进程先来那么该进程就会先执行;最短进程优先调度算法则是以每个进程执行所需时间长短为依据,某一个进程执行所需花的时间要短些那么该进程就先执行。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的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("无效的调度算法选择。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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) //显示本轮运行后的进程各状态情况
{
cout<<"进程各状态情况"<<endl;
}
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)
{
pcb *p;
p=get_process();//取得进程队列
int cpu=0;
while(!process_finish(p)) //若进程并未全部结束,则还需要执行
{
cpu++;
cout<<"运行次数:"<<cpu<<endl;
cpuexe(p);//一次cpu的执行
display(p);//显示本次执行结果
cout<<p->priority;
cout<<" ";
switch(p->process) //对枚举类型的输出方法
{
case ready:cout<<"就绪"<<endl;break;
case execute:cout<<"执行"<<endl;break;
case block:cout<<"阻塞"<<endl;break;
int count; //在时间片轮转法中使用的
int round; //在时间片轮转法中使用的
state process; //进程的状态
pcb *next; //指向下一个进程的pcb
};
pcb *get_process() //通过输入各进程的值来建立pcb队列,并返回其首元素的指针
{
pcb *q;
实
验
算
法
主
体
内
容
及
#include<stdio、h>
#include<dos、h>
#include<stdlib、h>
#include<conio、h>
#include<iostream、h>
#define P_NUM 5 //共有5个进程
#define P_TIME 50 //作为优先数计算时所用的值
q->cputime=0;
q->round=0;
q->count=0;
q->process=ready;
q->next=;
if(i==0)
{
p=q;
t=q;
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 * get_process_round()
{
pcb *q;
pcb *t;
pcb *p;
int i=0;
cout<<"请输入进程名与时间"<<endl;
while (i<P_NUM){
q=(struct pcb *)malloc(sizeof(pcb));
cin>>q->name;
cin>>q->needtime;
论
基
础
1、处理机调度的基本概念。
处理器就是计算机系统中的重要资源,处理器调度算法不仅对处理器的利用效率与用户进程的执行有影响,同时还与内存等其她资源的使用密切相关,对整个计算机系统的综合性能指标也有重要影响。
2、进程调度方式:
1、抢占式(剥夺式):
当一个进程正在处理器上运行时,系统可以根据规定的原则剥夺分配给它的处理器,而把处理器分配给其她进程使用。
2、非抢占式(非剥夺式):
一旦某个进程开始执行后便不再出让处理器,除非该进程运行结束或发生了某个事件不能继续执行。
3、本实验所用调度算法
a)优先数调度;
为每个进程设置一个优先数,进程调度程序每次选择就绪队列中优先数最大者占有处理器。
b)循环轮转调度。
基本思想就是:系统确定一个适当大小的时间片,所有进程排成一个就绪队列按时间片轮流使用CPU。又称为时间片轮转法。
《操作系统》上机实验报告
专业与班级
成绩
姓名
学号
课程名称
操作系统
实验名称
进程调度
实
验
目
的
与
要
求
1.进程调度就是处理机管理的核心内容。
2.本实验要求用C语言编写与调试一个简单的进程调度程序。
3.通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会与了解优先数与时间片轮转调度算法的具体实施办法。
理
case finish:cout<<"完成"<<endl;break;
}
p=p->next;
}
}
int process_finish(pcb *q) //判断所有的进程就是否运行结束
{
int b=1;
while(q&&b)
{
b=b&&q->needtime==0;
q=q->next;
}
return b;
pcb *t;
pcb *p;
int i=0;
cout<<"请输入进程名与时间"<<endl;
while(i<P_NUM)
{
q=(struct pcb *)malloc(sizeof(pcb));
cin>>q->name;
cin>>q->needtime;
q->cputime=0;
q->priority=P_TIME-q->needtime;
cout<<"名称"<<" "<<"进入时间"<<" "<<"还需时间"<<" "<<"优先级"<<" "<<"状态"<<endl;
while(p)
{
cout<<p->name;
cout<<" ";
cout<<p->cputime;
cout<<" ";
cout<<p->needtime;
cout<<" ";
enum state{
ready,
execute,
block,
finish
};//进程的状态,使用枚举
struct pcb
{
char name[4]; //进程名称
int priority; //进程优先级
int cputime; //已经占有cpu运行的时间
int needtime; //还需要运行的时间