实验一 单处理器系统进程调度(正确)

一．一、单处理器系统的进程调度1．实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

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

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

2．实验内容与要求（1）设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。

（2）模拟调度程序可任选两种调度算法之一实现。

（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。

3．实验说明设计一个按优先数调度算法实现处理器调度的程序。

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

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

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

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

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

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

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

例：队首标志K2K 1K2K3K4 K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选队首进程运行。

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

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

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。

处理器调度一、实验内容选择一个调度算法，实现处理器调度。

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

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

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

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是R, P2, P3，P4，R。

指针—按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“ 0”。

要求运行时间-- 假设进程需要运行的单位时间数。

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

状态-可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“ R”表示，当一个进程运行结束后，它的状态变为“结束”，用“ E”表示。

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

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志（4）处理器调度总是选队首进程运行。

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

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－ 1 要求运行时间－1来模拟进程的一次运行提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

(5)进程运行一次后，若要求运行时间工0,则再将它加入队列(按优先数大小插入，且置队首标志)；若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。

实验一——单处理器系统的进程调度实验一：进程的建立及调度1．实验目的：加深对进程概念的理解，熟悉PCB的组织，深入了解创建进程的一般过程，掌握用队列组织进程的方法，掌握进程调度算法。

2．实验内容编程实现创建原语，形成就绪队列，模拟实现进程的调度。

具体内容包括：1）、确定进程控制块的内容，用链表组织进程控制块；2）、完成进程创建原语和进程调度原语；3）、要求采用时间片轮转调度算法；4）、编写主函数对所做工作进程测试。

3、实验具体内容和步骤的说明这个实验主要考虑三个问题：如何组织进程、如何创建进程和如何实现处理器调度。

1）、进程的组织：首先就要设定进程控制块的内容。

进程控制块PCB记录各个进程执行时的情况。

不同的操作系统，进程控制块所记录的信息内容不一样。

操作系统功能越强，软件也越庞大，进程控制块所记录的内容也就越多。

本次实验只使用必不可少的信息。

一般操作系统中，无论进程控制块中信息量多少，信息都可以大致分为以下四类：①标识信息每个进程都要有一个惟一的标识符，用来标识进程的存在和区别于其他进程。

这个标识符是必不可少的，可以用符号或编号实现，它必须是操作系统分配的。

本实验中要求，采用编号方式，也就是为每个进程依次分配一个不相同的正整数。

②说明信息用于记录进程的基本情况，例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。

本模拟实验中，因为进程没有数据和程序，仅使用进程控制块模拟进程，所以这部分内容仅包括进程状态。

③现场信息现场信息记录各个寄存器的内容。

当进程由于某种原因让出处理器时，需要将现场信息记录在进程控制块中，当进行进程调度时，从选中进程的进程控制块中读取现场信息进行现场恢复。

现场信息就是处理器的相关寄存器内容，包括通用寄存器、程序计数器和程序状态字寄存器等。

在实验中，可选取几个寄存器作为代表。

用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。

