操作系统实验报告-进程调度
操作系统进程调度实验报告
实验进程调度实验专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块PCB, PCB用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个PCB实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。
主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架：进程调度过程:3.算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char n ame[10]; float arrivetime; float servicetime; float starttime; float fini shtime; float zztime; float dqzztime; };//定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector vPCE>m_ProcessQueue // 进程输入队列 vector <PCB>m_WaitQueue // 进程就绪队列 Vector <pCB>m_FinishQueue; // 完成队列 vector <PCB>:: iteratorPCB m_runProcess; //运行中的进程.为空I if ( m_WaitQueueemptyO)m_iter ; //迭代器开始判断就绪队 是否为空非空int m_ProcessCount; // 进程数float m_RunTime// 运行时间 int m_tagIsRun ;//是否在运行标志。
操作系统进程调度实验报告.
操作系统(2014年秋季学期) Array实验报告系别：计算机科学与技术班级：数媒12-1班姓名：学号：12101090105实验名称：进程调度总成绩：评语：日期：2020-2-20 3/242020-2-20 4/242020-2-20 5/24六、编译过程截图七、测试用例void fileCreate(char fileName[],int length,char fileKind[]); //创建文件void fileWrite(char fileName[]); //写文件void fileCat(char fileName[]); //读文件void fileRen(char fileName[],char rename[]); //重命名文件void fileFine(char fileName[]); //查询文件void fileDir(char UserName[]); //显示某一用户的所有文件void fileClose(char fileName[]); //关闭已打开的文件void fileDel(char fileName[]); //删除文件void chmod(char fileName[],char kind[]); //修改文件的读写方式int requestDist(int &startPostion,int maxLength); //磁盘分配查询void initDisk(); //初始化磁盘void freeDisk(int startPostion); //磁盘空间释放void diskShow(); //显示磁盘使用情况void print_userTable();//显示用户目录八、实验结果。
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
《操作系统》上机实验报告—进程调度
《操作系统》上机实验报告实验算法主体内容及#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兀。
操作系统进程调度实验报告
实验进程调度实验专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块PCB, PCB用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个PCB实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。
主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架：进程调度过程:3.算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char n ame[10]; float arrivetime; float servicetime; float starttime; float fini shtime; float zztime; float dqzztime; };//定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector vPCE>m_ProcessQueue // 进程输入队列 vector <PCB>m_WaitQueue // 进程就绪队列 Vector <pCB>m_FinishQueue; // 完成队列 vector <PCB>:: iteratorPCB m_runProcess; //运行中的进程.为空I if ( m_WaitQueueemptyO)m_iter ; //迭代器开始判断就绪队 是否为空非空int m_ProcessCount; // 进程数float m_RunTime// 运行时间 int m_tagIsRun ;//是否在运行标志。
操作系统进程调度实验报告
最大）的进程被交换到pcb[0]中。相同优先级的进程只按到
达时间排序
主要代码如下：for (i=0;i<n-1;i++)
//先按到达时间排序
{ for (j=n-2;j>=i;j--)
{ if (pcb[j+1].ReachTime<pcb[j].ReachTime)
{
temp=pcb[j];
pcb[j]=pcb[j+1];
print()打印 pcb[0].state!='F'
N
N Y
结束
图6.attemper( )函数
er( )函数：进程调度函数，调度排完序后存放在pcb[0]中的进程，分配给该进程 CPU，使之运行一个时间片，然后比较进程的剩余时间 (pcb[0].NeedTime-pcb[0].UsedTime)是否小于时间片的大小pTime， 若是，则该进程调度完成，进程处于完成状态，若非，则已用时间加 上一个时间片，进程处于就绪状态继续等待运行，然后调用print( ) 函数打印输出当前进程的状态并排序，直至所有进程处于完成状态后 结束运行 主要代码如下： do{
}
} }
开始 开始
输入pcb[n] 进程信息 sort（）排序 n=n+1 i=0 继续增加进程 输出pcb[i]进程信息 ch=getchar() i=i+1
Y
ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n' i<n
Y
N
N
结束
ch=='Y'||ch=='y'
操作系统实验报告——进程调度
北京邮电大学软件学院2019-2020学年第2学期实验报告课程名称：操作系统实验名称：进程调度实验完成人：日期： 2019 年 11 月 26 日一、实验目的1. 理解 Linux 管理进程所用到的数据结构。
2. 理解 Linux 的进程调度算法的处理逻辑及其实现所用到的数据结构。
二、实验内容1. 通过查阅参考书或者上网找资料，熟悉/usr/src/linux（注意：这里最后一级目录名可能是个含有具体内核版本号和“linux”字符串的名字）下各子目录的内容，即所含 Linux 源代码的情况。
2. 分析 Linux 进程调度有关函数的源代码，主要是 schedule()函数，并且要对它们引用的头文件等一并分析。
3. 实现 Linux 的进程调度算法及理解其实现所用的主要数据结构。
三、实验环境Linux下使用gcc+vscode四、实验过程描述第一部分：源代码分析：所需头文件：#include<linux/sched.h>#include<linux/kernel.h>#include<linux/sys.h>#include<linux/fdreg.h>#include<asm/system.h>#include<asm/io.h>#include<asm/segment.h>#include<signal.h><linux/kernel.h>：内核头文件，含有一些内核常用函数的原形定义。
<linux/fdreg.h>：软驱头文件，含有软盘控制器参数的一些定义。
<linux/sched.h>：调度程序头文件，主要定义了任务结构task_struct、初始任务0的数据，以及一些有关描述符参数设置和获取的嵌入式汇编函数宏语句。
<linux/sys.h>：系统调用头文件，主要是系统调用C函数处理程序。
操作系统进程调度实验报告
学生实验报告姓名：年级专业班级学号成绩
【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意
1.三种进程调度算法的执行结果如下。
(1)FCFS算法
(2)高优先权优先调度算法
(3)时间片轮转调度算法
2.以上三个程序能较好地实现进程的三种调度算法。
(1)用数组元素的顺序输入输出能实现进程的FCFS算法。
(2)用优先权的变化规律描述和冒泡法排序能模拟实现优先权调度算法。
(3)通过数组的运算和利用中间数组能实现时间片轮转调度算法。
3. 虽然以上三个程序能较直观的体现进程基本的三种调度算法，但还是存在一些不足。
(1)如在高优先权调度算中，当同时出现多个进程优先权相同的情况时，程序可能对这些不能选择正确的执行顺序。
改进的方法为添加一个判断，当多个进程的优先权相同时，按FCFS算法执行。
即在程序中表现为按数组元素下标的增大顺序排序。
(2)在时间片轮转算法中，不能一次性的输出进程的调度程度，而要通过多次的输入时间片。
改进的方法为把时间片设置为全局变量，在每次循环时都执行一次。
指导教师签名：
20 年月日
【备注。
进程调度实验报告答案(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，插入到就绪队列相关位置。
分析：动态优先级调度算法能够根据进程的运行情况动态调整优先级，使得优先级高的进程能够得到更多的运行时间，从而提高系统的响应速度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二 进程调度 一、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 二、程序中使用的数据结构及符号说明 按优先数调度算法实现处理器调度的程序 用C语言对其进程的数据结构进行定义如下： struct PCB //定义进程的数据结构 {char name[20]; //进程的名称 char point; //指针 int time; //要求运行时间 int math; //优先数 char state; //状态 }; 使用的调度算法： void diaodu() //核心算法，进程调度算法 {int g,h; struct PCB Y; for(g=0;g for(h=g+1;h if(P[g].math就进行交换 { Y=P[g]; P[g]=P[h]; P[h]=Y; } }
按时间片轮转法实现处理器调度的程序 #define PCB_NUM 10 /* 该程序包含十个PCB */ #define EXAMPLES 3 /* 该程序最多可模拟三个运行着的进程 */ /* 定义进程控制块 */ typedef struct pcb { struct pcb *next; /* 进程的下一个进程 */ char name[20]; /* 进程的名字 */ int time; /* 进程运行的时间 */ }PCB; /* 定义全局变量 */ PCB pcbTable[PCB_NUM]; /* 进程控制表 */ PCB *pcbCurrent = NULL; /* 当前运行的进程 */ PCB *pcbFree = NULL; /* 空闲进程 */ PCB *pcbReady = NULL; /* 就绪进程 */ PCB *pcbReadyRear = NULL; int currentProcesses = 0; /* 当前进程数 */ /* 函数声明 */ void InitPcbTable(); /* 初始化进程表 */ void DisplayIdle(); /* 显示空闲队列 */ int CreateProcesses(); /* 创建进程 */ void DisplayReadys(); /* 显示就绪进程 */ void Run(); PCB* Schedule(); /* 主函数 */ void main() 三、源程序及注释 #include char E; int m=5; //进程的数量 struct PCB //定义进程的数据结构 {char name[20]; //进程的名称 char point; //指针 int time; //要求运行时间 int math; //优先数 char state; //状态 }; struct PCB P[5]={ //定义一个PCB结构的数组，用于存放五个进程 {"p1",'k1',2,3,'R'}, //分别对五个“进程”赋初值 {"p2",'k4',3,5,'R'}, {"p3",'k5',1,3,'R'}, {"p4",'k3',2,4,'R'}, {"p5",'k1',4,6,'R'}}; void diaodu() //核心算法，进程调度算法 {int g,h; struct PCB Y; for(g=0;g for(h=g+1;h if(P[g].math就进行交换 { Y=P[g]; P[g]=P[h]; P[h]=Y; } } void main() //主函数 { int i,j; for(i=0;i printf("%d %s %c %d %c \n",P[i].math,P[i].name,P[i].point,P[i].time,P[i].state); do{ diaodu(); printf("%s\n",P[0].name); P[0].time-2; //每进行一次调度之后，时间和优先级都减2 P[0].math-2; if(P[0].time==0) //对运行时间进行判0，如果为0，则将其状态设为End { P[0].state='E'; P[0].math=0; } for(i=0;iprintf("%d %s %c %d %c \n",P[i].math,P[i].name,P[i].point,P[i].time,P[i].state); }while(P[0].state!='E'||P[1].state!='E'||P[2].state!='E'||P[3].state!='E'||P[4].state!='E'); } #include #include #include /* 定义宏 */ #define PCB_NUM 10 /* 该程序包含十个PCB */ #define EXAMPLES 3 /* 该程序最多可模拟三个运行着的进程 */ /* 定义进程控制块 */ typedef struct pcb { struct pcb *next; /* 进程的下一个进程 */ char name[20]; /* 进程的名字 */ int time; /* 进程运行的时间 */ }PCB; /* 定义全局变量 */ PCB pcbTable[PCB_NUM]; /* 进程控制表 */ PCB *pcbCurrent = NULL; /* 当前运行的进程 */ PCB *pcbFree = NULL; /* 空闲进程 */ PCB *pcbReady = NULL; /* 就绪进程 */ PCB *pcbReadyRear = NULL; int currentProcesses = 0; /* 当前进程数 */ /* 函数声明 */ void InitPcbTable(); /* 初始化进程表 */ void DisplayIdle(); /* 显示空闲队列 */ int CreateProcesses(); /* 创建进程 */ void DisplayReadys(); /* 显示就绪进程 */ void Run(); PCB* Schedule(); /* 主函数 */ void main() { InitPcbTable(); /* 初始化进程表 */ DisplayIdle(); /* 显示空闲进程队列 */ CreateProcesses(); /* 创建一个进程 */ DisplayIdle(); DisplayReadys(); /* 显示就绪进程 */ while(pcbReady != NULL) { pcbCurrent = Schedule(); printf("current process is:%s\n",pcbCurrent->name); Run(); DisplayIdle(); getch(); DisplayReadys(); getch(); } } void InitPcbTable() //初始化进程表函数 { int i = 0; pcbFree = &pcbTable[0]; /* pcbFree是一个指向进程表表头的指针 */
pcbTable[PCB_NUM-1].next = NULL; /* 处理进程表中表尾位置的PCB */ pcbTable[PCB_NUM-1].time = 0; strcpy(pcbTable[PCB_NUM-1].name,"idle");
for(i = 0; i < PCB_NUM-1; i++) /* 处理进程表中除表尾PCB的其余PCB*/ { pcbTable[i].next = &pcbTable[i+1]; pcbTable[i].time = 0; strcpy(pcbTable[i].name,"idle"); } } void DisplayIdle() //显示空闲进程队列函数 { PCB *p = pcbFree; /* p来搜索空闲进程队列 */ printf("number of idles:%d\n", PCB_NUM - currentProcesses); while(p != NULL) { printf("%s ", p->name); p = p->next; } printf("\n"); } int CreateProcesses() //创建进程函数 { PCB *p; int i = 0; for(i = 0; i < EXAMPLES; i++) /* EXAMPLE为最大可模拟的进程数目 */ { if(pcbFree == NULL) /* 当前没有空闲进程，则返回错误信息 */ return(-1); p = pcbFree; pcbFree = pcbFree->next ; printf("enter p %d's name:\n", i); scanf("%s", p->name); printf("enter p %d's time:(1~5)\n", i);