实验三 进程调度实验指导
进程调度实验报告
进程调度实验报告
实验名称实验三进程调度
⼀.实验⽬的
了解进程的调度机制，掌握短作业优先算法、时间⽚轮转算法（RR）和优先数算法，并理解响应时间和周转时间的意义。
⼆.实验内容
模拟短作业优先算法、时间⽚轮转算法（RR）和优先数算法的执⾏情况，并动态画出其进程执⾏的 Gantt 图，计算以上算法的每个进程的响应时间和周转时间。
三.实验步骤和结果
1、需要模拟执⾏的进程序列如下：
进程名到达时间运⾏时间优先数
P1 0 7 5
P2 1 1 1
P3 1 3 4
P4 2 5 3
P5 4 4 2
假设：优先数越⼩优先级越⾼；所有进程都是纯 CPU 型进程。
请把上表的数据按照你⾃⼰设计的格式存为⼀个⽂本⽂件 JOB1.TXT。
2、编写⼀个模拟程序，可以读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列，然后模拟短作业优先算法、时间⽚轮转算法（RR）和优先数算法的执⾏情况，并动态画出其进程执⾏的 Gantt 图，计算以上算法的每个进程的响应时间和周转时间。
3、读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列，按照短作业优先算法执⾏程序。
4、按照时间⽚轮转算法执⾏程序时间⽚⼤⼩分布为 1、2 和 3。
5、按照优先数算法执⾏程序。
程序执⾏结果见下图：
第1页，共2页
教务处制
四.实验总结
通过这次试验，我们更加深刻地理解了有关于进程调度的内容，响应时间就是进程刚开始被执⾏的时间，等待时间就是进程在就绪队列中等待的时间，周转时间就是进程被执⾏完毕的时间（包括等待进⼊内存的时间，在就绪队列中的等待时间，执⾏时间，I/O时间）。
实验三 模拟进程调度
实验三模拟进程调度一实验目的理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况二实验要求编写一个允许多个进程并发执行的进程调度程序。
1）进程调度算法：进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法，并且采用动态优先数策略，选择进程占用处理器后该进程仅能使用一个时间片，运行完后优先数减1。
2）每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
4）进程的运行时间以时间片为单位进行计算。
5）每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
.6）就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7）如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止三概要设计进程控制块：描述进程的状态信息，用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块图1.进程调度模拟程序模块图算法思想：定义结构体PCB描述进程的进程控制块，定义数组PCB pcb[Max]存放进程。
实验三 进程调度(实验报告格式)
实验三：进程调度一、实验目的（1）理解进程控制块和进程组织方式；（2）掌握时间片轮转调度算法实现处理机调度。
二、实验环境微型计算机，Ubuntu Linux10.04 ，gedit，gcc三、实验内容1建立合理的PCB数据结构，建立含有8个进程结点的就绪队列，每个进程的要求运行时间随机产生，要求每个进程的要求运行时间不大于15。
2 设置时间片大小（3~6），使用时间片轮转调度算法实现处理机调度。
四、实验结果五、源代码#include<stdio.h>#include<time.h>#include<malloc.h>#define T 8#define NUM 10typedef struct PCB{int name;int runtime;int runedtime;int killtime;struct PCB *next;}PCB;PCB *creat_jiuxu(PCB *top){PCB *temp;int i;srand((int)time(0));for(i=0;i<NUM;i++){temp=(PCB *)malloc(sizeof(PCB));temp->name=i;temp->runtime=rand()%15;temp->runedtime=0;temp->next=NULL;temp->killtime=0;if(i==0) top=temp;else{temp->next=top;top=temp;}}return top;}void run(PCB *top){PCB *tail=top;if(tail->next!=NULL)tail=tail->next;PCB *rq=NULL;while(top!=NULL){rq=top;if(rq->runtime<=rq->runedtime+T){printf("process_name:%d,runtime:%d,killtime:%d\n",rq->name,rq->runtime,rq->killtime);/*if(rq!=NULL) free(rq);*/top=top->next;}else{top=top->next;rq->runedtime+=T;rq->killtime++;tail->next=rq;tail=rq;rq->next=NULL;}}return;}int main(){PCB *top=NULL;top=creat_jiuxu(top);run(top);return 0;}。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。
在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。
这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。
2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后，它将被挂起，等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。
山东大学操作系统实验报告3进程调度算法实验
计算机科学与技术学院实验报告
3) 输入make命令编译连接生成可执行的
psched程序$gmake
gcc -g -c experime nt3.c
gcc psched.o -o psched
4)
执行psched程序
分析：
根据以上示例程序和独立实验程序中观察和记录的信息，说明它们反映出操作系统教材中讲解的哪些进程调度调度策略和功能？在真实的操作系统中它是怎样实现教材中讲解的进程调度效果的。
先进先出算法
算法总是把处理机分配给最先进入就绪队列的进程，一个进程一旦分得处理机，便一直执行下去，直到该进程完成或阻塞时，才释放处理机。
最高优先权（FPF）优先调度算法
该算法总是把处理机分配给就绪队列中具有最高优先权的进程。
常用以下两种方法来确定进程的优先权：
轮转法
前几种算法主要用于批处理系统中，不能作为分时系统中的主调度算法，在分时系统中，都采用时间片轮转法。
体会：
1. 实验中定义的函数一定要考虑好函数的参数问题，这样才不会出现一些不必要的错误；
2. 对于一些要忽略的信号要忽略掉，免得影响后面的响应过程。
操作系统实验三：进程调度
实验三进程调度1．目的和要求进程调度是处理机管理的核心内容。
本实验要求用C语言编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。
2．实验内容①设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。
②建立进程就绪队列。
对两种不同算法编制入链子程序。
③编制两种进程调度算法：1）优先数调度；2）循环轮转调度3．实验环境①PC兼容机②Windows、DOS系统、Turbo c 2.0③C语言4．实验提示①本程序用两种算法对五个进程进行调度，每个进程可有三个状态，并假设初始状态为就绪状态。
②为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
③在优先数算法中，优先数可以先取值为50-进程执行时间，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。
在轮转算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了2个单位），这时，CPU时间片数加2，进程还需要的时间片数减2，并排列到就绪队列的尾上。
④对于遇到优先数一致的情况，采用FIFO策略解决。
5.有关实验的改进意见:在实验操作过程中，发现用户输入的数据量太大且每次用户输入的大多数数据为重复数据，因此考虑采用文件输入方式，用户只需指定特定的输入文件的文件名来输入数据。
另一方面，程序的输出量较大，可以考虑采用文件输出的方式来储存程序的运行结果。
也可以用实时的输出界面来输出程序结果。
6.实验过程（1）打开vc++,写入代码并编译，无错；（2）调试源程序，出现一个错误；（3）查找错误，进行修改，删除两个“sleep（5）”，编译并调试均无错；（4）按1是优先数算法，根据提示分别输入三个进程名和所需时间；（5）按2是轮转算法，根据提示分别输入三个进程名和所需时间；（6）按3退出；。
实验进程调度的实验报告
一、实验目的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算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述：进程调度是操作系统中一个重要的组成部分，它负责决定在多个进程同时运行时，每个进程分配到的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．掌握常见的调度算法原理，对系统的性能有什么影响二准备知识1．进程的概念进程是在自身的虚拟地址空间运行的一个单独的程序。
进程与程序是有区别的，虽然它由程序产生。
程序只是一个静态的指令集合，不占系统的运行资源；而进程是一个随时都可能发生变化的、动态的、使用系统运行资源的程序。
而且一个程序可以启动多个进程。
进程是程序执行时的一个实例，从用户的观点来看，进程的目的是担当分配系统资源(CPU 时间，存储器等)的实体，Linux中的关于进程的代码大部分是如何管理进程的代码，每个进程运行的是程序的代码，进程有独立的存储空间，专有的用户空间堆栈。
2．进程的数据结构为了让Linux来管理系统中的进程，每个进程用一个task_struct数据结构来表示（任务与进程在Linux中可以混用）。
数组task包含指向系统中所有task_struct结构的指针.task_struct的主要数据域进程标志符PID进程所占的内存区域相关文件的文件描述符安全信息进程环境信号处理资源安排同步处理3.进程状态进程在执行过程中会根据环境来改变state。
Linux2.4内核进程有以下状态：Running进程处于运行（它是系统的当前进程）或者准备运行状态（它在等待系统将CPU分配给它）。
Waiting进程在等待一个事件或者资源。
Linux将等待进程分成两类；可中断与不可中断。
可中断等待进程可以被信号中断；不可中断等待进程直接在硬件条件等待，并且任何情况下都不可中断。
Stopped进程被停止，通常是通过接收一个信号。
正在被调试的进程可能处于停止状态。
Zombie这是由于某些原因被终止的进程，但是在task数据中仍然保留task_struct结构。
它像一个已经死亡的进程。
4. 相关的系统调用(1)Fork() 通过复制调用进程来建立新的进程，是最基本的进程建立过程(2)Exec() 包括一系列系统调用，它们都是通过用一个新的程序覆盖原来的内存空间，实现进程的转变(3)Wait() 提供初级的进程同步措施，能使一个进程等待，直到另外一个进程结束为止。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三作业（进程）调度实验指导实验目的与要求本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的理解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。
实验预备内容（1）掌握作业或进程调度算法。
（2）平均周转时间和带权平均周转时间计算。
实验内容设定一组作业或进程，给定相关参数，对这组进程或作业按调度算法实施调度，输出调度次序，并计算平均周转时间和带权平均周转时间。
使用的调度算法有：①先来先服务调度算法。
②优先级调度算法。
③短作业（或进程）优先调度算法。
④响应比高优先调度算法使用的主要数据结构：1．定义一个结构体，结构体的主要成员有：序号、作业（进程）号或名称、提交时间、运行时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时间、带权周转时间、运行次序等。
2．利用定义的结构体，定义一个结构体数组，用来记录系统中的作业或进程。
算法描述：1．主控程序算法描述2．数据输入算法3．数据输出算法4．先来先服务调度算法描述5．优先级调度算法6．短作业（或进程）优先调度算法优先级调度算法 在数组中找第一个未运行的作业 Pmin ←该作业的优先数 （当前最小的）k ←该作业的在数组中的下标作业的优先数 与Pnim 比较有未运行的作业未找到找到Pmin ←该作业 的优先数 k ←该作业的 在数组中的下标大小 优先级最高作业的选择算法先来先服务调度算法7．轮转调度算法选择运行时间最短作业的算法 系统中有未运行的作业 在未运行的作业中选择运行时间最短的作业把运行次序填入数组相应位置； 分别计算出该作业进入输入井时间、开始运行时间、运行结束时间、周转时间、带权周转时间，并填入数组相应位置。
调用输出程序，输出结果 短作业（或进程）优先调度算法 轮转调度算法 首次运行运行情况记录开始运行时间 是 否 计算尚需运行时间时间片到 运行结束系统中存在未运行完的作业记录开始时间 计算运行结束时间计算周转时间记录结束次序计算平均周转时间输出结果8．响应比高优先调度算法响应比高优先调度算法用C语言程序实现如下：#include<stdio.h>#include<string.h>#define MAX 10struct task_struct{int number; /*进程编号*/char name[10]; /*进程名称*/float come_time; /*到达时间*/float run_begin_time; /*开始运行时间*/float run_time /*运行时间*/float run_end_time; /*运行结束时间*/int priority; /*优先级*/int order; /*运行次序*/int run_flag; /*调度标志*/}tasks[MAX];int counter; /*实际进程个数*/int fcfs(); /*先来先服务*/int rr(); /*轮转调度*/int ps(); /*优先级调度*//*int mlqs(); /*分级轮转调度*/*//*int mlfqs(); /*分级反馈轮转调度*/*/int sjf(); /*短作业优先*/int hrrn(); /*响应比高优先*/int pinput(); /*进程参数输入*/int poutput(); /*调度结果输出*/void main(){int option;pinput();while(1){printf("请选择调度算法（0~7）:\n");printf("1.先来先服务\n");printf("2.轮转调度\n");printf("3.优先级调度\n");printf("4.短作业优先\n");printf("5.响应比高优先\n");printf("6.分级轮转调度\n");printf("7.分级反馈轮转调度\n");printf("0.退出\n");scanf("%d\n",&option);swich (option){case 0:printf("运行结束。
\n");return;case 1:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 1:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 1:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 2:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 3:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 4:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 5:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 6:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;case 7:printf("对进程按先来先服务调度。
\n");fcfs();poutput();break;default:printf("选择错误，请重选。
\n");break;}}}int fcfs(); /*先来先服务*/{float time_temp=0;int i;time_temp=tasks[0].come_timefor(i=0;i<counter;i++){tasks[i].run_begin_time=time_temp;tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;tasks[i].flag=1;time_temp=tasks[i].run_end_time;tasks[number_schedul].order=i+1;}}int rr(); /*轮转调度*/{float left_time[MAX]; /*用来存放进程剩余的运行时间*/int i,j,k,temp_counter;temp_counter=0;temp_time=tasks[0].come_time;number_schedul=1;for(i=0;i<counter;i++)left_time[i]=tasks[i].come_time;while(temp_counter<counter){for(i=0;(!(tasks[i].flag)||(i<counter)||(tasks[i].come<=temp_time));i++){if(left_time[i]==tasks[i].run_time)tasks[i].run_begin_time=temp_time;left_time[i]=left_time[i]-10;if (left_time[i]<=0){tasks[i].run_end_time=left_time[i]+10+temp_time;tasks[i].order=number_schedul;tasks[i].flag=1;temp_counter++;}}}}int ps(); /*优先级调度*/{float time_temp=0;int i=0,j;int number_schedul,temp_counter;int max_priority;max_priority=tasks[i].priority；j=1;while ((j<counter)||(tasks[i].come_time==tasks[j].come_time)){if (tasks[j].priority>tasks[i].priority){max_priority=tasks[i].priority;i=j;}j++;} /*查找第一个被调度的进程*//*对第一个被调度的进程求相应的参数*/number_schedul=i;tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_sche dul].run_time;tasks[number_schedul].flag=1;time_temp=tasks[number_schedul].run_end_time;tasks[number_schedul].order=1;temp_counter=1;while (temp_counter<counter){max_priority=0;j=0;while((j<counter)||!(tasks[j].flag)||tasks[j].come<=temp_time){if (tasks[j].priority>tasks[i].priority){max_priority=tasks[i].priority;i=j;}j++;} /*查找下一个被调度的进程*//*对找到的下一个被调度的进程求相应的参数*/tasks[number_schedul].run_begin_time=time_temp;tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_sche dul].run_time;tasks[number_schedul].flag=1;time_temp=tasks[number_schedul].run_end_time;temp_counter++;tasks[number_schedul].order=temp_counter;}}/*int mlqs(); /*分级轮转调度*//*{/*}/*int mlfqs(); /*分级反馈轮转调度*//*{/*}int sjf(); /*短作业优先*/{float time_temp=0;int i=0,j;int number_schedul,temp_counter;int run_time;run_time=tasks[i].run_time；j=1;while ((j<counter)||(tasks[i].come_time==tasks[j].come_time)){if (tasks[j].run_time<tasks[i].run_time){run_time=tasks[i].run_time;i=j;}j++;} /*查找第一个被调度的进程*//*对第一个被调度的进程求相应的参数*/number_schedul=i;tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_sche dul].run_time;tasks[number_schedul].flag=1;time_temp=tasks[number_schedul].run_end_time;tasks[number_schedul].order=1;temp_counter=1;while (temp_counter<counter){run_time=tasks[number_schedul].run_time;j=0;while ((j<counter)||(!tasks[j].flag))||(tasks[j].come<=temp_time){if (tasks[j].run_time<run_time){run_time=tasks[j].run_time;number_schedul=j;}j++;} /*查找下一个被调度的进程*//*对找到的下一个被调度的进程求相应的参数*/tasks[number_schedul].run_begin_time=time_temp;tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_sche dul].run_time;tasks[number_schedul].flag=1;time_temp=tasks[number_schedul].run_end_time;temp_counter++;tasks[number_schedul].order=temp_counter;}}int hrrn(); /*响应比高优先*/{int i,j,k,number_schedul;float temp_time,respond_rate,max_respond_rate;/*第一个进程被调度*/tasks[0].run_begin_time=tasks[0].come_time;tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;temp_time=tasks[0].run_end_time;tasks[0].flag=1;tasks[0].order=1;temp_counter=1;/*调度其他进程*/while(temp_counter<counter){max_respond_rate=0;for(j=0;((j<counter)||(tasks[j].come_time<=temp_time)||(!(tasks[j].flag));j++){respond_rate=(temp_time-tasks[j].come)/tasks[j[.run_time;if (respond_rate>max_respond_rate){max_respond_rate=respond_rate;number_schedul=j;}} /*找响应比高的进程*/tasks[number_schedul].run_begin_time=temp_time;tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_sche dul].run_time;temp_time=tasks[number_schedul].run_end_time;tasks[number_schedul].flag=1;temp_counter+=1;tasks[number_schedul].order=temp_counter;}}int pinput(); /*进程参数输入*/{int i;printf("please input the process counter:");scanf("%d",&counter);for(i=0;i<counter;i++){printf("please input the name:");scanf("%s",tasks[i].name);printf("please input the number:");scanf("%d",&tasks[i].number);printf("please input the come_time:");scanf("%f",&tasks[i].come_time);printf("please input the run_time:");scanf("%f",&tasks[i].run_time);printf("please input the priority:");scanf("%d",&tasks[i].priority);tasks[i].run_begin_time=0;tasks[i].run_end_time=0;tasks[i].order=0;tasks[i].run_flag=0;}}int poutput(); /*调度结果输出*/{int i;float turn_round_time=0,f1,w=0;printf("name number come_time run_begin_timerun_time run_end_time priority order turn_round_time\n");scanf("%d",&counter);for(i=0;i<counter;i++){f1=tasks[i].run_end_time-tasks[i].run_begin_time;turn_round_time+=f1;w+=(f1/tasks[i].run_time)printf("%s,%d,%5.2f,%5.2f,%5.2f,%5.2f,%d,%d,%5.2f\n",tasks[i].name, tasks[i].number,tasks[i].come_time,tasks[i].run_begin_time,,tasks[i].run_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);}printf("average_turn_round_timer=%5.2f\n",turn_round_time);printf("weight_average_turn_round_timer=%5.2f\n",w/counter);}。