实验一处理器调度之杨若古兰创作一、实验内容选择一个调度算法，实现处理器调度.二、实验目的在采取多道程序设计的零碎中，常常有若干个进程同时处于就绪形态.当就绪形态进程个数大于处理器数时，就必须按照某种计谋来决定哪些进程优先占用途理器.本实验模拟在单处理器情况下处理器调度，帮忙先生加深了解处理器调度的工作.三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定零碎有五个进程，每一个进程用一个进程控制块PCB 来代表.进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是P1，P2，P3，P4，P5.指针----按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最初一个进程中的指针为“0”.请求运转时间----假设进程须要运转的单位时间数.优先数----赋予进程的优先数，调度时老是拔取优先数大的进程先履行.形态----可假设有两种形态，“就绪”形态和“结束“形态，五个进程的初始形态都为“就绪“形态，用“R”暗示，当一个进程运转结束后，它的形态变成“结束”，用“E”暗示.（2）在每次运转你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“请求运转时间”.（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况.例：队首标记（4）处理器调度老是选队首进程运转.采取动态改变优先数的法子，进程每运转一次优先数就减“1”.因为本实验是模拟处理器调度，所以，对被选中的进程其实不实际的启动运转，而是履行：优先数－1请求运转时间－1来模拟进程的一次运转.提醒留意的是：在实际的零碎中，当一个进程被选中运转时，必须恢复进程的现场，它据有处理器运转，直到出现等待事件或运转结束.在这里省去了这些工作.（5）进程运转一次后，若请求运转时间≠0，则再将它加入队列（按优先数大小拔出，且置队首标记）；若请求运转时间=0，则把它的形态点窜为“结束”（），且退出队列.（6）若“就绪”形态的进程队列不为空，则反复上面（4）和（5）的步调，直到所有进程都成为“结束”形态.（7）在所设计的称序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运转一次后进称对列的变更.（8）为五个进程任意确定一组“优先数”和“请求运转时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名和进程控制块的动态变更过程.四、程序中使用的数据结构及符号说明：#define num 5//假定零碎中进程个数为5struct PCB{char ID;//进程名int runtime;//请求运转时间int pri;//优先数char state; //形态，R-就绪，F-结束};struct PCB pcblist[num];//定义进程控制块数组五、流程图：(1)(2)子程序init()(3) 子程序max_pri_process()流程图：(4)子程序show()流程图：(5)子程序run()流程图：//按优先数调度算法实现处理器调度的程序#include "stdio.h"#include "string.h"#define num 5//假定零碎中进程个数为5struct PCB{char ID;//进程名int runtime;//请求运转时间int pri;//优先数char state; //形态，R-就绪，F-结束};struct PCB pcblist[num];//定义进程控制块数组void init()//PCB初始化子程序{int i;for(i=0;i<num;i++){printf("PCB[%d]:ID pri runtime \n",i+1);//为每个进程任意指定pri和runtimescanf("%s%d%d",&pcblist[i].ID,&pcblist[i].pri,&pcblist[i].runtime );pcblist[i].state='R';//进程初始形态均为就绪getchar();//接收回车符}}int max_pri_process()//确定最大优先级进程子程序{int max=-100;//max为最大优先数，初始化为-100int i;int key;for(i=0;i<num;i++){if(pcblist[i].state=='r')//r为辅助形态标记，暗示正在运转return -1;//返回-1elseif(max<pcblist[i].pri&&pcblist[i].state=='R')//从就绪进程中拔取优先数最大的进程{max=pcblist[i].pri;//max存放每次轮回中的最大优先数key=i;//将进程号赋给key}}if(pcblist[key].state=='F')//具有最大优先数的进程若已运转终了return -1;//则返回-1else//否则return key;//将key作为返回值返回}void show()//显示子程序{int i;printf("\n ID pri runtime state\n");printf("-------------------------------------------------\n");for(i=0;i<num;i++)//顺次显示每个进程的名、优先数、请求运转时间和形态{printf("%s%6d%8d %s\n",&pcblist[i].ID,pcblist[i].pri,pcblist[ i].runtime,&pcblist[i].state);}printf(" press any key to continue...\n");}void run()//进程运转子程序{int i,j;int t=0;//t为运转次数for(j=0;j<num;j++){t+=pcblist[j].runtime;}//运转次数即为各个进程运转时间之和printf("\nbefore run,the conditon is:\n");show(); //调用show()子程序显示运转前PCB的情况getchar();//等待输入回车符for(j=0;j<t;j++){while(max_pri_process()!=-1)//具有最大优先数的进程没有运转完，让其运转{pcblist[max_pri_process()].state='r';//将其形态置为r，暗示其正在运转}for(i=0;i<num;i++){if(pcblist[i].state=='r'){ pcblist[i].pri-=1;//将当前运转进程的优先数减1 pcblist[i].runtime--;//请求运转时间减1{if(pcblist[i].runtime==0)pcblist[i].state='F';//运转完则将该进程形态置为结束elsepcblist[i].state='R';//未运转完将其形态置为就绪}show();//显示每次运转后各PCB的情况getchar();//等待回车进入下一次运转} } }}void main()//按动态优先数调度主程序{init();//初始化各个进程PCBrun();//进程调度模拟}七、实验总结本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现，了解到进程与进程控制块之间的联系，进程运转过程中形态和已运转时间的判断和计算，选中运转的进程名和选中进程运转后的各进程控制块形态.。

实验一单处理器调度算法的实现班级：计算机04-1班学号： 04034040112姓名：汀芷约成绩：___ ________日期：_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示：1、假设系统有5个进程，每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中，进程名即是进程标识。

链接指针：指出下一个到达进程的进程控制块首地址。

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时，开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

5、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而是执行：一是估计运行时间减1；二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0，则等待下一轮的运行；若该进程的剩余时间为0，则将该进程的状态置为C，并退出循环队列。

7、若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行为止。

8、在所设计的调度程序中，应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明：数据结构：数组data[][]符号说明：每个进程的状态是就绪 W（Wait）、运行R（Run）、或完成C（Complete）三种状态之一。

实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分，其目的是合理地分配处理机资源，以提高系统的性能和效率。

本次实验的主要目的是通过模拟处理机调度算法，深入理解不同调度算法的工作原理和性能特点，并能够对它们进行比较和分析。

二、实验环境本次实验使用了以下软件和工具：1、操作系统：Windows 102、编程语言：Python3、开发环境：PyCharm三、实验内容1、先来先服务（FCFS）调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。

即先到达的作业或进程先得到处理机的服务。

2、短作业优先（SJF）调度算法短作业优先调度算法优先调度运行时间短的作业或进程。

在实现过程中，需要对作业或进程的运行时间进行预测或已知。

3、高响应比优先（HRRN）调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。

响应比的计算公式为：响应比＝（等待时间＋要求服务时间）／要求服务时间。

4、时间片轮转（RR）调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片，每个作业或进程在一个时间片内运行，当时间片用完后，切换到下一个作业或进程。

四、实验步骤1、设计数据结构为了表示作业或进程，设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。

2、实现调度算法分别实现了上述四种调度算法。

在实现过程中，根据算法的特点进行相应的处理和计算。

3、模拟调度过程创建一组作业或进程，并按照不同的调度算法进行调度。

在调度过程中，更新作业或进程的状态和相关时间参数。

4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标，用于评估不同调度算法的性能。

五、实验结果与分析1、先来先服务（FCFS）调度算法平均周转时间：通过计算所有作业或进程的周转时间之和除以作业或进程的数量，得到平均周转时间。

在 FCFS 算法中，由于按照到达顺序进行调度，可能会导致长作业或进程长时间占用处理机，从而使平均周转时间较长。

淮海工学院计算机工程学院实验报告书课程名：《操作系统原理A》题目：进程调度班级：软件132学号：2013122907姓名：孙莹莹操作系统原理实验——进程调度实验报告一、目的与要求1）进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C 语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。

本实验可加深对进程调度算法的理解。

2）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）3）于2015年4月18日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。

二、实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。

2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。

3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。

4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。

三、实验步骤与源程序（1）流程图（2）实验步骤1）PCB的结构：优先级算法中，设PCB的结构如下图所示，其中各数据项的含义如下：Id：进程标识符号，取值1—5。

Priority：优先级，随机产生，范围1—5。

Used：目前已占用的CPU时间数，初值为0；当该进程被调用执行时，每执行一个时间片，Used加1。

Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，取值范围为5—10。

并随机产生，每运行一个时间片need减1；need为0则进程结束。

Status：进程状态R（运行），W（就绪），F（完成）；初始时都处于就绪状态。

Next：指向就绪队列中下一个进程的PCB的指针。

2）初始状态及就绪队列组织：5个进程初始都处于就绪状态，进程标识1—5，used初值都为0。

各进程的优先级随机产生，范围1—5。

处于就绪状态的进程，用队列加以组织，队列按优先级由高到低依次排列，队首指针设为head，队尾指针为tail。

操作系统单处理机系统的进程调度第一篇：操作系统单处理机系统的进程调度一.实验内容描述1.目的（1）了解Windows内存管理器（2）理解Windows的地址过程2.内容任意给出一个虚拟地址，通过WinDbg观察相关数据并找到其物理地址二.理论分析Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上的最小保护单位 1.Windows内存管理器Windows的内存管理主要由Windows执行体中的虚存管理程序负责，并由环境子系统负责，并由环境子系统负责与具体API相关的一些用户态特性的实现。

虚存管理程序是Windows中负责内存管理的那些子程序和数据结构的集合内存管理器的主要任务是：地址变换：将一个进程的虚拟地址空间转译为物理内存地址交换：当内存不足时，将内存中的有些内容转移到磁盘上，并且以后还要再次将这些内容读回2.Windows内存管理策略Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上最小的保护单位。

根据硬件的体系结构不同，页面尺寸被分为两种，大页面和小页面。

X86系统下小页面为4KB，大页面为4MB。

大页面的优点是：当引用同一页面内其他数据时，地址转移的速度会很快。

不过使用大页面通常要较大的内存空间，而且必须用一个单独的保护项来映射，因此可能会造成出现错误而不引发内存访问违例的情况。

通常PC机都为小页面 3.Windows虚拟地址空间布局 x86结构下的布局方式：默认情况下，32位Windows系统中每个用户进程可以占有2GB 的私有地址空间。

操作系统占有另外的2GB 2GB用户的进程地址空间布局如表：2GB的系统地址空间布局如同：3.虚拟地址转译地址转译是指将进程的虚拟地址空间映射到实际物理页面的过程。

x86系统中地址转译过程如图：关键数据结构如下：页目录：每个进程都有一个页目录，它是内存管理器为了映射进程中所有的页表位置而创建的一个页面。

进程也目录的地址被保存在内核进程快KPROCESS中，在x86系统上，它被映射到虚拟地址0xC0300000，当一个进程正在执行时，CPU可以通过寄存器CR3知道该进程页目录的位置。

操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。

这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。

具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。

然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标，可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。

综合实验一单处理器系统的进程管理一、实验目的1、加深进程概念理解，明确进程与程序区别。

2、理解操作系统中进程的组织、创建和调度等方法。

二、实验内容编写程序完成单处理器系统的进程调度，要求采用时间片轮转法调度策略。

具体内容：1、确定PCB内容及其组织方式。

2、要求模拟进程空闲（新）、就绪、运行、阻塞和完成5个状态。

3、实现进程创建、进程调度、进程阻塞和进程唤醒4个原语。

4、编写主函数对整个系统进程测试。

三、要求和提示三点要求：（1）创建进程的数目任意，可以有上限；不能只有就绪和运行两个状态，包含5各状态。

（2）创建进程需要的信息个数和格式自定，可以通过键盘手工输入，亦可从文件输入，但不允许用随机数。

（3）进程状态切换可以用图形（动画）方式、亦可用文本信息输出方式展示。

三点提示：（1）如何组织进程：●确定PCB内容：标识信息、状态、运行时间、I/O时间（时刻与持续时间）和存储地址等信息、现场信息、管理信息。

●PCB组织方式：相同状态的进程PCB构成一个队列（即有空闲、就绪、运行、阻塞和完成5个队列）。

（4）如何创建进程：●申请PCB（从空闲队列）—> 申请资源—> 填写PCB—>挂就绪队列（5）如何实现处理机调度及进程状态切换：●采用先来先服务（FCFS）调度策略实现进程调度。

●从就绪队列选择一个进程；摘取PCB，挂运行队列；修改状态等●PCB内容；保存现场、恢复现场。

●模拟运行--可以按照两种场景模拟进程运行：（1）可以预先设置好各进程的运行时间、I/O时间、I/O发生的时刻等信息，之后操作系统控制进程运行，实现状态切换，直到全部进程完成。

（2）亦可以采用人工干预方式控制进程状态切换（运行时间已预先设置），比如输入“Esc”进入“阻塞”状态，输入“Enter”则选择（新）进程运行（进程调度），当前进程回到就绪状态;输入“wakeup”,再选择阻塞进程，则被选中的阻塞进程回到就绪状态；输入“finished”，当前进程运行结束，回到完成状态。

实习一处理器调度一.实习内容选择一个调度算法，实现处理器调度。

二.实习目的本实习模拟在单处理器环境下的处理器调度，加深了解处理器调度的工作。

三.实习题目设计一个按优先数调度算法实现处理器调度的程序。

四. 设计思想1.设计思路(1)假定系统有5个进程，每个进程用一个PCB来代表。

(2) 开始运行之前，为每个进程确定它的“优先数”和“要求运行时间”。

通过键盘输入这些参数。

(3) 按进程优先数排列进程，优先数最大的进程插入队首，否者比较进程优先数，插入适当位置。

(4) 处理器总是选择队首进程运行。

采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。

(5) 进程运行一次后，若要求运行时间不等于0，则将它加入就绪队列，否则，将状态改为“结束”，退出就绪队列。

(6) 若就绪队列为空，结束，否则转到(4)重复。

2.主要数据结构struct pcb { /* 定义进程控制块PCB */char name[10]; /*进程名*/char state; /*状态*/int super; /*优先数*/int ntime; /*要求运行时间*/int rtime; /*周转时间*/struct pcb* link; /*下一个进程pcb首地址*/}3.主要代码结构及代码段分析void input() /* 建立进程控制块函数*/{ int i,num;system("cls"); /*清屏*/for(i=1;i<=5;i++){ printf("\n projectNo.%d:\n",i);p=getpch(PCB);printf("\n please input project name:");scanf("%s",p->name);printf("\n please input project priority:");scanf("%d",&p->super);printf("\n please input project running time:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='W';p->link=NULL;sort(); /* 调用sort函数*/}}void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/{p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大插入到当前进程前面*/ {p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}int space()/*求队列长度*/{int l=0;PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n proname\t state\t\t priority\t needtime\t remaintime\n"); printf("| %s\t\t",pr->name);printf("| %c\t\t",pr->state);printf("| %d\t\t",pr->super);printf("| %d\t\t",pr->ntime);printf("| %d\t\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** the running project is:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n **** the ready project state is:\n"); /*显示就绪队列状态*/ while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n project[%s] has finished.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{ (p->rtime)++;if(p->rtime==p->ntime){ p->state='E';printf("\n **** the finished project is:\n");disp(p);destroy();} /* 调用destroy函数*/else{(p->super)--;p->state='W';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("-----------------------------------------------------"); printf("\n now is %d rounds. \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n press any key to continue......\n");}printf("\n\n all projects have finished.\n");getch();/*从键盘获得字符*/}五.上机实习所用平台及相关软件本程序在windows xp平台下，TC2.0编译器编译通过。

一、试验目的熟悉操作系统几种不同的进程调度算法二、试验要求选择一种调度算法，用c＋＋或C语言实现。

每一个进程用一个PCB来表示，请设计合理的PCB结构自行选择合理的调度算法予以实现，如先入先出，时间片轮转，优先级调度均可。

要求输入为进程的基本参数，如进程号，优先级等（请依据调度算法合理选取），输出为进程的调度顺序。

三、试验环境Windows XP visual C++ 6.0四、试验内容程序的main() 函数在CPU_Scheduling.cpp 文件中PCB PCB.h中声明试验中用来表示进程的PCB用c++类实现class PCB{private:/* 编号*/int number ;/* 优先级*/int priority ;/* 已经运行的时间*/int running_time ;/* 将要运行的时间，对系统隐藏,所以不提供外部函数修改和查看*/int total_time ;/*目前的状态(1 - 4)1 : 等待2 : 就绪3 : 运行4 : 终止*/int state ;public:PCB (const int& number,const int priority, const int& total_time, const int& state) ;/*判断是否结束，只查看state*/bool finish() const;/*运行,输出当前运行进程编号，运行时时间running_time增加*/void run() ;/*设置状态*/void set_state(const int& n) ;int get_number() const; //返回进程编号};而调度算法采用了FCFS（先入先执行）和RR（时间片轮转）在测试代码中while (true){WaitForSingleObject(hMutex, INFINITE);if (num <= MAX){if (rand_int(1, 9) == 4 )plist.push_back(PCB(num++, rand_int(1, 10), 5, 2)) ;}ReleaseMutex(hMutex);}表示：假设只要进程总数小于规定的进程数目的最大值，就会随机产生新的进程。

操作系统实验题：设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三、实验内容进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。

每个进程有一个进程控制块（ PCB）表示。

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

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

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

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

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

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

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

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

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。

重复以上过程，直到所要进程都完成为止。

实验二单处理机系统的进程调度一．实验目的（1）加深对进程概念的理解，明确进程与程序的区别。

（2）深入了解系统如何组织进程、创建进程。

（3）进一步认识如何实现处理机调度。

二．实验内容编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。

三．实验原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.四．实验部分源程序#include<stdio.h>#include<time.h>#include<stdlib.h>/*********************以下是全局数据结构和变量***********************//*PCB 结构*/struct PCB{int pname;int pri;int runtime;int waittime;struct PCB *next;}pcb[7];struct PCB *running; /* 运行指针*/struct PCB *Hready; /*高优先级就绪队列头指针*/struct PCB *Lready; /*低优先级队列头指针*/struct PCB*wait; /*等待队列头指针*/int A=0;/**************************以下是函数说明****************************/ void delay(); /*利用循环实现延迟*/void proc(struct PCB *running); /*模拟进程3－9*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*将node插入到head所指示的队列的尾部*/int proc_switch(); /*进程调度函数*/void proc_wait(); /*进程等待函数*/int proc_wakeup(); /*进程唤醒函数*//************************以下是函数定义及注释************************/ main() /*主函数*/{ int i;/*初始化，创建进程3－9，置低优先级，等待时间为0,依次插入低优先级队列*/for(i=0;i<3;i++){pcb[i].pname=i+3;pcb[i].pri=0;pcb[i].waittime=0;InsertIntoQueueTail(&Lready,&pcb[i]);}wait=NULL;Hready=NULL; /*等待队列和高优先级队列为空*/printf("\n模拟进程调度开始:\n"); /*模拟进程调度开始*/for(;;){ switch(A){case 0:/*无进程等待调度，打印信息并返回*/if(!proc_switch()){printf("/n没有进程在运行返回:\n");getchar(); }break;case 1:proc_wait();break;case 3:case 4:case 5:case 6:proc(running); break;default:printf("\nerror!");exit(-1); }}}/*功能：延迟一个时间片*//*入口参数：无*//*出口参数：无*/void delay(){ int i,j;for(i=0;i<20000;i++)for(j=0;j<10000;j++){}}/*功能：进程3－9*//*入口参数：运行指针*//*出口参数：无*/void proc(struct PCB * running){ int i;srand( (unsigned)time( NULL ) );/*显示当前运行的进程的id*/printf("\n现在进程%d 正在运行\n",running->pname);/*当前进程执行running->runtime个时间片*/for(i=running->runtime;i>0;i--){/*显示剩余的时间片*/printf("剩余的时间片为%d\n",i);/*延迟*/delay();proc_wakeup();/*产生一个1到1000的随机数，若该随机数小余300，当前进程等待，*/ if((rand()%1000+1)<300){printf("进程%d开始等待.\n",running->pname);A=1;return; }}/*显示时间片耗尽，进程转为低优先级就绪状态*/printf("进程%d时间片耗尽\n",running->pname);InsertIntoQueueTail(&Lready,running);A=0;return; }/*功能：将一个节点插入队列尾部*//*入口参数：队列头指针地址head，待插入结点node*//*出口参数：无*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node){ struct PCB *p;node->next=NULL;/*被插入队列为空*/if(*head==NULL){*head=node;return; }/*被插入队列不为空*/else{p=*head;/*找到队列的最后一个结点*/while(p->next!=NULL)p=p->next; p->next=node; }}/*功能：进程调度*//*入口参数：无*//*出口参数：若调度成功，返回1，否则返回0*/int proc_switch() {/*若高优先级就绪队列和低优先级就绪队列均为空，则循环执行进程唤醒*/while(Hready == NULL && Lready == NULL)if(!proc_wakeup()) return 0;/*若高优先级就绪队列非空，则执行其第一个进程，分配2个时间片*/if(Hready!=NULL){running=Hready;Hready=Hready->next;running->runtime=2; }/*若高优先级就绪队列为空，则执行低优先级就绪队列的第一个进程，分配5个时间片*/else{running=Lready;Lready=Lready->next;running->runtime=5; }/*把调度进程的id赋给A*/A=running->pname;return 1; }/*功能：进程等待。

广东技术师范学院实验报告学院：计算机科学学院专业：计算机科学与技术（师范）班级：成绩：姓名：学号：组别：组员：实验地点：实验日期：指导教师签名：实验名称：实验一、进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解二、实验类别综合性实验。

综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识三、实验内容和步骤1．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。

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

静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。

动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。

例如：在进程获得一次CPU后就将其优先数减少1。

或者，进程等待的时间超过某一时限时增加其优先数的值，等等该题根据老师给的代码用Visual C++运行，结果以及分析如下：结果分析：根据上述输入的三个进程的信息可以得到：优先级最高的是进程cc 最先调度进程cc的状态为运行态，需要执行的时间为10当前就绪队列状态为：进程aa先级比较高，处于就绪队列前面，而进程bb先级是三者中最低的，所以处于就绪队列的最后。

而此时这两个进程的状态都为就绪态。

结果分析：当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间，则将它的优先级减1之后，再将三个进程按优先级的大小排列，从中选择优先级大的进程进入运行状态，则该次进入运行态的是进程aa按照这种方式一直运行下去：直到:结果分析：当进程bb的CPU占用时间等于它需要的执行时间时，进程bb度完成。

则这时进程调度中还有两个进程：进程aa进程cc结果分析：当调度进程中只剩下进程aa程cc这时根据进程优先级的大小，进程aa入运行态。

当进程aa调度时，进程调度程序中直剩下进程cc这时进程cc进入运行态，而当前就绪队列将为空。

实验一单处理器调度算法的实现班级：计算机04-1班学号： 04034040112姓名：汀芷约成绩：___ ________日期：_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示：1、假设系统有5个进程，每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中，进程名即是进程标识。

链接指针：指出下一个到达进程的进程控制块首地址。

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时，开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

5、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而是执行：一是估计运行时间减1；二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0，则等待下一轮的运行；若该进程的剩余时间为0，则将该进程的状态置为C，并退出循环队列。

7、若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行为止。

8、在所设计的调度程序中，应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明：数据结构：数组data[][]符号说明：每个进程的状态是就绪 W（Wait）、运行R（Run）、或完成C（Complete）三种状态之一。

操作系统模拟实验：单处理机系统进程调度实验报告数学与计算机学院单处理机系统的进程调度实验报告年级07 学号 207429023 姓名成绩专业信计实验地点主楼402 指导教师王硕实验项目单处理机系统的进程调度实验日期实验报告要求：一、实验目的1、加深对进程概念的理解，明确进程和程序的区别。

2、深入了解系统如何组织进程、创建进程。

3、进一步认识如何实现处理机调度。

二、实验原理三、实验要求1、采用时间片轮转调度算法实现进程调度。

2、确定进程控制块的内容，进程控制块的组织方式。

3、完成进程创建原语和进程调度原语。

4、编写主函数对所做工作进行测试。

四、实验结果（程序）及分析^p#i nclude#defi ne N 10 〃系统中所允许的最大进程数量#defi ne SLOT 5 //时间片大小//进程状态枚举typedef enum{}}}}Running, 〃运行状态Aready, 〃就绪状态Block ing //阻塞状态 } ProStatus;//进程控制块 typedef struct{//进程标识符//进程标识符//进程状态//通用寄存器//程序计数器寄存器〃程序状态字寄存器//指向下一个进程的指针ProStatus status; int a,b,c,d; int pc; int psw;int ;} PCB;//就绪队列指针typedef struct{int head; // 头指针int tail; // 尾指针} Ready;//模拟寄存器//PCB的静态链表//PCB的静态链表 PCB pcbArea[N]; int run;Ready ready; int pfree;〃模拟PCB区域的数组〃运行状态程序的指针//就绪队列指针〃空闲队列的指针//初始化运行状态进程指针void Ini tRu n{run=-1;}//初始化就绪状态队列void Ini tReady{ready.head=ready.tail=-1;//初始化空闲队列void In itFree{int temp;for(temp=0;temp<N-1;temp++){pcbArea[temp].=temp+1;}pcbArea[temp].=-1;pfree=0;}//就绪队列出队int PopReady 〃返回结点在PCB区域数组的编号{int temp;if(ready.head==-1){printf(“就绪队列为空，不能出队。

作者：败转头作品编号44122544：GL568877444633106633215458时间：2020.12.13实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。

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

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

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

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB 来代表。

进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是P1，P2，P3，P4，P5。

指针----按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“0”。

要求运行时间----假设进程需要运行的单位时间数。

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

状态----可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“R”表示，当一个进程运行结束后，它的状态变为“结束”，用“E”表示。

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

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志（4）处理器调度总是选队首进程运行。

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

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

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。